栈与队列

（1）采用链式存储实现栈的初始化、入栈、出栈操作。

（2）采用顺序存储实现栈的初始化、入栈、出栈操作。

（3）采用链式存储实现队列的初始化、入队、出队操作。

（4）采用顺序存储实现循环队列的初始化、入队、出队操作。

（5）在主函数中设计一个简单的菜单，分别测试上述算法。

[cpp]  view plain copy

1. //用链表实现栈用的是头插法，用链表实现队列用的是尾插法。  
2. #include<stdio.h>  
3. #include<stdlib.h>  
4. #define N 105  
5. int a[N];  
6. struct node  
7. {  
8.     int data;  
9.     node *next;  
10. }*h;  
11. void LinkStack()//用链表实现栈  
12. {  
13.     node *s;  
14.     int n;  
15.     printf("请输入需要入栈元素的数量：      ");  
16.     scanf("%d",&n);  
17.     printf("请输入需要入栈的元素：          ");  
18.     h=NULL;  
19.     s=h;  
20.     while(n--)  
21.     {  
22.         s=(node *)malloc(sizeof(node));  
23.         scanf("%d",&s->data);  
24.         s->next=h;  
25.         h=s;  
26.     }  
27.     printf("输出栈中的元素：                ");  
28.     while(h!=NULL)  
29.     {  
30.         printf("%d ",h->data);  
31.         h=h->next;  
32.     }  
33.     printf("\n");  
34.     return ;  
35. }  
36. void QueStack()//用顺序表实现栈  
37. {  
38.     int n;  
39.     int top;  
40.     printf("请输入需要入栈的元素的数量：    ");  
41.     scanf("%d",&n);  
42.     printf("请输入需要入栈的元素：          ");  
43.     top=0;  
44.     a[top++]=-1;  
45.     while(n--)  
46.     {  
47.         scanf("%d",&a[top++]);  
48.         top%=(N-1);  
49.     }  
50.     printf("输出栈中的元素：                ");  
51.     top--;  
52.     if(top<0)  
53.         top=N-1;  
54.     while(a[top]!=-1)  
55.     {  
56.         printf("%d ",a[top--]);  
57.         if(top<0)  
58.             top=N-1;  
59.     }  
60.     printf("\n");  
61.     return ;  
62. }  
63. void LinkQueue()//用链表实现队列  
64. {  
65.     node *s,*e;  
66.     int n;  
67.     h=(node *)malloc(sizeof(node));  
68.     s=h;  
69.     printf("请输入需要入队的元素的数量：    ");  
70.     scanf("%d",&n);  
71.     printf("请输入需要入队的元素：          ");  
72.     while(n--)  
73.     {  
74.         e=s;  
75.         s=(node *)malloc(sizeof(node));  
76.         scanf("%d",&s->data);  
77.         e->next=s;  
78.         s->next=NULL;  
79.     }  
80.     printf("输出队列中的元素：              ");  
81.     h=h->next;  
82.     while(h!=NULL)  
83.     {  
84.         printf("%d ",h->data);  
85.         h=h->next;  
86.     }  
87.     printf("\n");  
88.     return ;  
89. }  
90. void QueQueue()//用顺序表实现队列  
91. {  
92.     int n,i;  
93.     printf("请输入需要入队元素的数量：      ");  
94.     scanf("%d",&n);  
95.     printf("请输入需要入队的元素：          ");  
96.     for(i=0;i<n;i++)  
97.         scanf("%d",&a[i]);  
98.     printf("输出队列中的元素：              ");  
99.     for(i=0;i<n;i++)  
100.         printf("%d ",a[i]);  
101.     printf("\n");  
102.     return ;  
103. }  
104. int PrintMenu()  
105. {  
106.     printf("******************目录*******************\n");  
107.     printf("用链式存储实现栈的操作：                1\n");  
108.     printf("用顺序存储实现栈的操作：                2\n");  
109.     printf("用链式存储实现队列的操作：              3\n");  
110.     printf("用顺序存储实现队列的操作：              4\n");  
111.     printf("结束操作。                              0\n");  
112.     printf("请输入操作指令：                        ");  
113.     int T;  
114.     scanf("%d",&T);  
115.     switch(T)  
116.     {  
117.         case 1:LinkStack();break;  
118.         case 2:QueStack();break;  
119.         case 3:LinkQueue();break;  
120.         case 4:QueQueue();break;  
121.         case 0: return 1;  
122.         default:printf("输入错误，请重新输入。\n");break;  
123.     }  
124.     return 0;  
125. }  
126. int main()  
127. {  
128.     int flag;  
129.     flag=0;  
130.     while(1)  
131.     {  
132.         flag=PrintMenu();  
133.         printf("\n");  
134.         if(flag)  
135.             break;  
136.     }  
137.     printf("谢谢使用！\n");  
138.     return 0;  
139. }