复习 [数据结构] ---- 栈和队列

1. 1. 1. 1. /*------------------------------------- 
         2.     链队列  
         3. -------------------------------------*/ 
         4. #include <stdio.h> 
         5. #include <stdlib.h> 
         6. #define ElemType char 
         7. #define MaxSize 100
         9. typedef struct node     //定义节点类型 
         10. { 
         11.     ElemType data;      //数据域 
         12.     struct node *next;  //指针域 
         13. }SNode; 
         15. typedef struct
         16. {   
         17.     SNode *front;
         18.     SNode *rear;
         19. }LQueue;
         21. void InitQueue(LQueue *&qu)
         22. {
         23.     qu=(LQueue *)malloc(sizeof(LQueue));    //建立链队头节点
         24.     qu->front=qu->rear=NULL;
         25. }
         27. void EnQueue(LQueue *&qu,ElemType x)
         28. {
         29.     SNode *s;
         30.     s=(SNode *)malloc(sizeof(SNode));
         31.     s->data=x;
         32.     s->next=NULL;
         33.     if(qu->rear==NULL)                  //原来为空队
         34.     {
         35.         qu->front=qu->rear=s;
         36.     }
         37.     else
         38.     {
         39.         qu->rear->next=s;               //将*s插入队尾
         40.         qu->rear=s;                     //由qu->rear指向
         41.     }
         42. }
         44. int DeQueue(LQueue *&qu,ElemType &x)
         45. {
         46.     SNode *p;
         47.     if(qu->rear==NULL)
         48.         return 0;
         49.     p=qu->front;
         50.     if(qu->front==qu->rear)
         51.         qu->front=qu->rear=NULL;
         52.     else
         53.         qu->front=qu->front->next;
         54.     x=p->data;
         55.     free(p);
         56.     return 1;
         57. }
         59. int QueueEmpty(LQueue *qu)
         60. {
         61.     if(qu->front==NULL)
         62.         return 1;
         63.     else
         64.         return 0;
         65. }
         67. void main()
         68. {
         69.     LQueue *lq;
         70.     InitQueue(lq);
         71.     EnQueue(lq,'A');
         72.     EnQueue(lq,'B');
         73.     EnQueue(lq,'C');
         74.     EnQueue(lq,'D');
         75.     EnQueue(lq,'E');
         77.     char Temp;
         79.     Temp=NULL;
         80.     DeQueue(lq,Temp);
         81.     printf("出队元素为:%c/n",Temp);
         83.     Temp=NULL;
         84.     DeQueue(lq,Temp);
         85.     printf("出队元素为:%c/n",Temp);
         87.     Temp=NULL;
         88.     DeQueue(lq,Temp);
         89.     printf("出队元素为:%c/n",Temp);
         91.     if(QueueEmpty(lq))
         92.         printf("/n链队列为空/n");
         93.     else
         94.         printf("/n链队列中还有元素/n");
         95. }
         /*------------------------------------- 
      2.     链栈   
      3. -------------------------------------*/ 
      4. #include <stdio.h> 
      5. #include <stdlib.h> 
      6. #define ElemType char 
      8. typedef struct node     //定义节点类型 
      9. { 
      10.     ElemType data;      //数据域 
      11.     struct node *next;  //指针域 
      12. }SNode; 
      14. void InitStack(SNode *&st)  //置空栈   
      15. {
      16.     st=NULL;
      17. }
      19. void push(SNode *&st,ElemType x)    //在栈顶指针是st的链栈中插入一个值为x的节点
      20. {
      21.     SNode *p;
      22.     p=(SNode *)malloc(sizeof(SNode));       //创建一个节点*p 
      23.     p->data=x;
      24.     p->next=NULL;
      26.     if(st==NULL)                            //原来为空栈
      27.         st=p;
      28.     else
      29.     {
      30.         p->next=st;
      31.         st=p;
      32.     }
      33. }
      35. int gettop(SNode *st,ElemType &x)           //将栈st的栈顶节点的data域值赋给x
      36. {
      37.     if(st==NULL)                            //向下溢出
      38.         return 0;                           //返回失败
      39.     else
      40.     {
      41.         x=st->data;
      42.         return 1;                           //返回成功
      43.     }
      44. }
      46. int pop(SNode *&st,ElemType &x)             //将栈st的栈顶节点的data域值赋给x,然后删除栈顶节点
      47. {
      48.     SNode *p=st;
      49.     if(st==NULL)
      50.         return 0;
      51.     else
      52.     {
      53.         x=st->data;
      54.         st=st->next;
      55.         free(p);
      56.         return 1;
      57.     }
      58. }
      60. int StackEmpty(SNode *st)
      61. {
      62.     if(st==NULL)
      63.         return 1;
      64.     else
      65.         return 0;
      66. }
      68. void main()
      69. {
      70.     SNode *ss;
      71.     
      72.     InitStack(ss);
      73.     push(ss,'A');
      74.     push(ss,'B');
      75.     push(ss,'C');
      76.     push(ss,'D');
      77.     push(ss,'E');
      79.     char Temp;
      81.     gettop(ss,Temp);
      82.     printf("栈顶元素:%c/n",Temp);
      84.     Temp=NULL;
      85.     pop(ss,Temp);
      86.     printf("出栈元素:%c/n",Temp);
      87.     gettop(ss,Temp);
      88.     printf("栈顶元素:%c/n",Temp);
      90.     if(StackEmpty(ss))
      91.         printf("/n栈为空/n");
      92.     else
      93.         printf("/n栈中还有元素/n");
      94. }
      /*-----------------------------------
   2.     顺序队列
   3. -----------------------------------*/
   5. #include <stdio.h>
   6. #include <stdlib.h>
   8. #define ElemType char 
   9. #define MaxSize 50
   11. typedef struct
   12. {
   13.     ElemType data[MaxSize];     //存放队列元素
   14.     int front,rear;             //定义队头指针和队尾指针
   15. }Queue;
   17. void InitQueue(Queue &qu)
   18. {
   19.     qu.rear=qu.front=0;
   20. }
   22. int EnQueue(Queue &qu,ElemType x)       //入队
   23. {
   24.     if((qu.rear+1)%MaxSize==qu.front)   //队满
   25.         return 0;                       //报错
   26.     else
   27.     {
   28.         qu.rear=(qu.rear+1)%MaxSize;
   29.         qu.data[qu.rear]=x;
   30.         return 1;
   31.     }
   32. }
   34. int DnQueue(Queue &qu,ElemType x)       //出队
   35. {
   36.     if(qu.rear==qu.front)               //队空
   37.         return 0;                       //报错
   38.     else
   39.     {
   40.         qu.front=(qu.front+1)%MaxSize;
   41.         x=qu.data[qu.front];
   42.         return 1;
   43.     }
   44. }
   46. int QueueEmpty(Queue qu)
   47. {
   48.     if(qu.rear==qu.front)               //队空
   49.         return 1;
   50.     else
   51.         return 0;
   52. }
   54. void main()
   55. {
   56.     Queue qq;
   57.     InitQueue(qq);
   58.     EnQueue(qq,'A');
   59.     EnQueue(qq,'B');
   60.     EnQueue(qq,'C');
   61.     EnQueue(qq,'D');
   62.     EnQueue(qq,'E');
   64.     if(QueueEmpty(qq))
   65.         printf("/n队列为空/n");
   66.     else
   67.         printf("/n队列中还有元素/n");
   68. }
   /*---------------------------------
2.     顺序栈
4.   特别感谢  诛仙(QQ:16822065) 
5. ---------------------------------*/
7. #include <stdio.h> 
9. #define MaxSize 100 
10. typedef char ElemType; 
12. typedef struct 
13. { 
14.     ElemType s[MaxSize]; 
15.     int top; 
16. }Stack;
18. void InitStack(Stack &st)       //置栈空
19. {
20.     st.top = -1;
21. }
23. int push(Stack &st,ElemType x)  //将元素x压入到栈st中
24. {
25.     if(st.top == MaxSize - 1)   //栈上溢出
26.         return 0;
27.     else                        //否则栈指针增1，将x赋给栈顶元素
28.     {
29.         st.top++;
30.         st.s[st.top]=x;
31.         return 1;
32.     }
33. }
35. int gettop(Stack st,ElemType &x)//将栈st的栈顶元素赋给x，栈指针不变
36. {
37.     if(st.top==-1)              //栈下溢出
38.         return 0;
39.     else
40.     {
41.         x=st.s[st.top];         //否则将栈顶元素值赋给x
42.         return 1;               //返回成功信息
43.     }
44. }
46. int pop(Stack &st,ElemType &x)  //将栈st的栈顶元素赋给x，栈指针递减
47. {
48.     if(st.top==-1)              //栈下溢出
49.         return 0;
50.     else
51.     {
52.         x=st.s[st.top];         //否则把栈顶元素赋给x
53.         st.top--;
54.         return 1;               //返回成功信息
55.     }
56. }
58. int StackEmpty(Stack st)
59. {
60.     if(st.top==-1)
61.         return 1;               //如果栈为空返回1
62.     else
63.         return 0;               //否则返回0
64. }
66. void main()
67. {
68.     Stack ss;
69.     InitStack(ss);
71.     push(ss,'A');
72.     push(ss,'B');
73.     push(ss,'C');
74.     push(ss,'D');
76.     char Temp;
78.     gettop(ss,Temp);
79.     printf("栈顶元素为:%c/n",Temp);
81.     Temp=NULL;
82.     pop(ss,Temp);
83.     printf("出栈元素为:%c/n",Temp);
84.     
85.     gettop(ss,Temp);
86.     printf("栈顶元素为:%c/n",Temp);
88.     if(StackEmpty(ss))
89.         printf("/n栈为空/n");
90.     else
91.         printf("/n栈中还有元素/n");
92. }