03 栈和队列
栈
- 定义
栈（Stack）是限定仅在表尾进行插入和删除操作的线性表，栈又称为后进先出（Last In First Out）的线性表，简称LIFO结构
ADT 栈(stack)
Data
同线性表。元素具有相同的类型，相邻元素具有前驱和后堆关系。
Operation
InitStack ( *S )：初始化操作.建立一个空栈S。
DestroyStack ( *S )：若栈存在，则销毁它。
ClearStack (*S)：将栈清空。
StackEmpty ( S ):若栈为空，返回true,否则返回 false。
GetTop (S,*e)：若栈存在且非空，用e返回S的栈顶元素。
Push (*S,e)：若栈S存在，插入新元素e到栈S中并成为栈顶元素。
Pop (*S,*e)：删除栈S中栈顶元素，并用e返回其值。
StackLength (S)：返回回栈S的元素个数。
endADT
-
顺序存储结构
typedef int SElemType; /* SElemType类型根据实际情况而定，这里假设为int */ /* 顺序栈结构 */ typedef struct { SElemType data[MAXSIZE]; int top; /* 用于栈顶指针 */ }SqStack;-
出栈操作：时间复杂度O（1）
/* 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR */ Status Pop(SqStack *S,SElemType *e) { if(S->top==-1) return ERROR; *e=S->data[S->top]; /* 将要删除的栈顶元素赋值给e */ S->top--; /* 栈顶指针减一 */ return OK; } -
进栈操作：时间复杂度O（1）
/* 插入元素e为新的栈顶元素 */ Status Push(SqStack *S,SElemType e) { if(S->top == MAXSIZE -1) /* 栈满 */ { return ERROR; } S->top++; /* 栈顶指针增加一 */ S->data[S->top]=e; /* 将新插入元素赋值给栈顶空间 */ return OK; } -
两栈共享空间
-
结构
/* 两栈共享空间结构 */ typedef struct { SElemType data[MAXSIZE]; int top1; /* 栈1栈顶指针 */ int top2; /* 栈2栈顶指针 */ }SqDoubleStack; -
push
/* 插入元素e为新的栈顶元素 */ Status Push(SqDoubleStack *S,SElemType e,int stackNumber) { if (S->top1+1==S->top2) /* 栈已满，不能再push新元素了 */ return ERROR; if (stackNumber==1) /* 栈1有元素进栈 */ S->data[++S->top1]=e; /* 若是栈1则先top1+1后给数组元素赋值。 */ else if (stackNumber==2) /* 栈2有元素进栈 */ S->data[--S->top2]=e; /* 若是栈2则先top2-1后给数组元素赋值。 */ return OK; } -
pop
/* 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR */ Status Pop(SqDoubleStack *S,SElemType *e,int stackNumber) { if (stackNumber==1) { if (S->top1==-1) return ERROR; /* 说明栈1已经是空栈，溢出 */ *e=S->data[S->top1--]; /* 将栈1的栈顶元素出栈 */ } else if (stackNumber==2) { if (S->top2==MAXSIZE) return ERROR; /* 说明栈2已经是空栈，溢出 */ *e=S->data[S->top2++]; /* 将栈2的栈顶元素出栈 */ } return OK; }
-
-
-
链式存储结构
/* 链栈结构 */ typedef struct StackNode { SElemType data; struct StackNode *next; }StackNode,*LinkStackPtr; typedef struct { LinkStackPtr top; int count; }LinkStack;-
进栈操作：时间复杂度O（1）
/* 插入元素e为新的栈顶元素 */ Status Push(LinkStack *S,SElemType e) { LinkStackPtr s=(LinkStackPtr)malloc(sizeof(StackNode)); s->data=e; s->next=S->top; /* 把当前的栈顶元素赋值给新结点的直接后继，见图中① */ S->top=s; /* 将新的结点s赋值给栈顶指针，见图中② */ S->count++; return OK; } -
出栈操作：时间复杂度O（1）
/* 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR */ Status Pop(LinkStack *S,SElemType *e) { LinkStackPtr p; if(StackEmpty(*S)) return ERROR; *e=S->top->data; p=S->top; /* 将栈顶结点赋值给p，见图中③ */ S->top=S->top->next; /* 使得栈顶指针下移一位，指向后一结点，见图中④ */ free(p); /* 释放结点p */ S->count--; return OK; } -
总结：对比一下顺序栈和链栈，它们在时间复杂度上是一样的，均为O（1）。对于空间性能，顺序栈需要事先确定一个固定的长度，可能会存在内存空间浪费的问题，但它的优势是存取时定位很方便，而链栈则要求每个元素都有指针域，这同时也增加了一些内存开销，但对于栈的长度无限制。所以它们的区别和线性表中讨论的一样，如果栈的使用过程中元素变化不可预料，有时很小，有时非常大，那么最好是用链栈，反之，如果它的变化在可控范围内，建议使用顺序栈会更好一些。
-
-
作用
栈的引入简化了程序设计的问题，划分了不同关注层次，使得思考范围缩小，更加聚焦于我们要解决的问题核心。
-
栈的应用
-
递归：斐波那契数列的实现
把一个直接调用自己或通过一系列的调用语句间接地调用自己的函数，称做递归函数
#include "stdio.h" int Fbi(int i) /* 斐波那契的递归函数 */ { if( i < 2 ) return i == 0 ? 0 : 1; return Fbi(i - 1) + Fbi(i - 2); /* 这里Fbi就是函数自己，等于在调用自己 */ } int main() { int i; int a[40]; printf("迭代显示斐波那契数列：\n"); a[0]=0; a[1]=1; printf("%d ",a[0]); printf("%d ",a[1]); for(i = 2;i < 40;i++) { a[i] = a[i-1] + a[i-2]; printf("%d ",a[i]); } printf("\n"); printf("递归显示斐波那契数列：\n"); for(i = 0;i < 40;i++) printf("%d ", Fbi(i)); return 0; } -
四则运算表达式求值
9 + ( 3 - 1 ) * 3 + 10 / 2
-
后缀（逆波兰）表示法
9 3 1 - 3 * + 10 2 / + -
中缀表达式转后缀表达式
-
后缀表达式计算结果
中缀表达式转成后缀表达式后，借助栈来计算结果
-
-
队列
- 定义
队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。队列是一种先进先出（First In First Out）的线性表，简称FIFO，允许插入的一端称为队尾，允许删除的一端称为队头。
ADT 队列 (Queue)
Data
同线性表。元素具有相同的类型，相邻元素具有前驱和后继关系 。
Operation
InitQueue(*Q) :初始化操作,建立一个空队列Q。
DestroyQueue(*Q) :若队列Q存在，则销毁它。
ClearQueue(*Q) :将队列Q清空。
QueueEmpty(Q) :若队列Q为空，返回true，否则返回false。
GetHead(Q,*e) :若队列Q存在且非空，用e返回队列Q的队头元素。
EnQueue(*Q,e) :若队列Q存在，插入新元素e到队列Q中并成为对尾元素 。
DeQueue(*Q,*e) :删除队列Q中队头元素，并用e返回其值。
QueueLength(Q) :返回队列Q的元素个数
endADT
-
顺序存储结构
-
循环队列
我们把队列的这种头尾相接的顺序存储结构称为循环队列
-
循环队列的顺序存储结构如下：
typedef int QElemType; /* QElemType类型根据实际情况而定，这里假设为int */ /* 循环队列的顺序存储结构 */ typedef struct { QElemType data[MAXSIZE]; int front; /* 头指针 */ int rear; /* 尾指针，若队列不空，指向队列尾元素的下一个位置 */ }SqQueue; -
循环队列初始化：
/* 初始化一个空队列Q */ Status InitQueue(SqQueue *Q) { Q->front=0; Q->rear=0; return OK; } -
循环队列求队列长度代码如下：
/* 返回Q的元素个数，也就是队列的当前长度 */ int QueueLength(SqQueue Q) { return (Q.rear-Q.front+MAXSIZE)%MAXSIZE; } -
循环队列的入队列操作代码：
/* 若队列未满，则插入元素e为Q新的队尾元素 */ Status EnQueue(SqQueue *Q,QElemType e) { if ((Q->rear+1)%MAXSIZE == Q->front) /* 队列满的判断 */ return ERROR; Q->data[Q->rear]=e; /* 将元素e赋值给队尾 */ Q->rear=(Q->rear+1)%MAXSIZE;/* rear指针向后移一位置， */ /* 若到最后则转到数组头部 */ return OK; } -
循环队列的出队列操作代码
/* 若队列不空，则删除Q中队头元素，用e返回其值 */ Status DeQueue(SqQueue *Q,QElemType *e) { if (Q->front == Q->rear) /* 队列空的判断 */ return ERROR; *e=Q->data[Q->front]; /* 将队头元素赋值给e */ Q->front=(Q->front+1)%MAXSIZE; /* front指针向后移一位置， */ /* 若到最后则转到数组头部 */ return OK; }
-
-
链式存储结构
队列的链式存储结构，其实就是线性表的单链表，只不过它只能尾进头出而已，我们把它简称为链队列。
typedef int QElemType; /* QElemType类型根据实际情况而定，这里假设为int */ typedef struct QNode /* 结点结构 */ { QElemType data; struct QNode *next; }QNode,*QueuePtr; typedef struct /* 队列的链表结构 */ { QueuePtr front,rear; /* 队头、队尾指针 */ }LinkQueue;-
入队操作
/* 插入元素e为Q的新的队尾元素 */ Status EnQueue(LinkQueue *Q,QElemType e) { QueuePtr s=(QueuePtr)malloc(sizeof(QNode)); if(!s) /* 存储分配失败 */ exit(OVERFLOW); s->data=e; s->next=NULL; Q->rear->next=s; /* 把拥有元素e的新结点s赋值给原队尾结点的后继，见图中① */ Q->rear=s; /* 把当前的s设置为队尾结点，rear指向s，见图中② */ return OK; } -
出队操作
/* 若队列不空,删除Q的队头元素,用e返回其值,并返回OK,否则返回ERROR */ Status DeQueue(LinkQueue *Q,QElemType *e) { QueuePtr p; if(Q->front==Q->rear) return ERROR; p=Q->front->next; /* 将欲删除的队头结点暂存给p，见图中① */ *e=p->data; /* 将欲删除的队头结点的值赋值给e */ Q->front->next=p->next;/* 将原队头结点的后继p->next赋值给头结点后继，见图中② */ if(Q->rear==p) /* 若队头就是队尾，则删除后将rear指向头结点，见图中③ */ Q->rear=Q->front; free(p); return OK; }
-
-
总结：
对于循环队列与链队列的比较，可以从两方面来考虑，从时间上，其实它们的基本操作都是常数时间，即都为O（1），不过循环队列是事先申请好空间，使用期间不释放，而对于链队列，每次申请和释放结点也会存在一些时间开销，如果入队出队频繁，则两者还是有细微差异，对于空间上来说，循环队列必须有一个固定的长度，所以就有了存储元素个数和空间浪费的问题。而链队列不存在这个问题，尽管它需要一个指针域，会产生一些空间上的开销，但也可以接受。所以在空间上，链队列更加灵活。总的来说，在可以确定队列长度最大值的情况下，建议用循环队列，如果你无法预估队列的长度时，则用链队列。