（1.2.2）栈、队列的的结构定义和基本操作

一、栈：限定仅在表尾进行插入或删除操作的线性表

（1）结构定义

          1.1）顺序栈的结构图定义

 <img src="https://img-blog.csdn.net/20150313130623819?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvZmVpMjAxMjExMDY=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center" alt="" />
typedef struct{
int data[maxsize];
int top;
}sqtack;

         1.2）顺序栈的基本操作： 先存取，后移动指针

int stack[maxsize]; int top=-1;//初始化声明，<span style="font-size:18px;color:#ff0000;">注意，该方法会导致top指针指向第一个栈顶节点，而不是头结点</span>
stack[++top]=x;//进栈
x=stack[top--];//出栈
stack.top==1;//验证空栈
stack.top==maxize-1;//验证满栈

       2.1）链栈的结构定义   注意：该图中没有表示头结点

typedef struct{
int data;
Lnode * next;
}LNode;

    2.2）链栈的基本操作
入栈：  lst-next=p->next; lst->netx=p;

出栈：

x=lst->next;

 p=lst->next; 

lst->next=p->next;

free(p);

二、队列 ：表尾入，表头出

（1）顺序队列

1. /*队列的数据抽象*/  
2. typedef struct    
3. {  
4.     int data[maxsize] ;
5.     int front;//队列头指针  
6.     int rear;//队列尾指针  
7. } SqQueue;  

1.   
2. /*判断队列是否为空*/  
3. bool IsEmpty(SqQueue Q)  
4. {  
5.     return Q.front==Q.rear;  
6. }  
7.   
8.   
9. /*判断队列是否已满,这里我们牺牲一个空间，为甚么？你懂的*/  
10. bool IsFull(SqQueue Q)  
11. {  
12.     return ((Q.rear+1)%MAXQSIZE)==Q.front;  
13. }  
14.   
15.   
16.   
17.   
18. /*获取队列长度*/  
19. int QueueLength(SqQueue Q)  
20. {  
21.     return (Q.rear-Q.front+MAXQSIZE)%MAXQSIZE;  
22. }  
23.   
24.   
25.   
26. /*入队列*/  
27. status InQueue(SqQueue &Q,QElementType e)  
28. {  
29.     //判断队列是否已满  
30.     if(IsFull(Q))  
31.         return _ERROR;  
32.     Q.base[Q.rear]=e;  
33.     Q.rear = (Q.rear+1)%MAXQSIZE;  
34.     return _OK;  
35. }  
36.   
37.   
38. /*出队列*/  
39. status OutQueue(SqQueue &Q,QElementType &e)  
40. {  
41.     /*判断队列是否为空*/  
42.     if(IsEmpty(Q))  
43.         return _ERROR;  
44.     e = Q.base[Q.front];  
45.     Q.front = (Q.front + 1)%MAXQSIZE;  
46.     return _OK;  
47. }  

(2)链队列

1. struct Node  
2. {  
3.       T data;  
4.       Node<T> *next;  //此处<T>也可以省略  
5. };  

1. struct Queue  
2. {  
3.        Node   *rear;
4.       Node   *front;  
5. };  

进队

1.     Q->rear->next=s;       //将结点s插入到队尾  ,Q为头结点，也就是头指针
2.     Q->rear=s;  

出队

1.     if (rear==front) throw "下溢";  
2.     p=front->next;   
3.     x=p->data;                       //暂存队头元素  
4.     front->next=p->next;             //将队头元素所在结点摘链  
5.     if (p->next==NULL) rear=front;   //判断出队前队列长度是否为1