王道考研编程题总结

我还在完善中,边复习边完善(这个只是根据我自身总结的) 

一、 线性表

1. 结构体

#define MaxSize 40
typedef struct{
    ElemType data[MaxSize];
    int length;
}SqList

2. 编程题

1.  删除最小值

  • 题意 :从顺序表中删除具有最小值的元素(假设唯一)并由函数返回被删函数的值,空出的位置由最后一个元素填补,若顺序表为空,则显示出错信息并退出运行。
  • 思路 :搜索整个顺序表,查找最小值元素并记住其位置,搜索结束后用最后一个元素填补空出的原最小值元素的位置。

【注意】:别忘了边界条件和线性表长度要-1,因为属于改变线性表内容,所以传进去的是地址

bool Delete(SqList &L, ElemType &x) //此处不能用int,因为不明确是啥类型
{
    /*
    1. 判断是否为空
    2. 删除最小值,若线性表只有一个数,则返回
    3. 用最后一个位置填补空出的位置
    */
    if(L.length == 0) return false;
    int ElemType = L.data[0];
    int pos = 0;
    for(int i = 1; i < L.length; i ++)
    {
        if(L.data[i] < x)
        {
            x = L.data[i];
            pos = i;
        }
    }
    L.length --;
    //if(L.length == 0) return true; 该步可以不用要(不需要太注意题目未提的边界)
    L.data[pos] = L.data[L.length];
    return true;
}

2. 元素逆置

void Reverse(SqList &L)
{
    int l = 0, r = L.length-1;
    while(l < r)
    {
        int temp = L.data[l];
        L.data[l] = L.data[r];
        L.data[r] = temp;
        r --; l ++;
    }
}

3. 删除所有值为x的数

别忘了更新长度,以及&符

/*
用cnt统计值不为x的数字的个数,当遍历到某数(值不为x)时,将其移动到线性表中表cnt-1的位置。
*/

void Delete_x(SqList &L, int x)
{
    int cnt = 0;
    for(int i = 0; i < L.length; i ++)
    {
        if(L.data[i] != x)
        {
            cnt ++;
            L.data[cnt-1] = L.data[i];
        }
    }
    L.length = cnt; //不要忘了更新长度
}

5. 删除所有值重复的元素

题目已说是有序的

/*
与第三题的思想一致
用cnt记录未重复的元素的个数
初始时视第一个数为不重复的数,从左向右移动,若该数与前一个数不相同,则可视为不重复的数。
若该数为第cnt个不重复的数,则将其插入到数组中的第cnt个位置上
*/

void DisSame(SqList &L)
{
    int cnt = 1;
    for(int i = 1; i < L.length; i ++)
    {
        if(L.data[i] != L.data[i-1])
        {
            cnt ++;
            L.data[cnt-1] = L.data[i];
        }
    }
    L.length = cnt; //不要忘了更新长度
}

10. 数组的循环左移

/*
法一,利用公式i=(i-p+n)%n(需要开辅助数组)
正解:翻转三次
*/

void Reverse(int a[], int l, int r)
{
    for(int i = 0; i < (r-l+1)/2; i ++) //不是等于(利用正数第i与倒数第i的思想)
    {
        int temp = a[r-i];
        a[r-i] = a[l+i]
        a[l+i] = temp;
    }
}

void LeftMove(int a[], int n, int p)
{
    Reverse(a, 0, p-1);
    Reverse(a, p, n-1);
    Reverse(a, 0, n-1);
}

二、 链表

1. 结构体

typedef struct LNode
{
    ElemType data;
    struct LNode *next;
}LNode, *LinkList;

2. 基础用法

要注意的地方

定义完一个指针后(LNode *q)

如果需要给它赋值(即需要使用空间)

需要这样做

q = (LNode*)malloc(sizeof(LNode));

1. 初始化

bool InitList(LinkList &L)
{
    L = (LNode*)malloc(sizeof(LNode)); //创建头结点
    L->next = NULL;
    return true;
}

 2. 头插法

//头插法建立单链表(倒序)
void HeadInsert(LinkList &L)
{
    LNode *q; int x;
    int n; scanf("%d", &n);
    for(int i = 0; i < n; i ++)
    {
        scanf("%d", &x);
        q = (LNode*)malloc(sizeof(LNode));
        q->data = x;
        q->next = L->next;
        L->next = q;
    }
}

3. 尾插法 

//尾插法(正序)
void TailInsert(LinkList &L)
{
    LNode *q, *p; 
    int x;
    p = L;
    int n; scanf("%d", &n);
    for(int i = 0; i < n; i ++)
    {
        scanf("%d", &x);
        q = (LNode*)malloc(sizeof(LNode)); //这步不能省,要赋值的指针就需要开空间
        q->data = x;
        p->next = q;
        p = q;
    }
    p->next = NULL;
}

3. 编程题 

1. 找中间结点

算法思想:设置两个指针p和q,指针p每次走一步,指针q每次走两步,当指针q到达链尾时,指针p恰好在链表的中间结点

【注意】最后可能不足两步,故要看临界条件

void work(LNode *h)
{
    LNode *p, *q;
    //寻找中间结点
    p = q = h;
    while(q->next != NULL)
    {
        p = p->next; //p走一步
        q = q->next;
        if(q->next != NULL) 
            q = q->next; //q走两步
    }
}

17. 找倒数第k个位置的结点

/*
算法思想
指针p先向前走k步走到第k个结点时,令指针q指向头结点,随后让指针p和指针q同时向后走,
当指针p走到尾时,指针q所指向的结点即为倒数第k个位置的结点
当指针p还未走到第k个结点就到链表尾,则返回0
*/

bool Find(LinkList L, int k)
{
    LNode *p, *q;
    p = q = L;
    for(int i = 0; i < k; i ++)
    {
        p = p->next;
        if(!p) return 0;
    }
    while(p != NULL)
    {
        p = p->next;
        q = q->next;
    }
    printf("%d", q->data);
    return 1;
}

 2. 将某段链表逆置

利用头插法的思想

题目:将一个链表(已经插好的)进行逆置

void reverse(LNode *h)
{
    LNode *p = h->next; //p指向链表的第一个结点,同时也是逆转后的最后一个结点
    if(p == NULL) return ;
    LNode *q = p->next;
    while(q != NULL)
    {
        p->next = q->next; //将q摘下
        q->next = h->next;
        h->next = q; //将q插入头结点
        q = p->next; //更新
    }
}

18. 公共后缀的起始位置

要注意,主函数中,传的参数是指针,返回的也是指针类型

/*
算法思想:
指针p、q分别指向两个单词所在链表的头节点,遍历一遍链表,分别得到两个链表的长度,
假设一个链表比另一个链表的长度长k,那么指向该链表的指针先向前移动k步,之后同步遍历两个链表,
当p、q指向的结点为同一结点时,该结点即为第一个公共结点。
*/

/*
要注意,主函数中,传的参数是指针,返回的也是指针类型
*/

//求链表长度的函数
int GetLen(LNode *p)
{
    int len = 0;
    while(p->next != NULL)
    {
        len ++;
        p = p->next;
    }
    return len;
}

SNode *Find(LNode *str1, LNode *str2)
{
    int m = 0, n = 0; //两个链表的长度
    LNode *p = str1->next, *q = str2->next;
    m = GetLen(str1);  //求链表长度
    n = GetLen(str2);
    for(int i = m; m > n; m --) //若m>n,移动p指针
        p = p->next;
    for(int i = n; n > m; n --) //若n>m,移动q指针
        q = q->next;
    while(p != q && p != NULL) //寻找共同后缀的起始地址
    {
        p = p->next;
        q = q->next;
    }
    return p;
}

19. 去掉绝对值重复的结点

注意:

1. 题目需要给出数据类型定义

2. struct node *link; //题目要求用link,故此处不能用data

3. 删除结点时,要释放结点空间

    free(q); //释放该结点的空间

/*
算法思想:
该算法使用空间换时间的思想,开一个大小为n+1的数组a;各元素的初值为0.从头一次扫描链表
中的各结点。同时检查a[|data|]的值,若为0则保留该结点,并令a[|data|]=1;否则将该结点
从链表中删除
*/
typedef struct LNode
{
    int data;
    struct node *link; //题目要求用link,故此处不能用data
}LNode;


void work(LNode *h, int n) //头指针和数值范围是已经给出的,放在函数传参里即可
{
    int a[n + 1];
    LNode *p = h, *q;
    while(p->next != NULL)
    {
        int x = p->next->data;
        if(x < 0) x = -x; //绝对值
        if(a[x] == 0) //该绝对值未出现过
            a[x] = 1;
        else //该绝对值出现过,则删除该结点
        {
            q = p->next;
            p->next = q->next;
            free(q); //释放该结点的空间
        }
    }
}

20. 重新交叉排列

 【考察知识点】

1. 寻找中间结点

2. 将一段结点逆置

算法思想:

(1)先找出算法L的中间结点,为此设置两个指针p和q,指针p每次走一步,指针q每次走两步,当指针q到达链尾时,指针p恰好在链表的中间结点

(2)利用头插法将L的后半段结点原地逆置

(3)将后半段的结点按照题目要求依次插入前半段结点中

void work(LNode *h)
{
    LNode *p, *q, *r, *s;
    //寻找中间结点
    p = q = h;
    while(q->next != NULL)
    {
        p = p->next; //p走一步
        q = q->next;
        if(q->next != NULL) 
            q = q->next; //q走两步
    }
    q = p->next; //p为中间结点,q为后半段头结点
    //开始逆置
    while(q->next != NULL)
    {
        r = q->next;
        q->next = r->next; //摘下
        r->next = p->next;
        p->next = r;
    }
    q->next = NULL;
    //将后半段结点插到前半段
    s = h->next; //s指向前半段的第一个结点
    q = p->next;
    while(q != NULL)
    {
        p->next = q->next;
        q->next = s->next;
        s->next = q;
        s = q->next;
        q = p->next;
    }
}

三、栈

四、 队列

五、括号序列

六、 树

1. 结构体

typedef struct BiTNode{
    ElemType elem;  //数据域
    struct BiTNode *lchild, *rchild; //左、右孩子
}BiTNode, *BiTree;

 2. 递归遍历

        先序

void PreOrder(BiTree T)
{
    if(T != NULL){
        visit(T);
        PreOrder(T->lchild);
        PreOrder(T->rchild);
    }
}

        中序

void PreOrder(BiTree T)
{
    if(T != NULL){
        PreOrder(T->lchild);
        visit(T);
        PreOrder(T->rchild);
    }
}

        后序

void PreOrder(BiTree T)
{
    if(T != NULL){
        PreOrder(T->lchild);
        PreOrder(T->rchild);
        visit(T);
    }
}

3. 非递归遍历

需要用到栈

先序遍历

void PreOrder2(BiTree T)
{
    BiTree p = T;
    InitStsck(S);
    while(!Empty(S) || p)
    {
        if(p)
        {
            visit(p);
            Push(S, p); //保留p是为了之后探索它的右孩子
            p = p->lchild;
        }
        else
        {
            Pop(s, p);
            p = p->rchild;
        }
    }
    
}

中序遍历

中序遍历和先序遍历的思想是一样的,只是改变了访问的结点的位置

void InOrder2(BiTree T)
{
    BiTree p = T;
    InitStsck(S);
    while(!Empty(S) || p)
    {
        if(p)
        {
            Push(S, p); //保留p是为了之后探索它的右孩子
            p = p->lchild;
        }
        else
        {
            //此时已经遍历完左子树了,才能访问根节点
            Pop(s, p);
            visit(p); 
            p = p->rchild;
        }
    }
    
}

4. 层次遍历

(1)上到下,左到右

void LevelOrder(BiTree T)
{
    BiTree p; //用来接收队头
    InitQueue(Q);
    EnQueue(Q, T);
    while(!IsEmpty(Q))
    {
        DeQueue(Q, p);
        visit(p);
        if(p->lchild != NULL) EnQueue(Q, p->lchild);
        if(p->rchild != NULL) EnQueue(Q, p->rchild);
    }
    
}

(2)下到上,右到左

算法思想:利用原有的层次遍历算法,出队的同时将各结点指针入栈,在所有的结点入栈后再从栈顶开始依次访问结点

void InvertLevel(BiTree T)
{
    InitQueue(Q);
    InitStack(S);
    EnQueue(Q, T);
    BiTree p;
    while(IsEmpty(Q) == false)
    {
        DeQueue(Q, p); //注意,不是p = Dequeue(Q);
        Push(S, p); //出队,入栈
        if(p->lchild)
            EnQueue(Q, p->lchild);
        if(p->rchild)
            EnQueue(Q, p->rchild);
    }
    //自下而上,从右到左的层次遍历
    while(IsEmpty(S) == false)
    {
        Pop(S, p); //注意,不是p = Pop(S);
        visit(p->data); //遍历的是值
    }
}

5. 求二叉树高度

(1) 递归

int GetGigh(BiTree T)
{
    if(T == NULL) return 0;
    int lhigh = GetHigh(T->lchild);
    int rhigh = GetHigh(T->rchild);
    int high =  1 + (lchild > rchild ? lchild : rchild);
    return high;
}

(2)非递归

有点难度

P168

算法思想:采用层次遍历算法,设置变量level来记录当前结点所在的层数,设置变量last指向当前层的最右结点,每次层次遍历出队时队头指针与last比较,若相等,则lever加一,并让last指向下一层的最右结点,即当前的队尾结点,直到遍历完成,level即为二叉树的高度

注意事项

此处因为需要用到队尾元素,所以用的是数组队列

数组队列存的是结点,所以类型应为BiTree

int GetHigh(BiTree T)
{
    int level = 0; //记录高度
    int last = 0; //记录当前层的最右结点
    int front = -1, rear = -1; //队头和队尾指针
    BiTree Q[MaxSize]; //队列类型为结点
    Q[++rear] = T;
    BiTree p;
    while(IsEmpty(Q) == false) //队列不为空时
    {
        p = Q[++front];
        if(p->lchild)
            Q[++rear] = p->lchild; //左孩子入队
        if(p->rchild)
            Q[++rear] = p->rchild; //右孩子入队   
        if(last == front) //处理该层的最右结点;
        {
            level ++;
            last = rear;
        }
    }
    return level;
}

 6. 判断是否是完全二叉树

算法思想:采用层次遍历算法,遇到空节点时,查看其后是否有非空节点(不需要遍历完所有结点,当某层结点都为空时,自然没有后代),若有,则二叉树不是完全二叉树

void InvertLevel(BiTree T)
{
    InitQueue(Q);
    EnQueue(Q, T);
    BiTree p;
    while(IsEmpty(Q) == false)
    {
        DeQueue(Q, p); //注意,不是p = Dequeue(Q);
        if(p)
        {
            EnQueue(Q, p->lchild);
            EnQueue(Q, p->rchild);
        }
        else //遇到空结点
        {
            while(IsEmpty(Q) == false) //判断队列中的剩余结点是否都为空
            {
                DeQueue(Q, p);
                if(p) 
                    return false;
            }
        }
    }
   return true;
}

7. 统计双分支结点个数

法一:递归遍历+全局变量

法二:递归遍历,但不用全局变量

 int Work(BiTree T)
{
 
    if(T == NULL) return 0; //别忘了空节点也要有返回值   
    if(T->lchild && T->rchild) //自身是双分支结点
        return (Work(T->lchild) + Work(T->rchild)) + 1;
    else
        return Work(T->lchild) + Work(T->rchild);
}

 8. 将树中所有结点的左右结点交换

算法思想:采用后序递归算法,对于b结点,先交换b结点左孩子的左右子树,再交换b结点右孩子的左右子树,最后再交换b结点的左右孩子

[注意]:交换的时候要链表一样防止链接丢失

void Work(BiTree T)
{
   if(T != NULL)
   {
       Work(T->lchild);
       Work(T->rchild);
       //交换三部曲
       BiTree temp = T->lchild;
       T->lchild = T->rchild;
       T->rchild = temp;
   }
}

9. 求先序遍历中第k个结点的值

难点:返回时要一层一层递归返回

方法:使用全局变量来记录是否已经找到该值,并将该值记录在全局变量中

【当不知道要记录的值的类型时,用EmemType来赋值】

int flag = 0; //是否找到第k个数
ElemType ans; //记录该结点数据(当不知道类型时,用英文)
int res = 0; //res为当前遍历的数的序号
int Work(BiTree T, int k)
{
   if(flag == 1) return ans;
   res ++;
   if(res == k)
   {
       flag = 1; //找到了;
       ans = T->data;
       return ans;
   }
   if(T->lchild) Work(T->lchild, k); //只遍历存在的结点
   if(T->rchild) Work(T->rchild, k);
}

10. 删除子树

题目:对于树中每个元素值为x的结点,删除以它为根的子树,并释放相应的空间

1. 删除子树使用后序遍历,因为要先删完子孙后代再删自身

2. 释放内存用free();

3. Work函数之所以写得比较复杂是因为:

值为x的结点的父亲在删完子树后,需要指向NULL,所以通过父亲来判断孩子的值是否为x;

void Delete(BiTree &bt) //删除以bt为根的子树//注意,传入的是地址
{
    if(bt)
    {
        Delete(bt->lchild);
        Delete(bt->rchild);
        free(bt);
    }
}

void Work(BiTree T, ElemType x)
{
    if(!T) return ;
    if(T->data == x)
        Delete(T);
    else
    {
        if(T->lchild->data == x) //孩子值为x,删掉,并将孩子位置换成NULL
        {
            Delete(T->lchild);
            T->lchild = NULL;
        }
        else
            Work(T->lchild, x);
        if(T->rchild->data == x)
        {
            Delete(T->rchild);
            T->rchild = NULL;
        }
        else
            Work(T->rchild, x);
    }
}

 11. 求非空二叉树宽度

宽度:具有结点数最多的那一层

可以利用第五题:非递归求高度的思想求最大宽度

当last == front时,cnt = rear - front;

ans = max(ans, cnt);

 12. 知先序求后序

题目:设有一棵满二叉树,已知其先序序列为pre(字符串),设计一个算法求其后序序列post。

对于一般二叉树而言,仅根据先序或后序序列,不能确定另一个遍历序列。但对于满二叉树,可以确定

可以自己画画,很容易找规律,使用递归

#include<stdio.h>

void work(char pre[], int l, int r)
{
    if(l == r) 
    {
        printf("%c", pre[l]);
        return ;
    }
    work(pre, l+1, l+(r-l)/2);
    work(pre, l+(r-l)/2+1, r);
    printf("%c", pre[l]);
}

int main()
{
    char pre[100] = "01245367";
    work(pre, 1, 7);
    return 0;
}

 13. 将叶节点连成单链表

题目:将二叉树的结点按从左到右的顺序连成一个单链表,表头指针为head,二叉树按二叉链表方式存储,链接时用叶结点的右指针域来存放单链表指针

算法思想:使用先序遍历遍历到的叶节点的顺序就是从左到右的,故用pre指针记录前一个叶节点即可。

LinkList head, pre = NULL;
LinkList Work(BiTree T)
{
    if(T)
    {
        if(T->lchild==NULL && T->rchild==NULL)
        {
            if(pre == NULL)
            {
                head = L;
                pre = L;
            }
            else{
                pre->rchild = T;
                pre = T;
            }
        }
        Work(T->lchild);
        Work(T->rchild);
    }
    return head;
}

七、 图

对于默认图(即不带权),在邻接矩阵中,如两点之间存在边,则g[a][b]=1.否则为0

1. 出度大于入度的顶点个数

算法思想:在邻接矩阵中,对于每个顶点,其所在行中1的个数为该顶点对应的出度,其所在列1的个数为该顶点对应的入度。因此可以枚举每个顶点,用count1记录出度,用count2记录入度,用ans来记录K顶点的个数,当count1>count2时,输入该顶点,ans加一。最后返回ans的值。

int printVertices(MGraph G)
{
    int ans = 0; //K顶点个数
    for(int i = 0; i < G.numVertices; i ++) //枚举顶点
    {
        int count1 = 0; //记录出度
        int count2 = 0; //记录入度
        for(int j = 0; j < G.numVertices; j ++) //对行
            count1 += G.Edge[i][j]);
        for(int j = 0; j < G.numVertices; j ++) //对列
            count2 += G.Edge[j][i])
        if(count1 > count2) 
        {
            printf("%c ", G.VerticesList[i]);
            ans ++;
        }
        
    }
    return ans;
}

 八、 查找

1. 折半查找

#define MaxSize 40
typedef struct{
    ElemType data[MaxSize];
    int length;
}SqList

题目:写出折半查找的递归算法(要写递归的二分), low为1, high为ST.length(对线性表操作)

//自己定义线性表
#define MaxSize 40
typedef struct{
    ElemType data[MaxSize];
    int length;
}SqList


int find(int a[], int low, int high, int x)
{
    int pos;
    int mid = (low + high)/2;
    if(ST.data[mid] > x) 
        pos = find(a, low, mid-1, x);
    else if(ST.data[mid] < x)
        pos = find(a, mid+1, high, x);
    else pos = mid;
    return pos;
}

2. 矩阵查找

算法思想:从矩阵A的右上角即第一行的最后一列的那个元素开始比较,若当前元素小于目标值,则向下移动一行,若当前元素大于目标值,则向左移动一列 ,若当前元素等于目标值,则返回true,如果移动的过程越界了,说明矩阵中不存在该目标值,返回false。

 九、 并查集

初始化操作

void Init(int p[])
{
    for(int i = 0; i < SIZE; i ++)
        p[i] = i;
}

 1. 压缩路径

改进了Find操作

int find(int p[], int x)
{
   if(x != p[x]) p[x] = find(p[x]);
   return p[x];
}

十、 图

1. 与二叉树不一样(树没有环),dfs和bfs遍历图需要用visit[ ]来记录该结点是否访问过,防止重复访问

书本p227

2. BFS求解单元最短路问题时需要用d[ ]来记录当前距离

d[ ]要初始化为无穷大

3. 知道图怎么存就可以写题了,那些扩展都在搜索图的基础上进行的

1. bfs搜索

主函数

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:/a/929403.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

原生html+css+ajax实现二级下拉选择的增删改及树形结构列出

<?php $db_host localhost; $db_user info_chalide; $db_pass j8c2rRr2RnA; $db_name info_chalide; /* 数据库结构SQL CREATE TABLE categories ( id INT AUTO_INCREMENT PRIMARY KEY, name VARCHAR(255) NOT NULL, parent_id INT DEFAULT 0 ); */ try { $pdo new PD…

微信小程序介绍-以及写项目流程(重要)

前言&#xff1a;本篇文章介绍微信小程序以及项目介绍&#xff1a; 文章介绍&#xff1a;介绍了微信小程序常用的指令、组件、api。tips&#xff1a;最好按照官方文档来进行学习&#xff0c;大致可以我的目录来学习&#xff0c;对于写项目是没有问题的 微信小程序官方文档https…

Data Uncertainty Learning in Face Recognition 论文阅读

Data Uncertainty Learning in Face Recognition 论文阅读 Abstract1. Introduction2. Related Work3. Methodology3.1. Preliminaries3.2. Classification-based DUL for FR3.3. Regression-based DUL for FR3.4. Discussion of Related Works 4. Experiments4.1. Datasets an…

汽车产业数字化转型:协同创新破解挑战,平衡安全与流通

在数字经济时代的浪潮中&#xff0c;数据资源和数据信息已成为驱动各行各业转型升级的“新石油”。汽车产业&#xff0c;作为国民经济的重要支柱&#xff0c;正经历着前所未有的变革。随着数字化创新和转型的深入&#xff0c;数据在汽车全产业链中的作用和价值日益凸显。在这个…

vulnhub kioptirx1.2 超详细wp

探测 nmap --min-rate 10000 -p- 192.168.128.134 最小速率10000 nmap -sT -sV -sC -O 192.168.128.134 web打点 无弱口令 暴露cms寻找exp searchsploit LotusCMS -m 16982 [输入id号和参数m可以直接把东西复制到当前目录] 查看txt里面发现 都是xss没有rce github搜索到一个…

扫二维码进小程序的指定页面

草料二维码解码器 微信开发者工具 获取二维码解码的参数->是否登陆->跳转 options.q onLoad: function (options) {// console.log("options",options.q)if (options && options.q) {// 解码二维码携带的链接信息let qrUrl decodeURIComponent(optio…

mysql基础学习1

useradd -r -g mysql -s /bin/false mysql (-r)系统用户 不能登录 A temporary password is generated for rootlocalhost: d>#jT7rfoaz) 看是否启动 看进程 端口 直接连接 看日志 varchar (20) char(20)更耗空间 create table student_info(id int,name varchar(20),s…

Echarts使用平面方法绘制三维立体柱状图表

目录 一、准备工作 1.下载引入ECharts库 2.创建容器 二、绘制基本柱状 三、绘制立体柱状方法一 1.定义立方体形状 2.注册立方体形状 3.配置custom系列 4.设置数据 5.渲染图表 四、绘制立体柱状方法二 1.画前知识 2.计算坐标renderItem 函数 &#xff08;1&#x…

基于 MindQuantum 实现对 “天衍” 量子云平台真机的比特映射

MindQuantum 目前只支持量子模拟器&#xff0c;如果需要获得量子算法在真机上的实测数据&#xff0c;可以借助“天衍”量子云平台提供的真机。本文将介绍如何基于 MindQuantum 绘制“天衍”真机的拓扑图&#xff0c;并进而实现比特映射。 关于 MindQuantum 涉及比特映射的教程…

OpenBayes贝式计算创始人受邀参加第九届中国开源年会,分享 AI4S 前沿洞察

Open Source&#xff0c;Open Life&#xff0c;开源新生活&#xff01; 由开源社主办的第九届中国开源年会 (COSCon24) 于 2024 年 11 月 3 日在北京圆满落幕。本届大会为期 2 天&#xff0c;以 「开源新生活 - Open Source, Open Life 」 为主题&#xff0c;汇聚了来自全国各…

Day1 生信新手笔记

生信新手笔记 生信学习第一天笔记打卡。 转录组学中&#xff1a; 上游分析-基于linux&#xff0c;包括质控、过滤、比对、定量&#xff1b; 下游分析-基于R语言&#xff0c;包括差异分析、富集分析、可视化。 1. 级别标题 一个井号加空格 就是一级标题&#xff0c;两个井号加…

日拱一卒(9)——leetcode学习记录:两数组中位数

一、问题 给定两个大小分别为 m 和 n 的排序数组 nums1 和 nums2&#xff0c;要求你在 O(log(mn)) 的时间复杂度内找出这两个数组的中位数。 二、思路 时间复杂度O(log(n))代表随着操作数增加&#xff0c;剩余操作数递减&#xff0c;如二分法。 首先要建模&#xff0c;对这…

从 HTML 到 CSS:开启网页样式之旅(五)—— CSS盒子模型

从 HTML 到 CSS&#xff1a;开启网页样式之旅&#xff08;五&#xff09;—— CSS盒子模型 前言一、盒子模型的组成margin&#xff08;外边距&#xff09;&#xff1a;border&#xff08;边框&#xff09;&#xff1a;padding&#xff08;内边距&#xff09;&#xff1a;conten…

【区块链】深入理解区块链中的 Gas 机制

&#x1f308;个人主页: 鑫宝Code &#x1f525;热门专栏: 闲话杂谈&#xff5c; 炫酷HTML | JavaScript基础 ​&#x1f4ab;个人格言: "如无必要&#xff0c;勿增实体" 文章目录 深入理解区块链中的 Gas 机制一、Gas 的基本概念1.1 为什么需要 Gas&#xff1f…

黑马JavaWeb-day06、07、08(SQL部分) _

文章目录 MYSQL概述数据模型SQL简介SQL分类 DDL数据库操作表操作 DML增&#xff08;INSERT&#xff09;改&#xff08;UPDATE&#xff09;删&#xff08;DELETE&#xff09; DQL基本查询条件查询&#xff08;where&#xff09;分组查询&#xff08;group by&#xff09;排序查询…

Kubernetes集群操作

查看集群信息&#xff1a; kubectl get nodes 删除节点 &#xff08;⽆效且显示的也可以删除&#xff09; 后期如果 要删除某个节点&#xff0c;为了不增加其他节点的访问压力&#xff0c;先增加一个节点&#xff0c;再删除要删除的节点 语法 &#xff1a;kubect delete…

基于PSO粒子群优化的CNN-LSTM-SAM网络时间序列回归预测算法matlab仿真

目录 1.算法运行效果图预览 2.算法运行软件版本 3.部分核心程序 4.算法理论概述 5.算法完整程序工程 1.算法运行效果图预览 (完整程序运行后无水印) 2.算法运行软件版本 matlab2022a 3.部分核心程序 &#xff08;完整版代码包含详细中文注释和操作步骤视频&#xff09…

三步入门Log4J 的使用

本篇基于Maven 的Project项目&#xff0c; 快速演示Log4j 的导入和演示。 第一步&#xff1a; 导入Log4j依赖 <dependency><groupId>org.apache.logging.log4j</groupId><artifactId>log4j-api</artifactId><version>2.24.2</version&…

Redis 基础、Redis 应用

Redis 基础 什么是 Redis&#xff1f; Redis &#xff08;REmote DIctionary Server&#xff09;是一个基于 C 语言开发的开源 NoSQL 数据库&#xff08;BSD 许可&#xff09;。与传统数据库不同的是&#xff0c;Redis 的数据是保存在内存中的&#xff08;内存数据库&#xf…

3D数据大屏实现过程,使用echarts、Next.js

&#x1f4dc; 本文主要内容 数据大屏自适应方案动效 echarts&#xff1a; 3D 立体柱状图动态流光折线图 3D 地球&#xff08;飞线、柱状图&#xff09;无限滚动列表 &#x1f50d; 大屏效果 数据大屏&#xff1a; 点击预览 &#x1f579; 运行条件 next 12.3.4echarts 5.4…