数据结构（3）----栈和队列

目录

一.栈

1.栈的基本概念

2.栈的基本操作

3.顺序栈的实现

•顺序栈的定义

•顺序栈的初始化

•进栈操作

  •出栈操作

  •读栈顶元素操作

  •若使用另一种方式:

4.链栈的实现

•链栈的进栈操作

•链栈的出栈操作

•读栈顶元素

二.队列

1.队列的基本概念

2.队列的基本操作

3.用顺序存储实现队列

•初始化

•入队操作

•出队操作

•获得队头元素的值

•判满/空方案

4.用链式存储实现队列

•初始化

•入队操作

•出队操作

•队列满的条件

三.双端队列

一.栈

1.栈的基本概念

栈(stack)是只允许在一端进行插入或删除操作的线性表。

栈顶：允许插入和删除的一端。最上面的元素被称为栈顶元素。

栈底：不允许插入和删除的一端。最下面的元素被称为栈底元素。

如下图所示：

进栈顺序：a1-->a2-->a3-->a4-->a5

出栈顺序：a5-->a4-->a3-->a2-->a1

所以栈的特点是后进先出（Last In First Out ( LIFO )）

补充：

n个不同元素进栈，出栈元素不同排列的个数为\frac{1}{n+1}C_{2n}^{n}。

上述公式称为卡特兰(Catalan)数，可采用数学归纳证明。

2.栈的基本操作

•Initstack(&S)：初始化栈。构造一个空栈S，分配内存空间。
•DestroyStack(&L)：销毁栈。销毁并释放栈s所占用的内存空间。
•Push(&S,x)：进栈，若栈S未满，则将x加入使之成为新栈顶。

•Pop(&S,&x)：出栈，若栈S非空，则弹出栈顶元素，并用x返回。
•GetTop(S,&x)：读栈顶元素。若栈S非空，则用x返回栈顶元素。
其他常用操作:
StackEmpty(S)：判断一个栈S是否为空。若S为空，则返回true，否则返回false。

3.顺序栈的实现
•顺序栈的定义
#define Maxsize 10    //定义栈中元素的最大个数
typedef struct{ElemType data[Maxsize];    //静态数组存放栈中元素int top;    //栈顶指针
} SqStack;void testStack(){SqStack S;     //声明一个顺序栈(分配空间)
}
//这里使用声明的方式分配内存空间，并没有使用malloc函数。
//所以给这个栈分配的内存空间，会在函数结束之后又系统自动回收。

声明顺序栈后，就会给各个数据元素分配连续的存储空间，大小为MaxSize*sizeof(ElemType)的空间。

•顺序栈的初始化
#define Maxsize 10    //定义栈中元素的最大个数
typedef struct{
ElemType data[Maxsize];    //静态数组存放栈中元素
int top;    //栈顶指针
} SqStack;//初始化栈
void Initstack(Sqstack &S){S.top=-1;    //初始化栈顶指针
}//判断栈空
bool StackEmpty(SqStack S){if(S.top==-1)    //栈空return true ;else             //不空return false;
}void testStack(){SqStack S;InitStack(S);
}

•进栈操作
#define MaxSize 10
typedef struct{ElemType data[Maxsize];int top;
} Sqstack;//新元素入栈
bool Push(SqStack &S,ElemType x){if(S.top == MaxSize-1)    //栈满，报错return false;S.top = S.top + 1;    //指针先加1S.data[s.top]=x;      //新元素入栈return true;
}//或者写为
bool Push(SqStack &S,ElemType x){if(S.top == MaxSize-1)    //栈满，报错return false;S.data[++S.top]=x;return true;
}

//不能写为
bool Push(SqStack &S,ElemType x){if(S.top == MaxSize-1)    //栈满，报错return false;S.data[S.top++]=x;return true;
}//这意味着
bool Push(SqStack &S,ElemType x){if(S.top == MaxSize-1)    //栈满，报错return false;    S.data[s.top]=x;    //新进栈的元素会把以前的元素覆盖 S.top = S.top + 1;return true;
}

  •出栈操作
#define MaxSize 10
typedef struct{ElemType data[Maxsize];int top;
} Sqstack;//出栈操作
bool Pop(Sqstack &S,ElemType &x){if(S.top==-1)    //栈空，报错return false;x=S.data[S.top];    //栈顶元素先出栈S.top=S.top-1;    //指针再减1return true;
}
//删除操作中，top指针往下移,只是逻辑上被删除了，数据还残留在内存中。//出栈操作也可写为
bool Pop(Sqstack &S,ElemType &x){if(S.top==-1)    //栈空，报错return false;x=S.data[S.top--];return true;
}
//不能写为
bool Pop(Sqstack &S,ElemType &x){if(S.top==-1)    //栈空，报错return false;x=S.data[--S.top];return true;
}//这意味着
bool Pop(Sqstack &S,ElemType &x){if(S.top==-1)    //栈空，报错return false;S.top=S.top-1;x=S.data[S.top];return true;
}

 如果先减，再将top的值赋给x，那么x值就会返回"i"，而不是"j"

  •读栈顶元素操作
#define Maxsize 10
typedef struct{ElemType data[Maxsize];int top;
} Sqstack;//出栈澡作
bool Pop(Sqstack &S,ElemType &x){if(S.top==-1)    //栈空，报错return false;x=S.data[s.top--];    //先出栈，指针再减1return true;
}//读栈顶元素
bool GetTop(Sqstack S,ElemType &x){if(S.top==-1)    //栈空，报错return false;x=S.data[s.top];    //x记录栈顶元素return true;
}
//可以看到，出栈操作和读栈顶元素非常类似。

  •若使用另一种方式:

将top指针刚开始指向0，判断栈是否为空，即判断S.top==0，这样设计是将top指针指向下一个能插入元素的位置。

若进行入栈操作时，需要先把x放到top指针指向的位置，再让top+1，和之前的方式相反。

出栈操作也是，需要先让top-1，再把top指向的数据元素传回去。

代码如下：

#define Maxsize 10
typedef struct{ElemType data[Maxsize];int top;
} SqStack;//初始化栈
void Initstack(Sqstack &s){S.top=0;    //初始化指向0
}bool StackEmpty(Sqstack S){if(S.top==0)    //栈空return true;elsereturn false;
}//入栈操作
bool Push(SqStack &S,ElemType x){if(S.top == MaxSize)    //栈满，报错return false;S.data[S.top++]=x;return true;
}//出栈操作
bool Pop(Sqstack &S,ElemType &x){if(S.top==0)    //栈空，报错return false;x=S.data[--S.top];return true;
}void testStack(){    判断栈空SqStacks;//声明一个顺序栈InitStack(S);
}

顺序栈的缺点是栈的大小不可变，可以在刚开始就给栈分配大片的内存空间，但这样会导致内存空间的浪费，可以使用共享栈提高内存空间的利用率。共享栈即两个栈共享同一片内存空间。

代码如下：

#define MaxSize 10
typedef struct{ElemType data[Maxsize];    //静态数组存放栈中元素int top0;    //0号栈栈顶指针int top1;    //1号栈浅顶指针
} Shstack;//初始化栈
void InitStack(Shstack &S){S.top0=-1;    //初始化栈顶指针S.top1=Maxsize;
}

可以看到，共享栈判断栈满的条件：top0+1=top1

总结：

4.链栈的实现

对于链栈而言，其进栈操作其实对应于链表中对头结点的"后插"操作，出栈操作对应于链表中对头结点的"后删"操作,就是将链头的一端看作栈顶的一端。

建议先看：http://t.csdnimg.cn/IknBJ

代码如下：

//链栈的定义和链表的定义是相同的，只是命名不同
typedef struct Linknode{ElemType data;struct Linknode *next;
}LiStack;    //栈类型定义//带头结点
bool InitStack(LiStack &L){L=(Linknode *)malloc(sizeof(Linknode));if(L==NULL)return false;    //内存不足，分配失败L->next=NULL;return true;    
}bool Empty(LinkList L){return(L->next == NULL);
}//不带头结点
bool InitStack(LiStack &L){L=NULL;return true;
}bool Empty(LinkList L){return(L=NULL);
}
•链栈的进栈操作
//带头结点
LiStack LiSPush(LiStack &L){Linknode *s;int x;L=(LiStack)malloc(size(Linknode));L->next=NULL;scanf("%d",&x);while(x!=9999){s=(Linknode *)malloc(sizeof(Linknode));s->data=x;s->next=L->next;L->next=s;scanf("%d",&x);}return L;
}//不带头结点
LiStack LisPush(LiStack &L){Linknode *s;int x;L=NULL;scanf("%d",&x);while(x!=9999){s=(Linknode *)malloc(sizeof(Linknode));s->data=x;s->next=L;L=s;scanf("%d",&x);}return L;
}
•链栈的出栈操作
//带头结点
LiStack LisPop(LiStack &L, int &e) {if (L->next == NULL) {// 栈空，无法出栈return NULL;}Linknode *q = L->next;e = q->data;L->next = q->next;free(q);return L;
}//不带头结点
LiStack LisPop(LiStack &L, int &e) {if (L == NULL) {// 栈空，无法出栈return NULL;}Linknode *q = L;e = q->data;L = L->next;free(q);return L;
}
•读栈顶元素
//带头结点
int GetTop(LiStack &L) {if (L->next == NULL) {// 栈为空return -1; // 或者抛出异常}return L->next->data;
}//不带头结点
int GetTop(LiStack &L) {if (L == NULL) {// 栈为空return -1; // 或者抛出异常}return L->data;
}

 

二.队列

1.队列的基本概念

栈(stack)是只允许在一端进行插入或删除操作的线性表。队列(aueue)是只允许在一端进行插入，在另一端删除的线性表。

队头，队尾，空队列:

空队列：没有数据元素

队头：允许删除的一端

队尾：允许插入的一端

队列的特点：先进入队列的元素先出队，即先进先出（First In First Out,FIFO）。

2.队列的基本操作

Initaueue(&Q)：初始化队列，构造一个空队列。

DestroyQueue(&Q)：销毁队列。销毁并释放队列Q所占用的内存空间。

EnQueue(&Q,x)：入队，若队列Q未满，将x加入，使之成为新的队尾。

DeQueue(&a,&x)：出队，若队列Q非空，删除队头元素，并用x返回。
GetHead(a,&x)：读队头元素，若队列Q非空，则将队头元素赋值给x。

其他常用操作：

QueueEmpty(Q)：判队列空，若队列Q为空返回true，否则返回false。

3.用顺序存储实现队列
•初始化
#define Maxsize 10    //定义队列中元素的最大个数
typedef struct{ElemType data[Maxsize];    //用静态数组存放队列元素int front,rear;    //队头指针和队尾指针
}SqQueue;void testQueue(){SqQueue Q;//声明一个队列
}

声明一个队列后，系统会分配一片连续的存储空间，大小为MaxSize*sizeof(ElemType)，如下图所示：

队头指针：指向队头元素。

队尾指针：指向队尾元素的后一个位置。

所以还没有插入元素时，队头指针与队尾指针同时指向data[0]：

#define Maxsize 10    //定义队列中元素的最大个数
typedef struct{ElemType data[Maxsize];    //用静态数组存放队列元素int front,rear;    //队头指针和队尾指针
}SqQueue;void InitQueue(SqQueue &Q){//初始时，队头和队尾指针指向0Q.rear=Q.front=0;
}//判空
bool QueueEmpty(SqQueue Q){if(Q.rear==Q.front)    //队空条件return true;elsereturn false;void testQueue(){SqQueue Q;//声明一个队列InitQueue(Q);}

•入队操作

只能从队尾入队

#define MaxSize 10
typedef struct{ElemType data[Maxsize];int front,rear;
} SqQueue;//入队
bool EnQueue(SqQueue &Q,ElemType x){if(Q.rear==MaxSize)    return false;    //队满则报错Q.data[Q.rear]=x;    //新元素插入队尾Q.rear=(Q.rear+1);return true;
}

注：rear=MaxSize不能作为队列已满的判断条件，上面的写法是错误的。如下图所示，若前面的元素出队了，要再插入元素，可以从前面无数据元素的区域插入。

正确写法：

#define MaxSize 10
typedef struct{ElemType data[Maxsize];int front,rear;
} SqQueue;//入队
bool EnQueue(SqQueue &Q,ElemType x){if((Q.rear+1)%MaxSize=Q.front)    //判满return false;    //队满则报错Q.data[Q.rear]=x;    //新元素插入队尾Q.rear=(Q.rear+1)%MaxSize;    //队尾指针加1取模return true;
}

这里的Q.rear=(Q.rear)%MaxSize实现的效果是：当（Q.rear+1）%MaxSize==0时，即“队满”时，会将rear指针重新指向data[0]。

这样用模运算，将存储空间在逻辑上变成了“环状。

如下图所示，队满条件是：队尾指针的再下一个位置是队头，即(Q.rear+1)%MaxSize==Q.front

为什么需要不能再插入一个元素，并且使rear和front指向同一个元素呢？

因为初始化队列的时候，rear指针与front指针就是指向同一个位置，同时我们也是通过判断rear和front指针是否指向同一个位置，判断队列是否为空的。

如果再插入一个元素，rear和front指针指向同一个位置，这样，判满与判空条件就会混淆起来。

所以必须牺牲一个存储单元，以区分队列满还是空。

•出队操作

只能让队头元素出队：

//出队(删除一个队头元素，并用x返回)
bool DeQueue(sqQueue &Q,ElemType &x){if(Q.rear==Q.front)    //当队头指针与队尾指针再次指向同一个位置时，说明队空return false;    //队空则报错x=Q.data[Q.front];Q.front=(Q.front+1)%Maxsize;    //队头指针后移return true;
}

•获得队头元素的值
//获得队头元素的值，用x返回
bool GetHead(SqQueue Q,ElemType &x){if(Q.rear==Q.front)    //队空则报错return false;x=Q.data[Q.front];return true;
}//相比于出队操作,获取队头的值不需要将队头指针后移
bool DeQueue(sqQueue &Q,ElemType &x){if(Q.rear==Q.front)    //当队头指针与队尾指针再次指向同一个位置时，说明队空return false;  x=Q.data[Q.front];Q.front=(Q.front+1)%Maxsize;    return true;
}
•判满/空方案

方案一：

以上方案中，判断队列已满的条件：队尾指针的再下一个位置是队头，即：

(Q.rear+1)%MaxSize==Q.front

队空条件：队头指针与队尾指针指向同一个地方，即：

Q.rear=Q.front

队列元素个数：

(rear+MaxSize-front)%MaxSize

例如下图，rear=2，front=3，那么队列元素个数就是：（2+10-3）%10 =9%10=9

其实也可以不用牺牲一个存储空间，下面两种方案可供参考。

方案二：

#define MaxSize 10
typedef struct{ElemType data[MaxSize];int front,rear;int size;    //用size表示当前队列的长度，当入队成功size++，出队成功size--
}SqQueue;

具体代码如下： 

#define MaxSize 10
typedef struct {ElemType data[MaxSize];int front, rear;int size; // 用size表示当前队列的长度，当入队成功size++，出队成功size--
} SqQueue;// 初始化队列
void InitQueue(SqQueue &Q) {Q.front = Q.rear = 0;Q.size = 0;
}// 判断队列是否为空
bool QueueIsEmpty(SqQueue Q) {return (Q.rear == Q.front) && (Q.size == 0);
}// 判断队列是否已满
bool QueueIsFull(SqQueue Q) {return (Q.rear == Q.front) && (Q.size == MaxSize);
}// 入队操作
bool EnQueue(SqQueue &Q, ElemType x) {if (QueueIsFull(Q))return false;Q.data[Q.rear] = x;Q.rear = (Q.rear + 1) % MaxSize;Q.size++;return true;
}// 出队操作
bool DeQueue(SqQueue &Q, ElemType &x) {if (QueueIsEmpty(Q))    // 队列为空return false;x = Q.data[Q.front];Q.front = (Q.front + 1) % MaxSize;Q.size--;return true;
}

 

方案三：

#define Maxsize 10
typedef struct{ElemType data[Maxsize];int front,rear;int tag;    //记录最近进行的是删除/插入
//每次删除操作成功时，都令tag=0，每次插入成功时，都令tag=1;
} SqQueue;

只有删除操作，才能导致队空，只有插入操作，才能导致队满。所以：

具体代码如下： 

#define Maxsize 10
typedef struct{ElemType data[Maxsize];int front,rear;int tag;    //记录最近进行的是删除/插入
//每次删除操作成功时，都令tag=0，每次插入成功时，都令tag=1;
} SqQueue;// 初始化队列
void InitQueue(SqQueue &Q) {Q.front = Q.rear = 0;Q.tag = 0; // 初始时没有进行过操作，设置tag为0
}// 判断队列是否为空
bool QueueIsEmpty(SqQueue Q) {return Q.front == Q.rear && Q.tag == 0;
}// 判断队列是否已满
bool QueueIsFull(SqQueue Q) {return Q.front == Q.rear && Q.tag == 1;
}// 入队操作
bool EnQueue(SqQueue &Q, ElemType x) {if (QueueIsFull(Q)) {return false;}Q.data[Q.rear] = x;Q.rear = (Q.rear + 1) % Maxsize;Q.tag = 1; // 插入成功，设置tag为1return true;
}// 出队操作
bool DeQueue(SqQueue &Q, ElemType &x) {if (QueueIsEmpty(Q)) {return false;}x = Q.data[Q.front];Q.front = (Q.front + 1) % Maxsize;Q.tag = 0; // 删除成功，设置tag为0return true;
}

在考试时，也可能出现rear指向队尾元素的情况，如下图所示：

//rear指向队尾元素的后一个位置时入队操作：
Q.data[Q.rear]=x;
Q.rear=(Q.rear+1)%MaxSize;//rear指向队尾元素时入队操作：
Q.rear=(Q.rear+1)%MaxSize;
Q.data[Q.rear]=x;

初始化操作：

void InitQueue(SqQueue &Q){//初始时，队头和队尾指针指向0Q.front=0;Q.rear=MaxSize-1;
}

判空操作： 

//判空
bool QueueEmpty(SqQueue Q){if((Q.rear+1)%MaxSize==Q.front)    //队空条件return true;elsereturn false;

判满操作：

判满也不能用与判空相同的条件了：

可以牺牲一个存储空间，即队空时，队尾指针在队头指针后面一个位置，队满时，队尾指针在队头指针后面两个位置。

或者向上面说的一样，增加辅助变量，如size，tag

这里只演示牺牲一个存储空间的情况：

#define Maxsize 10
typedef struct{ElemType data[Maxsize];int front,rear;
} SqQueue;// 初始化队列
void InitQueue(SqQueue &Q) {Q.front = 0;Q.rear =MaxSze-1;}//判空
bool QueueEmpty(SqQueue Q){if((Q.rear+1)%MaxSize==Q.front)    //队空条件return true;elsereturn false;//判满
bool QueueEmpty(SqQueue Q){if((Q.rear+2)%MaxSize==Q.front)    //队空条件return true;elsereturn false;// 入队操作
bool EnQueue(SqQueue &Q, ElemType x) {if (QueueIsFull(Q)) {return false;}Q.rear=(Q.rear+1)%MaxSize;    //先往后移一个存储空间，再赋值Q.data[Q.rear]=x;return true;
}// 出队操作
bool DeQueue(SqQueue &Q, ElemType &x) {if (QueueIsEmpty(Q)) {return false;}x = Q.data[Q.front];    Q.front = (Q.front + 1) % Maxsize;return true;
}

总结：

4.用链式存储实现队列
•初始化
typedef struct LinkNode{        //链式队列结点ElemType data;struct LinkNode *next;
}LinkNode;typedef struct{    //链式队列LinkNode *front,*rear;    //队列的队头和队尾指针
}LinkQueue;


typedef struct LinkNode{        //链式队列结点ElemType data;struct LinkNode *next;
}LinkNode;typedef struct{    //链式队列LinkNode *front,*rear;    //队列的队头和队尾指针
}LinkQueue;//初始化队列(带头结点)
void InitQueue(LinkQueue &Q){//初始时 front、rear 都指向头结点Q.front=Q.rear=(LinkNode*)malloc(sizeof(LinkNode));Q.front->next=NULL;
}//判断队列是否为空
bool IsEmpty(LinkQueue Q){if(Q.front==Q.rear)return true;elsereturn false;
}void testLinkQueue(){LinkQueue Q;    //声明一个队列InitQueue(Q);   //初始化队列
}//初始化队列(不带头结点)
void InitQueue(LinkQueue &Q){//初始时 front、rear 都指向NULLQ.front=NULL;Q.rear=NULL;
}//判断队列是否为空(不带头结点)
bool IsEmpty(LinkQueue Q){if(Q.front==NULL)return true;elsereturn false;
}

 

•入队操作
//新元素入队(带头结点)
void EnQueue(LinkQueue &Q,ElemType x){LinkNode *s=(LinkNode *)malloc(sizeof(LinkNode));s->data=x;s->next=NULL;    //新结点插入到rear之后    Q.rear->next=s;  //修改表尾指针Q.rear=s;

首先申请一个新结点，并把数据元素放到这一新结点当中：s->data=x;

新插入的结点一定是队列的最后一个结点，所以该结点的next指针指向NULL:s->next=NULL

将rear指向的结点的next指针指向新申请的s结点：Q.rear->next=s;

最后表尾指针会指向新的表尾结点：Q.rear=s;

若不带头结点，在第一个元素入队时，就需要进行特殊的处理：

//新元素入队(不带头结点)
void EnQueue(LinkQueue &Q,ElemType x){LinkNode *s=(LinkNode *)malloc(sizeof(LinkNode));s->data=x;s->next=NULL;if(Q.front == NULL){    //在空队列中插入第一个元素Q.front = s;    //修改队头队尾指针Q.rear=s;    } else {    Q.rear->next=s;    //新结点插入到 rear 结点之后Q.rear=s;    //修改 rear 指针}
}

•出队操作
//队头元素出队(带头结点)
bool DeQueue(LinkQueue &Q,ElemType &x){if(Q.front==Q.rear)return false;    //空队LinkNode *p=Q.front->next;x=p->data;    //用变量x返回队头元素Q.front->next=p->next;    //修改头结点的 next 指针if(Q.rear==p)    //此次是最后一个结点出队Q.rear=Q.front;    //修改rear指针free(p);    //释放结点空间return true;
}

首先用p指向要出队的结点，即头结点之后的结点：LinkNode *p=Q.front->next;

接着修改头结点的后项指针：Q.front->next=p->next;

最后释放结点p：free(p)

若此次出队的结点p是当前队列的最后一个元素，在修改完头结点的后项指针后：

还需要修改表尾指针，让其指向头结点：Q.rear=Q.front;

最后释放p：free(p)

对于不带头结点的队列：

//队头元素出队(不带头结点)
bool DeQueue(LinkQueue &Q,ElemType &x){if(Q.front==NULL)    //空队return false;LinkNode *p=Q.front;    //p指向此次出队的结点x=p->data;    //用变量x返回队头元素Q.front=p->next;    //修改 front 指针if(Q.rear==p){Q.front = NULL;Q.rear = NULL;}free(p);return true;
}

每次出队的是front指针指向的结点：LinkNode *p=Q.front;

由于没有头结点，所以每一次队头出队时，就需要修改队头指针指向的结点：

Q.front=p->next;

最后一个结点出队后，将front和rear都指向NULL：Q.front=NULL;Q.rear=NULL;

•队列满的条件

对于顺序存储的队列，存储空间都是预分配的，预分配的存储空间耗尽，则队满。而对链式存储而言，一般不会对满，除非内存不足。

三.双端队列

之前学习的栈，只允许从一端插入和删除的线性表：

队列则只允许从一端插入，另一端删除的线性表：

双端队列则是允许从两端插入，也允许从两端删除的线性表：

若只使用其中一端的插入、删除操作，则效果等同于栈。所以，只要是栈能实现的功能，双端队列一定能够实现。

双端队列还可以分为：

输入受限的双端队列：只允许从一端插入、两端删除的线性表。

输出受限的双端队列：只允许从两端插入、一端删除的线性表。

对于栈而言，合法的出栈序列有14种，可用卡特兰数计算：

对于输入受限的双端队列：

在栈中合法的序列，在双端队列中一定合法，所以只需要看“在栈中不合法”的输出队列即可。

可以得到以下结果，划线的是在栈中不合法，而在输入受限的双端队列中合法的序列：

对于输出受限的双端队列，同理：

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

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Annaconda的替代品miniforge！

Annaconda的替代品miniforge！

用了多年的Annaconda竟然要收费了（个人不收费，企业收费，但个人电脑在企业IP下，还是被警告了），只能用miniforge 全面替换了！ 一、卸载anaconda windows下卸载， 设置 -> 应用和功…
阅读更多...
【算法】动态规划练习（一）

【算法】动态规划练习（一）

目录 1137. 第 N 个泰波那契数 分析 代码 面试题 08.01. 三步问题 分析 代码 746. 使用最小花费爬楼梯 分析 代码 泰波那契序列 Tn 定义如下： T0 0, T1 1, T2 1, 且在 n > 0 的条件下 Tn3 Tn Tn1 Tn2 给你整数 n，请返回第 n 个泰波…
阅读更多...
C++进阶篇11---IO流

C++进阶篇11---IO流

一、对C语言的输入输出的理解 C语言中我们经常用scanf()和printf()进行输入输出，形象的描述它们的作用如下 对于缓冲区的理解： 可以屏蔽掉低级I/O的实现，低级I/O的实现依赖操作系统本身内核的实现，所以如果能够屏蔽这部分的差异…
阅读更多...
基于PHP的校园招聘管理系统

基于PHP的校园招聘管理系统

有需要请加文章底部Q哦 可远程调试 基于PHP的校园招聘管理系统 一 介绍 此校园招聘管理系统基于原生PHP开发，数据库mysql，前端bootstrap。系统角色分为个人用户，企业和管理员三种。 技术栈：phpmysqlbootstrapphpstudyvscode 二…
阅读更多...
蓝桥杯第十四届C++C组

蓝桥杯第十四届C++C组

目录 三国游戏 填充 翻转 【单调队列优化DP】子矩阵 【快速幂、欧拉函数】互质数的个数 【tire树】异或和之差 【质因数分解】公因数匹配 子树的大小 三国游戏 题目描述 小蓝正在玩一款游戏。游戏中魏蜀吴三个国家各自拥有一定数量的士兵X, Y, Z (一开始可以认为都…
阅读更多...
C语言整数和小数的存储

C语言整数和小数的存储

1.整数在内存中的存储 计算机使用二进制进行存储、运算，整数在内存中存储使用的是二进制补码 1.1原码、反码、补码 整数的2进制表⽰⽅法有三种，即 原码、反码和补码 三种表⽰⽅法均有符号位和数值位两部分，符号位都是⽤0表⽰“正”&am…
阅读更多...
Qt实现无边框圆角窗口

Qt实现无边框圆角窗口

我们在使用QDialog的时候许多场景下都不需要默认的标题栏，这时候我们需要设置他的标志位。 this->setWindowFlags(Qt::FramelessWindowHint);由于现代的窗口风格，我们一般会设置窗口为圆角边框的样式，我们可以使用qss的方式来进行设置。 …
阅读更多...
汇编——SSE打包整数

汇编——SSE打包整数

SSE也可以进行整数向量的加法，示例如下： ;sse_integer.asm extern printfsection .datadummy db 13 align 16pdivector1 dd 1dd 2dd 3dd 4pdivector2 dd 5dd 6dd 7dd 8fmt1 db "Packed Integer Vector 1: %d, %d, %d, %d",…
阅读更多...
提升团队工程交付能力，从“看见”工程活动和研发模式开始

提升团队工程交付能力，从“看见”工程活动和研发模式开始

作者：张裕、雅纯 理想中的研发团队应当具有以下特征： 总是工作在最高优先级的事项上 理想的研发团队能够识别并始终集中精力在当前最紧迫和最有价值的任务上。这需要团队具备出色的项目管理能力和决策能力，以便能够正确评估优先级&#xff0…
阅读更多...
Ant Design Vue

Ant Design Vue

Ant Design Vue是一个由阿里巴巴团队打造的Vue组件库，它以其优雅的设计和丰富的功能集成而被广泛使用。以下是对Ant Design Vue的简单介绍： 首先，Ant Design Vue采用了精良的设计风格，为用户提供了简约、美观的界面，符…
阅读更多...
MySQL-视图：视图概述、创建、查看、更新、修改、删除

MySQL-视图：视图概述、创建、查看、更新、修改、删除

第14章 视图 1. 常见的数据库对象2. 视图概述2.1 为什么使用视图？2.2 视图的理解 3. 创建视图3.1 创建单表视图3.2 创建多表联合视图3.3 基于视图创建视图 4. 查看视图5. 更新视图的数据5.1 一般情况5.2 不可更新的视图 6. 修改、删除视图6.1 修改视图6.2 删除视图 …
阅读更多...
微信小程序使用自己的布局

微信小程序使用自己的布局

我第一天学习微信小程序，照着黑马程序员老师的操作模仿编辑。因为视频是23年的，我24年4月份学习发现很多地方不一样了。 新版微信开发者工具中没有自带wxss文件。我自己建了一个list.wxss文件，发现用不了，在list.wxml文件中编写v…
阅读更多...
pbootcms模板网站饰品首饰玛瑙水晶钻石饰品玉石戒指复古珠宝饰品pbcms网站源码下载

pbootcms模板网站饰品首饰玛瑙水晶钻石饰品玉石戒指复古珠宝饰品pbcms网站源码下载

内容目录 一、详细介绍二、效果展示1.部分代码2.效果图展示 三、学习资料下载 一、详细介绍 pbootcms模板网站饰品首饰玛瑙水晶钻石饰品玉石戒指复古珠宝饰品pbcms网站源码下载PC版 pbootcms内核开发的网站模板，该模版适用于饰品首饰类企业网站，复古珠…
阅读更多...
spring面试八股

spring面试八股

常用的注册bean的方式 ComponentScan扫描到的service和Controller等的注解 Configration配置类或者是xml文件的定义。 spring中有几种依赖注入的方式 1.构造器注入。 2.setter方法注入。 3.使用field属性的方式注入。 applicationContext是什么 spring bean spring aop Aop…
阅读更多...
iOS 应用内网络请求设置代理

iOS 应用内网络请求设置代理

主要通过URLSessionConfiguration 的connectionProxyDictionary 属性 为了方便其他同学使用，我们可以通过界面来进行设定（是否开启代理、服务端、端口），从而达到类似系统上的设定 具体链接参考：为 iOS 网络请求设置代理…
阅读更多...
【电子取证篇】USB软只读锁软件

【电子取证篇】USB软只读锁软件

【电子取证篇】USB软只读软件 推荐的这两款USB只读软件都免安装版本，方便携带—【蘇小沐】 1、实验环境 Removable Access Tool_v1.2usbblock_v1.0Windows 11 专业工作站版23H2（22631.3374） （一）Removable Access …
阅读更多...
Spring——框架介绍

Spring——框架介绍

每一个Java技术中都会存在一个“核心对象”，这个核心对象来完成主要任务为了得到核心对象，需要创建若干个辅助对象，从而导致开发步骤增加JDBC中 JDBC 核心对象——PreparedStatement 通过DriverManager得到数据库厂商提供的Driver对象DriverM…
阅读更多...
【御控物联】JSON结构数据转换在物流调度系统中的应用（场景案例三）

【御控物联】JSON结构数据转换在物流调度系统中的应用（场景案例三）

文章目录 一、前言二、场景概述三、解决方案四、在线转换工具五、技术资料 一、前言 物流调度是每个生产厂区必不可少的一个环节，主要包括线边物流和智能仓储。线边物流是指将物料定时、定点、定量配送到生产作业一线的环节，其包括从集中仓库到线边仓、…
阅读更多...
【LeetCode】894. 所有可能的真二叉树

【LeetCode】894. 所有可能的真二叉树

文章目录 [894. 所有可能的真二叉树](https://leetcode.cn/problems/all-possible-full-binary-trees/)思路一：分治代码：思路二：记忆化搜索代码： 894. 所有可能的真二叉树 思路一：分治 1.递归，n1 时&#…
阅读更多...
Cute Background FX

Cute Background FX

Cute Background FX是环境背景粒子系统的集合。非常适合作为菜单的背景。 该包包括： -20个独特预制件+20个URP预制件 -5种独特的环境设计 -15种纹理 -2个自定义着色器+2个URP着色器 -共59项独特资产 -一个演示场景，您可以在其中概述所有内容。 所有纹理都是512x512分辨率的P…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023