数据结构:顺序栈的基本操作和实现（一个数组实现两个栈）

栈的特点：

1只能在栈顶进行操作
2后进先出LIFO(last in first out)

栈的顺序结构结构实现

这里利用数组来实现，举一个特例，一个数组实现两个栈。从两端的出发，可以充分利用数组空间。

思路：
由于有两个栈，因此需要设置一个tag标志来显示当前的操作对象
判定当前栈是否满，当top2-top1==1，栈满。如果令top2==top1则会溢出。
定义宏MAXSIZE方便修改数组的大小

#include<stdio.h>
/*
	使用一个数组实现两个堆栈
	为了充分利用数组空间，从两端开始，第一个栈向数组末端生长，第二个栈向数组首端生长

	操作：1：判断栈是否为空
		  2：判断栈是否为满
		  3：若栈未满，则可进行压栈操作
		  4：若栈未空，则可进行弹栈操作
		  5: 若栈不空，获取栈顶元素
		  6: 将栈置为空栈,只需修改栈顶索引到数组首部或者尾部即可。
*/

#define MAXSIZE 100

//判断栈是否为空，返回1代表空栈，0代表非空。tag==0，操作栈1。tag==1，操作栈2；
int isEmpty(int tag,int Stack);

//判断栈是否为满,返回1代表满栈，0代表未满
int isFull(int Stack1, int Stack2);

//压栈操作，tag==0，操作栈1。tag==1，操作栈2；Stack1和Stack2指示栈顶位置
int push(int arr[], int elem,int tag,int Stack1,int Stack2);

//弹栈操作,tag==0，操作栈1。tag==1，操作栈2；Stack指示栈顶位置
int pop(int arr[], int elem, int tag, int Stack);

//获取栈顶元素,tag==0，操作栈1。tag==1，操作栈2；Stack指示栈顶位置
int getTop(int arr[], int tag, int Stack);

//遍历栈,tag==0，操作栈1。tag==1，操作栈2；Stack指示栈顶位置
void visit(int arr[],int tag,int Stack);

//将栈置为空栈,tag==0，操作栈1。tag==1，操作栈2；Stack指示栈顶位置
int Clear(int tag, int Stack);

//获取栈的长度,tag==0，操作栈1。tag==1，操作栈2；Stack指示栈顶位置
int stackLength(int tag,int Stack);

int main()
{
	int arr[MAXSIZE];
	int elem=0;

	//Stack指示栈顶元素位置
	int Stack1 = -1, Stack2 = MAXSIZE;
	int tag1 = 0, tag2 = 1;
	int top2;

	if (!isFull(Stack1, Stack2))
	{
		printf("栈1和栈2未满\n");
	}
	
	if (!isEmpty(tag1, Stack1))
	{
		printf("栈1非空\n");
	}

	if (!isEmpty(tag2,Stack2))
	{
		printf("栈2非空\n");
	}
	
	printf("\n为Stack2压入一个值为99的元素:\n");
	Stack2=push(arr, 99, tag2, Stack1, Stack2);
	
	if (!isEmpty(tag2, Stack2))
	{
		printf("栈2非空\n");
	}

	top2 = (arr, tag2,Stack2);
	printf("栈顶元素为%d\n",top2);

	printf("\nStacke2遍历结果\n");
	visit(arr, tag2,Stack2);

	printf("\n计算Stack1和Stack2的长度:\n");
	printf("Stack1的长度:%d\n", stackLength(tag1, Stack1));
	printf("Stack2的长度:%d\n", stackLength(tag2,Stack2));

	printf("\n弹出Stacke2的栈顶元素:");
	Stack2 = pop(arr,elem, tag2,Stack2);
	if (!isEmpty(tag2, Stack2))
	{
		printf("栈2非空\n");
	}
	
	return 0;
}

int isEmpty(int tag, int Stack)
{
	if (tag == 0 && Stack == -1)
	{
		printf("栈1空\n");
		return 1;
	}
	else if (tag == 1 && Stack == MAXSIZE)
	{
		printf("栈2空\n");
			return 1;
	}
	else
	{
		return 0;
	}
}

int isFull(int Stack1, int Stack2)
{
	if (Stack2 - Stack1 == 1)
	{
		printf("栈满");
		return 1;
	}
	else
	{
		return 0;
	}
}

int push(int arr[], int elem, int tag,int Stack1,int Stack2)
{
	if (isFull(Stack1, Stack2))
	{
		if (tag == 0)
		{
			return Stack1;
		}
		else
		{
			return Stack2;
		}
	}
	else
	{
		if (tag == 0)
		{
			arr[++Stack1] = elem;
			return Stack1;
		}
		else
		{
			arr[--Stack2] = elem;
			return Stack2;
		}
	}
}

int pop(int arr[], int elem, int tag, int Stack)
{
	if (tag==0)
	{
		if (isEmpty(tag, Stack))
		{
			return Stack;
		}
		else
		{
			printf("弹出元素为：%d\n", arr[Stack--]);
			return Stack;
		}
	}
	else
	{
		if (isEmpty(tag, Stack))
		{
			return Stack;
		}
		else
		{
			printf("弹出元素为：%d\n", arr[Stack++]);
			return Stack;
		}
	}
}

int getTop(int arr[],int tag, int Stack)
{
	if (tag == 0)
	{
		if (isEmpty(tag, Stack))
		{
			return 0;
		}
		else
		{
			return arr[Stack];
		}
	}
	else
	{
		if (isEmpty(tag, Stack))
		{
			return 0;
		}
		else
		{
			return arr[Stack];
		}
	}

}

void visit(int arr[], int tag, int Stack)
{
	int i;
	
	if (tag == 0)
	{
		if (isEmpty(tag, Stack))
		{
			printf("栈为空，无法遍历\n");
			return 0;
		}

		for (i = 0; i < Stack; i++)
		{
			printf("%d\n", arr[i]);
		}
		printf("遍历完成\n");
		return 0;
	}
	else
	{
		if (isEmpty(tag, Stack))
		{
			printf("栈为空，无法遍历\n");
			return 0;
		}

		for (i =Stack; i <MAXSIZE; i++)
		{
			printf("%d\n", arr[i]);
		}
		printf("遍历完成\n");
		return 0;
	}
}

//将栈置为空栈
int Clear(int tag, int Stack)
{
	if (tag == 0)
	{
		Stack = -1;
		return Stack;
	}
	else
	{
		Stack = MAXSIZE;
		return Stack;
	}
}

int stackLength(int tag, int Stack)
{
	if (tag == 0)
	{
		return Stack+1;
	}
	else
	{
		return MAXSIZE - Stack;
	}
}