一.使用两个队列实现（实现栈先进后出的特点）
思路：
1.创建两个队列的结构体，并将这俩个队列（Queue1和Queue2）的结构体封装到一个结构体里。
2.入栈：判断哪个队列中为空（Queue1和Queue2）就入哪个队列。
3.出栈：判断任意一个队列（Queue1和Queue2）中如果Queue1或者Queue2中的元素个数大于一则把这个队列中的元素导入另外一个队列中（相当于取元素不为一的队列的队头（Front）元素插入（Push）另外一个队列）直到不为一的元素的队列只剩一个元素然后出队列（Pop），再将令外一个队列的元素导入为空的队列，直到该队列剩一个元素，然后输出。如此循环。直到两个队列为空。
图解：
队列操作参考：点击打开链接
实现的代码：
//入栈
void StackPush(Stack* s, DataType data)
{
assert(s);
//哪个队列为空入哪个队列
if (QueueEmpty(&(s->q1)))
QueuePush(&(s->q2), data);
else
QueuePush(&(s->q1), data);
}
//出栈
void StackPop(Stack* s,Queue* q)
{
assert(s);
if (QueueEmpty(&(s->q1)) && QueueEmpty(&(s->q2)))
{
printf("栈已空！！！！\n");
return;
}
if (!QueueEmpty(&(s->q1)))
{
while (QueueSize(&s->q1) > 1)
{
DataType data = QueueTop(&(s->q1));
QueuePop(&(s->q1));
QueuePush(&(s->q2), data);
}
QueuePop(&s->q1);
}
if (!QueueEmpty(&(s->q2)))
{
while (QueueSize(&s->q1) > 1)
{
DataType data = QueueTop(&(s->q2));
QueuePop(&(s->q2));
QueuePush(&(s->q2), data);
}
QueuePop(&s->q2);
}
}
二：元素出栈，入栈顺序的合法性。如入栈的序列（1，2，3，4，5），出栈序列为（4，5，3，2，1）
思路：
1.将入栈序列放入数组Inorder中，再定义一个索引（InIdx）。将出栈序列放在数组Outorder中，再定义一个索引（OutIdx）
2.再添加一个栈，每次栈不为空并且用栈顶的元素和数组Outorder中索引OutIdx所指向的元素做对比如果相同则取栈顶元素并且出栈（Pop），索引（OutIdx++），如果相比元素不同则将数组Inorder中的元素入栈，索引InIdx++(一定要防止越界)
如此循环就可以判断。
图解：
栈的操作参考：点击打开链接
代码部分：
int InOutStackIsValid(int* InOrder, int InSize, int* OutOrder, int OutSize)
{
Stack s;
int InIdx = 0;
int OutIdx = 0;
// 入栈和出栈元素的个数必须相同
if (InSize != OutSize)
return 0;
StackInit(&s);
while (OutIdx < OutSize)
{
//栈顶元素与Outorder中的第一个元素不同就入栈
while (StackEmpty(&s) || StackTop(&s) != OutOrder[OutIdx])
{
//防止越界
if (InIdx < InSize)
StackPush(&s, InOrder[InIdx++]);
else
return 0;
}
//栈顶元素和Outorder的第一个元素相同就出栈
StackPop(&s);
OutIdx++;
}
return 1;
}
void TestCheckStack()
{
int InOrder[] = { 1, 2, 3, 4, 5 };
int InSize = sizeof(InOrder) / sizeof(InOrder[0]);
int OutOrder[] = { 4, 5, 3, 2, 1 };
int OutSize = sizeof(OutOrder) / sizeof(OutOrder[0]);
if (InOutStackIsValid(InOrder, InSize, OutOrder, OutSize))
{
printf("输出合法！！\n");
}
else
{
printf("输出不合法！！！\n");
}
}
int main()
{
TestSharedStack();
system("pause");
return 0;
}
三.一个数组实现两个栈（共享栈）
思路：
定义一个数组，再将指针(Top1)指向数组下标的0号位，将指针（Top2）指向数组下标的1号位
将数组中的偶数下标入Stack1，然后（Top1+= 2）
将数组中的奇数下标入Stack2,r然后（Top2 += 2）
图解：
代码：
SharedStack.h
#pragma once
#include<string.h>
#include<stdio.h>
#include<Windows.h>
#include<assert.h>
typedef int DataType;
#define MAX_SIZE 10
typedef struct SharedStack
{
DataType array[MAX_SIZE];
int top1; //栈1占用偶数空间
int top2; //栈2占用奇数空间
}SharedStack;
//初始化
void SharedStackInit(SharedStack* s);
//判空
int SharedStackEmpty(SharedStack* s,int which);
//栈顶元素
DataType SharedStackTop(SharedStack* s, int which);
//入栈
void SharedStackPush(SharedStack* s,int which, DataType data);
//出栈
void SharedStackPop(SharedStack* s, int which);
//栈中元素个数
int SharedStackSize(SharedStack* s, int which);
SharedStack.c
//初始化
void SharedStackInit(SharedStack* s)
{
s->top1 = 0; //栈1占用偶数空间
s->top2 = 1; //栈2占用奇数空间
}
//入栈
void SharedStackPush(SharedStack* s,int which, DataType data)
{
assert(1 == which || 2 == which);
if (1 == which)
{
if (s->top1 < MAX_SIZE)
{
s->array[s->top1] = data;
s->top1 += 2;
}
}
else
if (s->top2 < MAX_SIZE)
{
s->array[s->top2] = data;
s->top2 += 2;
}
}
//出栈
void SharedStackPop(SharedStack* s,int which)
{
assert(1 == which || 2 == which);
if (1 == which)
{
if (s->top1 != 0)
s->top1 -= 2;
}
else
{
if (s->top2 != 0)
s->top2 -= 2;
}
}
//判断栈是不为空
int SharedStackEmpty(SharedStack* s,int which)
{
assert(1 == which || 2 == which);
if (1 == which)
{
if (s->top1 == 0)
return 0;
else
return 1;
}
else
{
if (s->top2 == 0)
return 3;
else
return 4;
}
}
//获取栈顶元素
DataType SharedStackTop(SharedStack* s, int which)
{
assert(1 == which || 2 == which);
if (which == 1)
{
if (s->top1 != 0)
return s->array[s->top1 - 2];
}
else
{
if (which != 0)
return s->array[s->top2 - 2];
}
}
//获取栈中元素的个数
int SharedStackSize(SharedStack* s, int which)
{
assert(1 == which || 2 == which);
if (1 == which)
{
if (s->top1 != 0)
return (s->top1 >> 1);
}
else
{
if (s->top2 != 0)
return(s->top2 >> 1);
}
}
test.c
void TestSharedStack()
{
SharedStack s;
SharedStackInit(&s);
SharedStackPush(&s, 1, 2);
SharedStackPush(&s, 1, 4);
SharedStackPush(&s, 1, 6);
SharedStackPush(&s, 1, 8);
SharedStackPush(&s, 2, 1);
SharedStackPush(&s, 2, 3);
SharedStackPush(&s, 2, 5);
SharedStackPush(&s, 2, 7);
printf("size1= %d\n", SharedStackSize(&s, 1));
printf("top1= %d\n", SharedStackTop(&s, 1));
SharedStackPop(&s, 1);
printf("size1= %d\n", SharedStackSize(&s, 1));
printf("top1= %d\n", SharedStackTop(&s, 1));
printf("size2= %d\n", SharedStackSize(&s, 2));
printf("top2= %d\n", SharedStackTop(&s, 2));
SharedStackPop(&s, 2);
printf("size2= %d\n", SharedStackSize(&s, 2));
printf("top2= %d\n", SharedStackTop(&s, 2));
}
int main()
{
TestSharedStack();
system("pause");
return 0;
}