棧和隊列
- 1 棧
- 棧的順序存儲
- 棧的鏈式存儲
- 2 隊列
- 隊列的順序存儲
- 隊列的鏈式存儲
- 3 棧和隊列的應用
- 用棧實現隊列
- 用隊列實現棧
- 最小棧
1 棧
參考文章:
https://zhuanlan.zhihu.com/p/346164833
https://zhuanlan.zhihu.com/p/120965372#:~:text=%E6%A0%88%E6%98%AF%E4%B8%80%E7%A7%8D%20%E5%90%8E%E8%BF%9B%E5%85%88%E5%87%BA%EF%BC%88LIFO%EF%BC%89,%E7%9A%84%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%20%E8%BF%9B%E6%A0%88%E7%9A%84%E9%A1%BA%E5%BA%8F%E4%B8%BAa1%2Ca2%2Ca3%2Ca4%2Ca5%EF%BC%8C%E5%87%BA%E6%A0%88%E7%9A%84%E9%A1%BA%E5%BA%8F%E4%B8%BAa5%2Ca4%2Ca3%2Ca2%2Ca1
棧是一種特殊的線性表,僅允許在一端進行插入和刪除。被允許插入和刪除的一端為棧頂(top),另一端稱為棧底(bottom),棧底是固定的,不允許進行插入和刪除
棧的主要基本操作有:
- InitStack(&S):初始化棧
- StackEmpty(S):判斷一個棧是否為空
- Push(&S,x):進棧,若棧未滿,則將x加入到棧頂
- pop(&S,&x):出棧,若棧非空,則將棧頂元素出棧,并用x返回
棧的順序存儲
采用順序存儲的棧稱為順序棧,用數組實現。
棧的定義為:
#define STACK_SIZE 100typedef int ElmType;typedef struct{int top; /* 棧頂指針 */ElmType data[STACK_SIZE]; /* 順序棧 */
}SqStack;
- 棧頂指針:S.top,初始時設置S.top = -1;棧頂元素:S.data[top];
- 進棧操作:先判斷S.top==STACK_SIZE-1,若棧不滿,S.top加1,然后將值送到棧頂。
- 出棧操作:棧非空時,先去棧頂元素值,然后再將棧頂指針減1
- 棧空條件:S.top==-1
- 棧滿條件:S.top==STACK_SIZE-1
- 棧長:S.top+1
棧的鏈式存儲
采用鏈式存儲的棧稱為鏈棧,鏈棧的優點是便于多個棧共享存儲空間和提高其效率,且不存在棧滿上溢的情況。通常采用單鏈表實現,并規定所有操作都是在單鏈表的表頭進行的。這里規定鏈棧沒有頭結點,top指向棧頂元素,
鏈棧的存儲可定義為:
typedef int ElemType;
typedef struct LinkNode{ElemType data;struct LinkNode *next;
}LinkStack;
2 隊列
隊列是只允許在一端進程插入操作,在另一端進行刪除操作的線性表。被允許插入的一端叫隊尾(rear),被允許刪除的一端叫隊頭(front)。
隊列的主要基本操作有:
- InitQueue(&Q):初始化隊列
- QueueEmpty(Q):判斷隊列是否為空
- QueueLenght(Q):判斷隊列中元素的個數
- push(&Q,x):入隊,如果隊列沒有滿,就在隊尾插入x
- pop(&Q,&x):出隊,如果隊列非空,就在隊首刪除一個元素,并用x返回
隊列的順序存儲
類型定義為:
#define QUEUE_SIZE 100
typedef int ElemType;
typedef struct
{ElemType data[QUEUE_SIZE]; /* 隊列 */int front; /* 隊首 */int rear; /* 隊尾 */
}SqQueue;
由于普通隊列存在溢出問題,所以我們用循環隊列,循環隊列的定義和普通隊列定義一樣。
說明:這里浪費一個存儲空間
- 初始化:rear=front=0
- 添加一個元素:如果隊列沒有滿,則插入,即Q[rear] = x,rear= (rear+1)%QUEUE_SIZE
- 刪除一個元素:如果隊列非空,則刪除,即*x=Q[front],front = (front+1)% QUEUE_SIZE
- 判斷隊列是否為空:rear==front
- 判斷隊列是否滿:(rear+1)%QUEUE_SIZE==front
- 隊列元素個數:(rear-front+QUEUE_SIZE)%QUEUE_SIZE
隊列的鏈式存儲
隊列的數組實現比較麻煩,需要考慮各種邊界情況,所以通常使用鏈表形式來實現隊列。
使用單向鏈表來實現鏈式隊列,鏈式隊列中存儲front和rear即可。
typedef int ElemType;
typedef struct node
{int date;struct node *next;
}LinkNode;
typedef struct queue{LinkNode *front;LinkNode *rear;
}LinkQueue;
3 棧和隊列的應用
用棧實現隊列
參考文章:https://cloud.tencent.com/developer/article/1643318
LeedCode題目位置:232. 用棧實現隊列
隊列的特性是新加入的元素在隊尾,最先入隊的元素排在隊首,按隊首到隊尾的順序依次出棧。用棧實現隊列,需要把新加入的元素保留在棧底,保證棧頂是隊列最先加入的元素。
所以我們用兩個棧A、B來實現,每次入隊時,先把存放數據的棧A彈出到另一個棧B,然后把數據存到A,最后把B中的元素依次彈出壓入A棧中,這樣保證了新加入的元素在棧底。
隊列出隊是把隊列隊首的刪除,對應棧是把棧A的棧頂元素刪除。
實現代碼如下:
#include <stdlib.h>typedef char bool;#define SIZE 100
#define false 0
#define true 1
/* 棧的定義 */
typedef struct{int length;int data[SIZE];
}Stack;/* 初始化棧 */
Stack *initStack()
{Stack * ret = malloc(sizeof(Stack));ret->length=-1;return ret;
}/* 判斷棧是否為空 */
bool StackEmpty(Stack *s)
{return s->length==-1;
}/* 入棧操作 */
bool stackPush(Stack *s,int x)
{if(s->length==SIZE-1){return false;}s->length++;s->data[s->length]=x;return true;
}
/* 出棧操作 */
bool stackPop(Stack *s,int *x)
{if(s->length==-1){return false;}*x = s->data[s->length];s->length--;return true;
}/* 釋放棧 */
void freeStack(Stack *s)
{free(s);
}typedef struct {Stack *inStack;Stack *outStack;
} MyQueue;/* 創造隊列 */
MyQueue* myQueueCreate() {MyQueue *ret = (MyQueue *)malloc(sizeof(MyQueue));ret->inStack = initStack();ret->outStack = initStack();return ret;
}void myQueuePush(MyQueue* obj, int x) {int y;/* 先把棧A的元素依次彈出放到棧B */while(stackPop(obj->inStack,&y)){stackPush(obj->outStack,y);}/* 把入隊的元素放到棧A的棧底 */stackPush(obj->inStack,x);/* 依次彈出棧B的元素放到棧A */while(stackPop(obj->outStack,&y)){stackPush(obj->inStack,y);}
}int myQueuePop(MyQueue* obj) {int x;/* 刪除棧A的棧頂元素 */stackPop(obj->inStack,&x);return x;
}int myQueuePeek(MyQueue* obj) {return obj->inStack->data[obj->inStack->length];
}bool myQueueEmpty(MyQueue* obj) {return StackEmpty(obj->inStack);
}void myQueueFree(MyQueue* obj) {free(obj->inStack);free(obj->outStack);free(obj);
}/*** Your MyQueue struct will be instantiated and called as such:* MyQueue* obj = myQueueCreate();* myQueuePush(obj, x);* int param_2 = myQueuePop(obj);* int param_3 = myQueuePeek(obj);* bool param_4 = myQueueEmpty(obj);* myQueueFree(obj);
*/
用隊列實現棧
參考文章:https://cloud.tencent.com/developer/article/1643318
LeedCode題目位置:225. 用隊列實現棧
棧的特性是新加入的元素出現在棧頂,刪除的元素也在棧頂,隊列的特性是新加入的特性在隊尾,刪除的元素在隊首。
我們可以讓數據先入隊列,然后把隊列的以前的數據依次出隊再入隊,這樣保證了新壓入的數據在隊首,對應棧的棧頂。
出棧的話,對應隊列的操作就是把隊首的元素刪除即可。
實現代碼如下:
#include <stdlib.h>#define false 0
#define true 1
#define SIZE 101typedef struct{int front; // 隊首int rear; //隊尾int data[SIZE];
}Queue;/* 初始化隊列 */
Queue * initQueue()
{Queue * ret = (Queue *)malloc(sizeof(Queue));ret->front=0;ret->rear=0;return ret;
}
/* 判斷隊列是否為空 */
bool QueueEmpty(Queue *q)
{if(q->front==q->rear){return true;}elsereturn false;
}/* 入隊 */
bool queuePush(Queue *q,int x)
{/* 隊滿 */if(q->front == (q->rear+1)%SIZE){return false;}q->data[q->rear]=x;q->rear =(q->rear+1)%SIZE;return true;
}
/* 出隊 */
bool QueuePop(Queue *q,int *x)
{/* 隊列是否為空 */if(q->front==q->rear)return false;*x = q->data[q->front];q->front = (q->front+1)%SIZE;return true;
}
/* 獲取隊首元素 */
int getQueueTop(Queue *q)
{return q->data[q->front];
}
typedef struct {Queue *q;
} MyStack;MyStack* myStackCreate() {MyStack *ret = (MyStack *)malloc(sizeof(MyStack));ret->q = initQueue();return ret;
}void myStackPush(MyStack* obj, int x) {int y;/* 計算現在有多少個元素 */int length = (obj->q->rear-obj->q->front+SIZE)%SIZE;/* x入隊 */queuePush(obj->q,x);for(int i=0;i<length;i++){/* 出隊 */QueuePop(obj->q,&y);/* 入隊 */queuePush(obj->q,y);}
}
/* 只需將隊首元素刪除 */
int myStackPop(MyStack* obj) {int x;QueuePop(obj->q,&x);return x;
}int myStackTop(MyStack* obj) {return getQueueTop(obj->q);
}bool myStackEmpty(MyStack* obj) {return QueueEmpty(obj->q);
}void myStackFree(MyStack* obj) {free(obj->q);free(obj);
}/*** Your MyStack struct will be instantiated and called as such:* MyStack* obj = myStackCreate();* myStackPush(obj, x);* int param_2 = myStackPop(obj);* int param_3 = myStackTop(obj);* bool param_4 = myStackEmpty(obj);* myStackFree(obj);
*/
最小棧
LeedCode位置:155. 最小棧
題目要求在常數時間內檢索到最小元素的棧,所以我們在棧里面設置一個變量min來記錄最小元素的位置。
當插入元素,如果插入的元素比棧內的元素都要小,這個時候需要更新min;當刪除元素時,如果此時最小的元素在棧頂,也需要更新min值。
代碼實現如下:
#include <stdlib.h>#define SIZE 30000typedef struct {int length; //記錄元素個數,始終指向棧頂元素int min; //記錄最小元素的位置int data[SIZE];
} MinStack;int getStackMin(MinStack *s)
{int min =0;for(int i=1;i<=s->length;i++){if(s->data[min]>s->data[i]){min = i;}}return min;
}MinStack* minStackCreate() {MinStack *ret = (MinStack *)malloc(sizeof(MinStack));ret->length = -1;ret->min = 0;return ret;
}void minStackPush(MinStack* obj, int val) {obj->data[++obj->length]=val;/* 插入的元素比棧內的元素都要小,這個時候需要更新min */if(val<obj->data[obj->min])obj->min = obj->length;
}void minStackPop(MinStack* obj) {obj->length--;/* 刪除元素時,如果此時最小的元素在棧頂,也需要更新min值 */if(obj->min==(obj->length+1)){obj->min = getStackMin(obj);}
}int minStackTop(MinStack* obj) {return obj->data[obj->length];
}int minStackGetMin(MinStack* obj) {return obj->data[obj->min];
}void minStackFree(MinStack* obj) {free(obj);
}/*** Your MinStack struct will be instantiated and called as such:* MinStack* obj = minStackCreate();* minStackPush(obj, val);* minStackPop(obj);* int param_3 = minStackTop(obj);* int param_4 = minStackGetMin(obj);* minStackFree(obj);
*/