以下代码中出现的关于基于顺序表实现栈和基于顺序表实现队列的相关操作来自于我的博客：
栈：https://blog.csdn.net/tongxuexie/article/details/79858068
队列：https://blog.csdn.net/tongxuexie/article/details/79858973
1.入栈、出栈、取栈中最小元素的事件复杂度均为O(1)（两种方法）
头文件minstack.h
1 //头文件只被编译一次
2 #pragma once
3 #include"seqstack.h"
4 //定义结构体
5 typedef struct MinStack
6 {
7 SeqStack stack;
8 }MinStack;
源文件minstack.c
1 #include<stdio.h>
2 #include"seqstack.h"
3 #include"minstack.h"
4
5 /*==========方法1:出栈、入栈、取栈中最小元素的时间复杂度均为O(1)=======*/
6 //1.初始化
7 //思路：直接对原本的栈进行初始化，即对minstack->stack初始化
8 void MinStackInit(MinStack* minstack)
9 {
10 //非法输入
11 if(minstack==NULL)
12 return;
13 //利用之前所写的基于顺序表的栈进行初始化
14 SeqStackInit(&minstack->stack);
15 }
16 //2.入栈
18 void MinStackPush(MinStack* minstack,SeqStackType value)
19 {
20 //非法输入
21 if(minstack==NULL)
22 return;
23 //取栈顶元素
24 SeqStackType top;
25 int ret=SeqStackTop(&(minstack->stack),&top);
26 //如果取栈顶元素失败，说明为空栈，直接入栈两次value
27 if(ret==0)
28 {
29 SeqStackPush(&(minstack->stack),value);
30 SeqStackPush(&(minstack->stack),value);
31 }
32 else
33 {
34 SeqStackType min=top<value?top:value;
35 //先入栈value
36 SeqStackPush(&(minstack->stack),value);
37 //再入栈min
38 SeqStackPush(&(minstack->stack),min);
39 }
40 }
41 //3.出栈
42 //思路：直接利用SeqStackPop出栈两次即可，因为入栈时入栈了两次
43 void MinStackPop(MinStack* minstack)
44 {
45 //非法输入
46 if(minstack==NULL)
47 return;
48 //出栈两次
49 SeqStackPop(&(minstack->stack));
50 SeqStackPop(&(minstack->stack));
51 }
52 //4.取栈中最小元素
53 //思路：由于入栈时的思想，所以栈顶元素就是最小元素
54 //返回两个信息:1.执行成功与否 2.最小元素的值
55 int MinStackTop(MinStack* minstack,SeqStackType* value)
56 {
57 //非法输入
58 if(minstack==NULL||value==NULL)
59 return 0; //返回0表示执行失败
60 //空栈时
61 if((minstack->stack).size==0)
62 return 0;
63 //取栈顶元素
64 SeqStackTop(&(minstack->stack),value);
65 //返回1表示执行成功
66 return 1;
67 }
68 /*==========测试代码块1=======*/
69 //1.测试MinStackInit
70 void Test_MinStackInit()
71 {
72 HEADER;
73 MinStack minstack;
74 MinStackInit(&minstack);
75 printf("size expected 0,actual %d\n",(&minstack.stack)->size);
76 printf("capacity expected 1000,actual %d\n",(&minstack.stack)->capacity);
77 }
78 //2.测试MinStackPush
79 void Test_MinStackPush()
80 {
81 HEADER;
82 MinStack minstack;
83 MinStackInit(&minstack);
84 MinStackPush(&minstack,'c');
85 MinStackPush(&minstack,'b');
86 MinStackPush(&minstack,'a');
87 MinStackPush(&minstack,'d');
88 SeqStackPrintChar(&(minstack.stack),"入栈");
89 }
90 //3.测试MinStackPop
91 void Test_MinStackPop()
92 {
93 HEADER;
94 MinStack minstack;
95 MinStackInit(&minstack);
96 MinStackPush(&minstack,'c');
97 MinStackPush(&minstack,'b');
98 MinStackPush(&minstack,'a');
99 MinStackPush(&minstack,'d');
100 MinStackPop(&minstack);
101 SeqStackPrintChar(&(minstack.stack),"出栈一次");
102 MinStackPop(&minstack);
103 MinStackPop(&minstack);
104 SeqStackPrintChar(&(minstack.stack),"出栈三次");
105 MinStackPop(&minstack);
106 MinStackPop(&minstack);
107 SeqStackPrintChar(&(minstack.stack),"尝试对空栈出栈");
108 }
109 //4.测试MinStackTop
110 void Test_MinStackTop()
111 {
112 HEADER;
113 MinStack minstack;
114 SeqStackType value;
115 MinStackInit(&minstack);
116 int ret;
117 ret=MinStackTop(&minstack,&value);
118 printf("expected 0,actual %d\n",ret);
119 MinStackPush(&minstack,'c');
120 MinStackPush(&minstack,'b');
121 MinStackPush(&minstack,'a');
122 MinStackPush(&minstack,'d');
123 ret=MinStackTop(&minstack,&value);
124 printf("expected 1,actual %d\n",ret);
125 printf("expected a,actual %c\n",value);
126 MinStackPop(&minstack);
127 MinStackPop(&minstack);
128 ret=MinStackTop(&minstack,&value);
129 printf("expected 1,actual %d\n",ret);
130 printf("expected b,actual %c\n",value);
131 }
132 /*==========方法2:出栈、入栈、取栈中最小元素的时间复杂度均为O(1)=======*/
133 //思路：设置两个栈:1.一个栈用来正常入栈出栈 2.一个栈是对正常栈的栈顶元素与将要入栈的值的较小值进行入栈
134 //1.初始化
135 //思路：利用SeqStackInit对两个栈分别初始化
136 void StackInit(SeqStack* normal_stack,SeqStack* min_stack)
137 {
138 //非法输入
139 if(normal_stack==NULL||min_stack==NULL)
140 return;
141 //对normal_stack初始化
142 SeqStackInit(normal_stack);
143 //对min_stack初始化
144 SeqStackInit(min_stack);
145 }
146 //2.入栈
147 //思路:normal_stack中正常入栈value，min_stack中入栈value与normal_stack的栈顶元素top的较小值min
148 void StackPush(SeqStack* normal_stack,SeqStack* min_stack,SeqStackType value)
149 {
150 //非法输入
151 if(normal_stack==NULL||min_stack==NULL)
152 return;
153 //取normal_stack的栈顶元素
154 SeqStackType top;
155 int ret=SeqStackTop(normal_stack,&top);
156 //如果为空栈，则都入栈value
157 if(ret==0)
158 {
159 SeqStackPush(normal_stack,value);
160 SeqStackPush(min_stack,value);
161 }
162 //如果非空，normal_stack入栈value,min_stack入栈min
163 else
164 {
165 SeqStackType min=top<value?top:value;
166 //normal_stack入栈value
167 SeqStackPush(normal_stack,value);
168 //min_satck入栈min
169 SeqStackPush(min_stack,min);
170 }
171 }
172 //3.出栈
173 //思路：分别对normal_stack和min_stack出栈一次
174 void StackPop(SeqStack* normal_stack,SeqStack* min_stack)
175 {
176 //非法输入
177 if(normal_stack==NULL||min_stack==NULL)
178 return;
179 //对normal_stack出栈
180 SeqStackPop(normal_stack);
181 //对min_stack出栈
182 SeqStackPop(min_stack);
183 }
184 //4.取栈中最小元素
185 //思路:对min_stack取栈顶元素即为normal_stack栈中最小元素
186 //返回两个有效信息:1.是否执行成功，用返回值带出 2.最小元素的值，用参数带出
187 int StackTop(SeqStack* min_stack,SeqStackType* top)
188 {
189 //非法输入
190 if(min_stack==NULL)
191 return 0; //返回0表示执行失败
192 //空栈时
193 if(min_stack->size==0)
194 return 0;
195 //非空栈
196 return SeqStackTop(min_stack,top); //执行成功返回1
197 }
198 /*==============测试代码块2=============*/
199 //1.测试StackInit
200 void Test_StackInit()
201 {
202 HEADER;
203 SeqStack normal_stack;
204 SeqStack min_stack;
205 StackInit(&normal_stack,&min_stack);
206 printf("size expected 0,actual %d\n",normal_stack.size);
207 printf("capacity expected 1000,actual %d\n",normal_stack.capacity);
208 printf("size expected 0,actual %d\n",min_stack.size);
209 printf("capacity expected 1000,actual %d\n",min_stack.capacity);
210 }
211 //2.测试StackPush
212 void Test_StackPush()
213 {
214 HEADER;
215 SeqStack normal_stack;
216 SeqStack min_stack;
217 StackInit(&normal_stack,&min_stack);
218 StackPush(&normal_stack,&min_stack,'d');
219 StackPush(&normal_stack,&min_stack,'b');
220 StackPush(&normal_stack,&min_stack,'a');
221 StackPush(&normal_stack,&min_stack,'c');
222 SeqStackPrintChar(&normal_stack,"对normal_stack入栈'd''b''a''c'");
223 SeqStackPrintChar(&min_stack,"对min_stack入栈'd''b''a''a'");
224 }
225 //3.测试StackPop
226 void Test_StackPop()
227 {
228 HEADER;
229 SeqStack normal_stack;
230 SeqStack min_stack;
231 StackInit(&normal_stack,&min_stack);
232 StackPush(&normal_stack,&min_stack,'d');
233 StackPush(&normal_stack,&min_stack,'b');
234 StackPush(&normal_stack,&min_stack,'a');
235 StackPush(&normal_stack,&min_stack,'c');
236 StackPop(&normal_stack,&min_stack);
237 SeqStackPrintChar(&normal_stack,"对normal_stack出栈一次");
238 SeqStackPrintChar(&min_stack,"对min_stack出栈一次");
239 StackPop(&normal_stack,&min_stack);
240 StackPop(&normal_stack,&min_stack);
241 SeqStackPrintChar(&normal_stack,"对normal_stack出栈三次");
242 SeqStackPrintChar(&min_stack,"对min_stack出栈三次");
243 StackPop(&normal_stack,&min_stack);
244 StackPop(&normal_stack,&min_stack);
245 SeqStackPrintChar(&normal_stack,"对normal_stack空栈出栈");
246 SeqStackPrintChar(&min_stack,"对min_stack空栈出栈");
247 }
248 //4.测试StackTop
249 void Test_StackTop()
250 {
251 HEADER;
252 SeqStack normal_stack;
253 SeqStack min_stack;
254 SeqStackType top;
255 StackInit(&normal_stack,&min_stack);
256 StackPush(&normal_stack,&min_stack,'d');
257 StackPush(&normal_stack,&min_stack,'b');
258 StackPush(&normal_stack,&min_stack,'a');
259 StackPush(&normal_stack,&min_stack,'c');
260 int ret;
261 ret=SeqStackTop(&min_stack,&top);
262 printf("expected 1,actual %d\n",ret);
263 printf("expected a,actual %c\n",top);
264 StackPop(&normal_stack,&min_stack);
265 StackPop(&normal_stack,&min_stack);
266 ret=SeqStackTop(&min_stack,&top);
267 printf("expected 1,actual %d\n",ret);
268 printf("expected b,actual %c\n",top);
269 StackPop(&normal_stack,&min_stack);
270 StackPop(&normal_stack,&min_stack);
271 ret=SeqStackTop(&min_stack,&top);
272 printf("expected 0,actual %d\n",ret);
273 }
274 /*===========主函数==========*/
275 int main()
276 {
277 //Test_MinStackInit();
278 //Test_MinStackPush();
279 //Test_MinStackPop();
280 //Test_MinStackTop();
281 Test_StackInit();
282 Test_StackPush();
283 Test_StackPop();
284 Test_StackTop();
285 return 0;
286 }
2.使用两个栈实现一个队列
头文件queue.h
1 #include"seqstack.h"
2 //头文件只被编译一次
3 #pragma once
4 //定义结构体
5 typedef struct QueueBy2Stack
6 {
7 SeqStack input; //该栈用于入队列
8 SeqStack output; //该栈用于出队列
9 }QueueBy2Stack;
源文件queue.c
1 #include<stdio.h>
2 #include"queue.h"
3 #include"seqstack.h"
4
5 /*============两个栈实现一个队列===========*/
6 //1.初始化
7 //思路：对两个栈进行初始化即可
8 void QueueInit(QueueBy2Stack* q)
9 {
10 //非法输入
11 if(q==NULL)
12 return;
13 //对input栈初始化
14 SeqStackInit(&(q->input));
15 //对output栈初始化
16 SeqStackInit(&(q->output));
17 }
18 //1.入队列
22 //非法输入
23 if(q==NULL)
24 return;
25 while(1)
26 {
27 SeqStackType top;
28 int ret=SeqStackTop(&(q->output),&top);
29 //判断output是否为空栈
30 if(ret==0)
31 break;
32 //output非空时，将output中的元素出栈到input中
33 SeqStackPop(&(q->output));
34 SeqStackPush(&(q->input),top);
35 }
36 //将output搬运到input后，对input进行入栈value
37 SeqStackPush(&(q->input),value);
38 }
39 //3.出队列
41 void QueuePop(QueueBy2Stack* q)
42 {
43 //非法输入
44 if(q==NULL)
45 return;
46 while(1)
47 {
48 SeqStackType top;
49 int ret=SeqStackTop(&(q->input),&top);
50 //判断input是否为空栈
51 if(ret==0)
52 break;
53 //input非空时，将input中的元素出栈到output中
54 SeqStackPop(&(q->input));
55 SeqStackPush(&(q->output),top);
56 }
57 //将input搬运到output后，对output进行出栈
58 SeqStackPop(&(q->output));
59 }
60 //4.取队首元素
61 //思路：在output栈中取栈顶元素即是对队列取队首元素
62 //返回两个有效信息:1.是否执行成功，用返回值带出 2.队首元素的值，用输出参数带出
63 int QueueFront(QueueBy2Stack* q,SeqStackType* value)
64 {
65 //非法输入
66 if(q==NULL||value==NULL)
67 return 0; //返回0表示执行失败
68 SeqStackType top;
69 while(1)
70 {
71 int out=SeqStackTop(&(q->output),&top);
72 int in=SeqStackTop(&(q->input),&top);
73 //判断input、output两个是不是都为空栈
74 if(in==0&&out==0)
75 return 0;
76 //output为空栈时，将input出栈到output再取output的栈顶元素
77 else if(in==0)
78 {
79 break;
80 }
81 //output不为空栈时，表示input为空栈，直接取output的栈顶元素
82 else
83 {
84 SeqStackPop(&(q->input));
85 SeqStackPush(&(q->output),top);
86 }
87 }
88 return SeqStackTop(&(q->output),value);
89 }
90 /*============测试代码块============*/
91 //1.测试QueueInit
92 void Test_QueueInit()
93 {
94 HEADER;
95 QueueBy2Stack q;
96 QueueInit(&q);
97 printf("expected 0,actual %d\n",q.input.size);
98 printf("expected 1000,actual %d\n",q.input.capacity);
99 printf("expected 0,actual %d\n",q.output.size);
100 printf("expected 1000,actual %d\n",q.output.capacity);
101 }
102 //2.测试QueuePush
103 void Test_QueuePush()
104 {
105 HEADER;
106 QueueBy2Stack q;
107 QueueInit(&q);
108 QueuePush(&q,'a');
109 QueuePush(&q,'b');
110 QueuePush(&q,'c');
111 QueuePush(&q,'d');
112 SeqStackPrintChar(&(q.input),"入队列'a''b''c''d'");
113 }
114 //3.测试QueuePop
115 void Test_QueuePop()
116 {
117 HEADER;
118 QueueBy2Stack q;
119 QueueInit(&q);
120 QueuePush(&q,'a');
121 QueuePush(&q,'b');
122 QueuePush(&q,'c');
123 QueuePush(&q,'d');
124 QueuePop(&q);
125 SeqStackPrintChar(&(q.output),"出队列一次");
126 QueuePop(&q);
127 QueuePop(&q);
128 SeqStackPrintChar(&(q.output),"出队列三次");
129 QueuePop(&q);
130 QueuePop(&q);
131 SeqStackPrintChar(&(q.output),"对空队列出队列");
132 }
133 //4.测试QueueFront
134 void Test_QueueFront()
135 {
136 HEADER;
137 QueueBy2Stack q;
138 QueueInit(&q);
139 QueuePush(&q,'a');
140 QueuePush(&q,'b');
141 QueuePush(&q,'c');
142 QueuePush(&q,'d');
143 int ret;
144 SeqStackType value;
145 ret=QueueFront(&q,&value);
146 printf("expected 1,actual %d\n",ret);
147 printf("expected a,actual %c\n",value);
148 QueuePop(&q);
149 ret=QueueFront(&q,&value);
150 printf("expected 1,actual %d\n",ret);
151 printf("expected b,actual %c\n",value);
152 QueuePop(&q);
153 QueuePop(&q);
154 QueuePop(&q);
155 ret=QueueFront(&q,&value);
156 printf("expected 0,actual %d\n",ret);
157 }
158 /*=============主函数==========*/
159 int main()
160 {
161 Test_QueueInit();
162 Test_QueuePush();
163 Test_QueuePop();
164 Test_QueueFront();
165 return 0;
166 }
3.使用两个队列实现一个栈
头文件stack.h
1 #include"seqqueue.h"
2 //在结构体中定义两个队列
3 typedef struct StackBy2Queue
4 {
5 SeqQueue queue1;
6 SeqQueue queue2;
7 }StackBy2Queue;
源文件stack.c
1 #include<stdio.h>
2 #include"seqqueue.h"
3 #include"stack.h"
4
5 /*==============两个队列实现一个栈=============*/
6 //1.初始化
7 //思路：利用SeqQueueInit对两个队列分别初始化
8 void StackInit(StackBy2Queue* stack)
9 {
12 return;
13 //利用SeqQueueInit对两个队列分别初始化
14 SeqQueueInit(&(stack->queue1));
15 SeqQueueInit(&(stack->queue2));
16 }
17 //2.入栈
18 //思路：利用队列的size找到非空队列对其进行入队列操作即表示入栈
19 void StackPush(StackBy2Queue* stack,SeqQueueType value)
20 {
21 //非法输入
22 if(stack==NULL)
23 return;
24 //找到非空队列
25 SeqQueue* input=stack->queue1.size!=0?&(stack->queue1):&(stack->queue2);
26 //找到该队列后进行入队列即表示入栈
27 SeqQueuePush(input,value);
28 }
29 //3.出栈
31 void StackPop(StackBy2Queue* stack)
32 {
33 //非法输入
34 if(stack==NULL)
35 return;
36 //处理空队列
37 if((stack->queue1).size==0&&(stack->queue2).size==0)
38 return;
39 //非空队列实现出栈
40 SeqQueue* from=NULL;
41 SeqQueue* to=NULL;
42 //判断哪个队列是非空队列
43 if(stack->queue1.size>0)
44 {
45 //如果队列1为非空队列，则将队列queue1的元素(除了最后一个元素外)都出队列到队列queue2中
46 from=&(stack->queue1);
47 to=&(stack->queue2);
48 }
49 else
50 {
51 //如果队列2为非空队列，则将队列queue2的元素(除了最后一个元素外)都出队列到队列queue1中
52 from=&(stack->queue2);
55 }
56 //来到此处，则from表示需要出队列的队列，to表示需要入队列的队列
57 while(1)
58 {
59 if(from->size==1)
60 break;
61 SeqQueueType value;
62 //取from的队首元素
63 SeqQueueFront(from,&value);
64 //对from出队列一次
65 SeqQueuePop(from);
66 //将从from取出的队首元素入队列到to中
67 SeqQueuePush(to,value);
68 }
69 //来到这表示from只剩最后一个元素，对其直接出队列即相当于实现出栈
70 SeqQueuePop(from);
71 }
72 //4.取栈顶元素
74 //返回2个有效信息：1.是否执行成功，用返回值带出 2.栈顶元素的值，用参数带出
75 int StackTop(StackBy2Queue* stack,SeqQueueType* top)
76 {
77 //非法输入
78 if(stack==NULL)
79 return 0; //执行失败返回0
80 //处理空队列
81 if((stack->queue1).size==0&&(stack->queue2).size==0)
82 return 0;
83 //非空队列取栈顶元素
84 SeqQueue* from=NULL;
85 SeqQueue* to=NULL;
86 //判断哪个队列是非空队列
87 if(stack->queue1.size>0)
88 {
89 //如果队列1为非空队列，则将队列queue1的元素(除了最后一个元素外)都出队列到队列queue2中
90 from=&(stack->queue1);
91 to=&(stack->queue2);
92 }
93 else
94 {
95 //如果队列2为非空队列，则将队列queue2的元素(除了最后一个元素外)都出队列到队列queue1中
96 from=&(stack->queue2);
97 to=&(stack->queue1);
98
99 }
100 //来到此处，则from表示需要出队列的队列，to表示需要入队列的队列
101 while(1)
102 {
103 if(from->size==0)
104 break;
105 //取from的队首元素
106 SeqQueueFront(from,top);
107 //对from出队列一次
108 SeqQueuePop(from);
109 //将从from取出的队首元素入队列到to中
110 SeqQueuePush(to,*top);
111 }
112 //while循环结束后，*top就表示栈顶元素
113 return 1; //执行成功返回1
114 }
115 /*==============测试代码块==============*/
116 //1.测试StackInit
117 void Test_StackInit()
118 {
119 HEADER;
120 StackBy2Queue stack;
121 StackInit(&stack);
122 printf("size expected 0,actual %d\n",stack.queue1.size);
123 printf("head expected 0,actual %d\n",stack.queue1.head);
124 printf("tail expected 0,actual %d\n",stack.queue1.tail);
125 printf("size expected 0,actual %d\n",stack.queue2.size);
126 printf("head expected 0,actual %d\n",stack.queue2.head);
127 printf("tail expected 0,actual %d\n",stack.queue2.tail);
128 }
129 //2.测试StackPush
130 void Test_StackPush()
131 {
132 HEADER;
133 StackBy2Queue stack;
134 StackInit(&stack);
135 StackPush(&stack,'a');
136 StackPush(&stack,'b');
137 StackPush(&stack,'c');
138 StackPush(&stack,'d');
139 SeqQueuePrintChar(&(stack.queue1),"依次入栈4个元素并对队列1打印");
140 SeqQueuePrintChar(&(stack.queue2),"依次入栈4个元素并对队列2打印");
141 }
142 //3.测试StackPop
143 void Test_StackPop()
144 {
145 HEADER;
146 StackBy2Queue stack;
147 StackInit(&stack);
148 StackPush(&stack,'a');
149 StackPush(&stack,'b');
150 StackPush(&stack,'c');
151 StackPush(&stack,'d');
152 StackPop(&stack);
153 SeqQueuePrintChar(&(stack.queue1),"出栈1次并对队列1打印");
154 SeqQueuePrintChar(&(stack.queue2),"出栈1次并对队列2打印");
155 StackPop(&stack);
156 StackPop(&stack);
157 SeqQueuePrintChar(&(stack.queue1),"出栈3次并对队列1打印");
158 SeqQueuePrintChar(&(stack.queue2),"出栈3次并对队列2打印");
159 StackPop(&stack);
160 StackPop(&stack);
161 SeqQueuePrintChar(&(stack.queue1),"尝试对空队列出栈并对队列1打印");
162 SeqQueuePrintChar(&(stack.queue2),"尝试对空队列出栈并对队列2打印");
163 }
164 //4.测试StackTop
165 void Test_StackTop()
166 {
167 HEADER;
168 StackBy2Queue stack;
169 StackInit(&stack);
170 StackPush(&stack,'a');
171 StackPush(&stack,'b');
172 StackPush(&stack,'c');
173 StackPush(&stack,'d');
174 int ret;
175 SeqQueueType top;
176 ret=StackTop(&stack,&top);
177 printf("ret expected 1,actual %d\n",ret);
178 printf("top expected d,actual %c\n",top);
179 StackPop(&stack);
180 ret=StackTop(&stack,&top);
181 printf("ret expected 1,actual %d\n",ret);
182 printf("top expected c,actual %c\n",top);
183 StackPop(&stack);
184 StackPop(&stack);
185 StackPop(&stack);
186 ret=StackTop(&stack,&top);
187 printf("ret expected 0,actual %d\n",ret);
188 }
189 /*==============主函数=============*/
190 int main()
191 {
192 Test_StackInit();
193 Test_StackPush();
194 Test_StackPop();
195 Test_StackTop();
196 return 0;
197 }
4.判断入栈出栈的合法性，即给定两个字符串，一个字符串无论如何进行入栈出栈看最终是否能得到另一字符串
源文件stack_push_pop_legal.c
1 #include<stdio.h>
2 #include"seqstack.h"
3
4 /*==========元素出栈入栈顺序的合法性=========*/
5 //思路：1.该函数中需要知道两数组以及它们的数组大小
6 // 2.循环的把input元素入栈
7 // 3.取栈顶元素和output.index指向的元素比较(index是output的索引值，从0开始)
8 // 4.如果不相等，继续循环取下一个input元素入栈
9 // 5.如果相等：(1)出栈
10 // (2)index++
11 // (3)来到第2步，继续，直到index走到最后(即index==output_size)并且栈为空，结束
12 int StackOrder(char input[],size_t input_size,char output[],size_t output_size)
13 {
14 //非法输入
15 if(input==NULL||output==NULL)
16 {
17 return 0;
18 }
19 //循环遍历input数组中的元素，进行入栈
20 size_t i=0;
21 size_t index=0;
22 SeqStack stack;
23 SeqStackInit(&stack);
24 for(i=0;i<input_size;i++)
25 {
26 //对input中的元素入栈
27 SeqStackPush(&stack,input[i]);
28 //取栈顶元素
29 SeqStackType top;
30 int ret=SeqStackTop(&stack,&top);
31 //判断是否已为空栈
32 if(ret==0)
33 break;
34 //循环遍历output中的元素去与栈顶元素比较
35 while(1)
36 {
37 //判断index的合法范围
38 if(index>=output_size)
39 break;
40 //判断top与output[index]元素是否相等
41 if(top!=output[index])
42 break;
43 //相等时，先出栈，再将index++继续循环
44 SeqStackPop(&stack);
45 SeqStackTop(&stack,&top);
46 index++;
47 }
48 }
49 //来到这儿比较出栈入栈是否合法
50 if(stack.size==0&&index==output_size)
51 return 1;
52 //循环结束都没有退出程序表示不合法，返回0
53 return 0;
54 }
55 /*==========主函数==========*/
56 int main()
57 {
58 char input[]={'a','b','c','d','e'};
59 char output[]={'d','e','c','b','a'};
60 size_t input_size=sizeof(input)/sizeof(char);
61 size_t output_size=sizeof(output)/sizeof(char);
62 //printf("%d %d\n",input_size,output_size);
63 int ret=StackOrder(input,input_size,output,output_size);
64 printf("expected 1,actual %d\n",ret);
65 return 0;
66 }
5.一个数组实现两个栈（共享栈）
头文件sharedstack.h
1 //头文件只被编译一次
2 #pragma once
3 //宏定义一个标识符，为了方便打印函数名
4 #define HEADER printf("==============%s============\n",__FUNCTION__);
5 //重定义数据元素类型，方便用户修改
6 typedef char SharedStackType;
7 //宏定义一个标识符，用于表示数组最大范围
8 #define SharedStackMaxSize 1000
9 //定义共享栈的结构体类型
10 typedef struct SharedStack
11 {
12 //存放栈中数据元素
13 SharedStackType data[SharedStackMaxSize];
14 //第一个栈，数组元素的有效范围为[0,top1)
15 size_t top1;
16 //第二个栈，数组元素的有效范围为[top2,SharedStackMaxSize)
17 size_t top2;
18 }SharedStack;
源文件sharedstack.c
1 #include<stdio.h>
2 #include"sharedstack.h"
3
4 /*===============一个数组实现两个栈==============*/
5 //1.初始化
6 //思路：初始化即将两个栈初始化为空栈，故将top1=0以及top2=SharedStackMaxSize时，两个栈为空栈
7 void SharedStackInit(SharedStack* stack)
8 {
9 //非法输入
10 if(stack==NULL)
11 return;
12 //将top1置为0
13 stack->top1=0;
14 //将top2置为SharedStackMaxSize
15 stack->top2=SharedStackMaxSize;
16 }
17 //2.1打印栈1中的元素
18 void SharedStack1PrintChar(SharedStack* stack,char* msg)
19 {
20 //非法输入
21 if(stack==NULL||msg==NULL)
22 return;
23 //打印一行字符串
24 printf("%s\n",msg);
25 //打印栈1中的元素
26 size_t i=0;
27 for(i=0;i<stack->top1;i++)
28 {
29 printf("%c ",stack->data[i]);
30 }
31 printf("\n");
32 }
33 //2.2打印栈2中的元素
34 void SharedStack2PrintChar(SharedStack* stack,char* msg)
35 {
36 //非法输入
37 if(stack==NULL||msg==NULL)
38 return;
39 //打印一行字符串
40 printf("%s\n",msg);
41 //打印栈1中的元素
42 size_t i=SharedStackMaxSize-1;
43 for(;i>=stack->top2;i--)
44 {
45 printf("%c ",stack->data[i]);
46 }
47 printf("\n");
48 }
49 //3.1对第一个栈[0,top1)入栈
50 //思路：1.先判断栈是否已满，即top1是否等于top2? 2.对入栈元素value进行入栈，即stack->data[top1]=value 3.将top1++
51 void SharedStackPush1(SharedStack* stack,SharedStackType value)
52 {
53 //非法输入
54 if(stack==NULL)
55 return;
56 //1.判断数组是否已满？能不能入栈
57 if((stack->top1)==(stack->top2))
58 return;
59 //2.对value进行入栈操作
60 stack->data[stack->top1]=value;
61 //3.top1++
62 stack->top1++;
63 }
64 //3.2对第二个栈[top2,SharedStackMaxSize)入栈
65 //思路：1.先判断栈是否已满，即top1是否等于top2? 2.对入栈元素value进行入栈，即stack->data[top2-1]=value 3.将top2--
66 void SharedStackPush2(SharedStack* stack,SharedStackType value)
67 {
68 //非法输入
69 if(stack==NULL)
70 return;
71 //1.判断数组是否已满？能不能入栈
72 if((stack->top1)==(stack->top2))
73 return;
74 //2.对value进行入栈操作
75 stack->data[stack->top2-1]=value;
76 //3.top2--
77 stack->top2--;
78 }
79 //3.1对栈1出栈
80 //思路：直接将top1--即表示出栈
81 void SharedStackPop1(SharedStack* stack)
82 {
83 //非法输入
84 if(stack==NULL)
85 return;
86 //空栈时无法出栈
87 if(stack->top1==0)
88 return;
89 //top1--
90 stack->top1--;
91 }
92 //3.2对栈2出栈
93 //思路：直接将top2++即表示出栈
94 void SharedStackPop2(SharedStack* stack)
95 {
96 //非法输入
97 if(stack==NULL)
98 return;
99 //空栈时无法出栈
100 if(stack->top2==SharedStackMaxSize)
101 return;
102 //top2++
103 stack->top2++;
104 }
105 //4.1取栈1的栈顶元素
106 //返回2个有效信息：1.是否有栈顶元素，用返回值带出 2.栈顶元素的值，用参数带出
107 int SharedStackTop1(SharedStack* stack,SharedStackType* value)
108 {
109 //非法输入
110 if(stack==NULL||value==NULL)
111 return 0; //返回0表示无栈顶元素
112 //空栈时
113 if(stack->top1==0)
114 return 0;
115 //取栈顶元素
116 *value=stack->data[stack->top1-1];
117 //有栈顶元素返回1
118 return 1;
119 }
120 //4.2取栈2的栈顶元素
121 //返回2个有效信息：1.是否有栈顶元素，用返回值带出 2.栈顶元素的值，用参数带出
122 int SharedStackTop2(SharedStack* stack,SharedStackType* value)
123 {
124 //非法输入
125 if(stack==NULL||value==NULL)
126 return 0; //返回0表示无栈顶元素
127 //空栈时
128 if(stack->top2==SharedStackMaxSize)
129 return 0;
130 //取栈顶元素
131 *value=stack->data[stack->top2];
132 //有栈顶元素返回1
133 return 1;
134 }
135 /*================测试代码块==========*/
136 //1.测试SharedStackInit
137 void Test_SharedStackInit()
138 {
139 HEADER;
140 SharedStack stack;
141 SharedStackInit(&stack);
142 printf("top1 expected 0,actual %d\n",stack.top1);
143 printf("top2 expected 1000,actual %d\n",stack.top2);
144 }
145 //2.1测试SharedStackPush1
146 void Test_SharedStackPush1()
147 {
148 HEADER;
149 SharedStack stack;
150 SharedStackInit(&stack);
151 SharedStackPush1(&stack,'a');
152 SharedStackPush1(&stack,'b');
153 SharedStackPush1(&stack,'c');
154 SharedStackPush1(&stack,'d');
155 SharedStack1PrintChar(&stack,"对栈1入栈元素'a''b''c''d'");
156 }
157 //2.2测试SharedStackPush2
158 void Test_SharedStackPush2()
159 {
160 HEADER;
161 SharedStack stack;
162 SharedStackInit(&stack);
163 SharedStackPush2(&stack,'x');
164 SharedStackPush2(&stack,'y');
165 SharedStackPush2(&stack,'s');
166 SharedStackPush2(&stack,'t');
167 SharedStack2PrintChar(&stack,"对栈2入栈元素'x''y''s''t'");
168 }
169 //3.1测试SharedStackPop1
170 void Test_SharedStackPop1()
171 {
172 HEADER;
173 SharedStack stack;
174 SharedStackInit(&stack);
175 SharedStackPush1(&stack,'a');
176 SharedStackPush1(&stack,'b');
177 SharedStackPush1(&stack,'c');
178 SharedStackPush1(&stack,'d');
179 SharedStackPop1(&stack);
180 SharedStack1PrintChar(&stack,"对栈1出栈1次");
181 SharedStackPop1(&stack);
182 SharedStackPop1(&stack);
183 SharedStackPop1(&stack);
184 SharedStackPop1(&stack);
185 SharedStack1PrintChar(&stack,"尝试对栈1空栈出栈");
186 }
187 //3.2测试SharedStackPop2
188 void Test_SharedStackPop2()
189 {
190 HEADER;
191 SharedStack stack;
192 SharedStackInit(&stack);
193 SharedStackPush2(&stack,'x');
194 SharedStackPush2(&stack,'y');
195 SharedStackPush2(&stack,'s');
196 SharedStackPush2(&stack,'t');
197 SharedStackPop2(&stack);
198 SharedStack2PrintChar(&stack,"对栈2出栈1次");
199 SharedStackPop2(&stack);
200 SharedStackPop2(&stack);
201 SharedStackPop2(&stack);
202 SharedStackPop2(&stack);
203 SharedStack2PrintChar(&stack,"尝试对栈2空栈出栈");
204 }
205 //4.测试SharedStackTop1
206 void Test_SharedStackTop1()
207 {
208 HEADER;
209 SharedStack stack;
210 SharedStackInit(&stack);
211 SharedStackPush1(&stack,'a');
212 SharedStackPush1(&stack,'b');
213 SharedStackPush1(&stack,'c');
214 SharedStackPush1(&stack,'d');
215 int ret;
216 SharedStackType value;
217 ret=SharedStackTop1(&stack,&value);
218 printf("ret expected 1,actual %d\n",ret);
219 printf("value expected d,actual %c\n",value);
220 SharedStackPop1(&stack);
221 ret=SharedStackTop1(&stack,&value);
222 printf("ret expected 1,actual %d\n",ret);
223 printf("value expected c,actual %c\n",value);
224 SharedStackPop1(&stack);
225 SharedStackPop1(&stack);
226 SharedStackPop1(&stack);
227 ret=SharedStackTop1(&stack,&value);
228 printf("ret expected 0,actual %d\n",ret);
229 }
230 //4.测试SharedStackTop2
231 void Test_SharedStackTop2()
232 {
233 HEADER;
234 SharedStack stack;
235 SharedStackInit(&stack);
236 SharedStackPush2(&stack,'x');
237 SharedStackPush2(&stack,'y');
238 SharedStackPush2(&stack,'s');
239 SharedStackPush2(&stack,'t');
240 int ret;
241 SharedStackType value;
242 ret=SharedStackTop2(&stack,&value);
243 printf("ret expected 1,actual %d\n",ret);
244 printf("value expected t,actual %c\n",value);
245 SharedStackPop2(&stack);
246 ret=SharedStackTop2(&stack,&value);
247 printf("ret expected 1,actual %d\n",ret);
248 printf("value expected s,actual %c\n",value);
249 SharedStackPop2(&stack);
250 SharedStackPop2(&stack);
251 SharedStackPop2(&stack);
252 ret=SharedStackTop2(&stack,&value);
253 printf("ret expected 0,actual %d\n",ret);
254 }
255 /*================主函数============*/
256 int main()
257 {
258 Test_SharedStackInit();
259 Test_SharedStackPush1();
260 Test_SharedStackPush2();
261 Test_SharedStackPop1();
262 Test_SharedStackPop2();
263 Test_SharedStackTop1();
264 Test_SharedStackTop2();
265 return 0;
266 }