顺序栈：使用一组连续的内存依次保存栈中的数据，定义一个top变量来保存栈顶序号。
 
栈结构是“后进先出”的原则。
 
栈的最基本操作有两个：push（入栈） + pop（出栈）
 

 
 

import java.util.Scanner;

/** 
*  @author   LilyLee
 * @date     2017年4月25日
 * @time     下午4:25:15
 * @Version  1.0
 * @email    lilylee_1213@foxmail.com
 *
 */
public class Mystack {

	public static void main(String[] args) {
		Stack_type st=new Stack_type();
		Stack_Data data1=new Stack_Data();
		Stack_type stack =st.STinit(); //初始化栈
		Scanner sc=new Scanner(System.in);
		System.out.println("input  name age end with name='0'"); //输入栈元素，以0结束
		while(true){
			Stack_Data sdata=new Stack_Data();
			sdata.name=sc.next();
			if(sdata.name.equals("0")){break;}
			sdata.age=sc.nextInt();
			st.PushST(stack, sdata);
		}
		String flag="1";
		System.out.println("pop stack  end with 0");//输入任意非0元素完成弹栈
		flag=sc.next();
		while(!(flag.equals("0"))){
			data1=st.PopST(stack);
			if(data1==null){break;}
			System.out.println(data1.name+" "+data1.age);
			flag=sc.next();
		}
		System.out.println("End and Free");
		st.STFree(st);
		
	}
}

class Stack_Data{
	String name;
	int age;
}

class Stack_type{
	static final int MAXLEN=50; //定义栈的最大长度
	Stack_Data[] data=new Stack_Data[MAXLEN+1];
	int top;
	
	Stack_type STinit(){
		Stack_type p;
		
		if((p=new Stack_type())!=null){  //申请栈内存
			p.top=0;
			return p;
			}
		return null;
		
	}
	
	boolean STIsEmpty(Stack_type s){  //判断栈是否为空
		boolean t;
		t=(s.top==0);
		return t;
	}
	
	boolean STIsFull(Stack_type s){  //判断栈是否已满
		boolean t;
		t=(s.top==MAXLEN);
		return t;
	}
	
	void STClear(Stack_type s){  //清空栈
		s.top=0;
	}
	
	void STFree(Stack_type s){ //释放栈所占用空间
		if(s!=null){
			s=null;
		}
	}
	
	int PushST(Stack_type s,Stack_Data data){
		if((s.top+1)>MAXLEN){return 0;}  //栈溢出
		s.data[++s.top]=data;
		return 1;
	}
	
	Stack_Data PopST(Stack_type s){
		if(s.top==0){System.out.println("no elements!"); return null;} //栈为空，操作失败
		return (s.data[s.top--]);
	}
	
	Stack_Data PeekST(Stack_type s){
		if(s.top==0){System.exit(0);}  //栈为空，操作失败
		return (s.data[s.top]);
	}
	
	
}


 

 

共享栈判断栈满的条件，即判断两个栈顶的位置的状态，其根本是由两个栈顶指针的操作方式决定的。
 用入栈操作来说有以下两种操作方式：（1）栈顶指针先加1，再赋值，那么栈顶指针所指的地方是最后入栈的元素（2）若先赋值，栈顶指针再加1，则指针指向的位置是在最后入栈元素的后面1位，指向的地方为空值。
 
由此导致下面可能发生的四种情况：
 （1）初始值：top0=-1,top1=maxsize ，栈顶指针先加1（top1为减一），再赋值
 
 （2）初始值：top0=-1,top1=maxsize-1，top0先加1再赋值，top1先赋值，再减1
 
 （3）初始值：top0=0,top1=maxsize，top0先赋值再加1，top1先减1再赋值
 
 （4）初始值：top0=0,top1=maxsize-1，栈顶指针先赋值再加1（top1为减一）
 

将编号为0和1的两个栈存放于一个数组空间V[m]中，栈底分别处于数组的两端。当第0号栈的栈顶指针top[0]等于-1时该栈为空;当第1号栈的栈顶指针top[1]等于m时，该栈为空。两个栈均从两端向中间增长。试编写双栈初始化，判断栈空、栈满、进栈和出栈等算法的函数。
 
 
#include<iostream>
using namespace std;
typedef struct {
	int top[2], bot[2];
	int *V;
	int m;
}DblStack;
void ShowMenu() {
	cout << "************下面我们开始设计双栈************" << endl;
	cout << "****************0.双栈初始化****************" << endl;
	cout << "****************1.插入数据******************" << endl;
	cout << "****************2.删除数据******************" << endl;
	cout << "****************3.打印数据******************" << endl;
	cout << "****************本实验仅进行一次************" << endl;
}
//初始化一个大小为m的双向栈
void InitDblStack(DblStack &S) {
	cout << "请输入双栈的大小" << endl;
	cin >> S.m;
	//动态分配一个最大容量为m的数组空间
	S.V = new int[S.m];
	//左栈栈底指针
	S.bot[0] = -1;
	//右栈栈底指针
	S.bot[1] = S.m;
	//左栈栈顶指针
	S.top[0] = -1;
	//右栈栈顶指针
	S.top[1] = S.m;
	system("pause");
	system("cls");
}
//向指定的i号栈中插入元素
void DblPush(DblStack &S) {
	int i = 0;
	int j = 0;
	int flag=0;
	int *x = new int();
	cout << "请输入您要插入数据的栈号" << endl;
	cin >> i;
	//判断栈号是否输入错误
	if (i < 0 || i>1) 
		cout << "栈号输入错误" << endl;
	//向0栈插入数据，反之向1栈插入数据
	if (i == 0) {
		cout << "您要在此栈插入数据的个数" << endl;
		cin >> j;
		for (int t = 0;t < j;t++) {
			cout << "插入第" << (t + 1) << "个数" << endl;
			cin >> *x;
			//判断栈是否已满
			if (S.top[0] + 1 == S.top[1]) {
				cout << "双栈已满，无法再继续添加数据" << endl;
				flag=1;
				}
			else
				S.V[++S.top[0]] = *x;
			if（flag==1）
			    break;
		}
	}
	else {
		cout << "您要在此栈插入数据的个数" << endl;
		cin >> j;
		for (int t = 0;t < j;t++) {
			cout << "插入第" << (t + 1) << "个数" << endl;
			cin >> *x;
			if (S.top[0] + 1 == S.top[1]){
				cout <<"双栈已满，无法插入该数据" << endl;
				flag=1;
				}
			else
				S.V[--S.top[1]] = *x;
			if(flag==1)	
			    break;
		}
	}
	delete x;
	system("pause");
	system("cls");
}

//删除指定的i号栈的栈顶元素，用x返回其值
void DblPop(DblStack &S){
	int i,j;
	cout << "您需要删除哪号栈的栈顶元" << endl;
	cin >> i;
	cout << "您需要删除几个数" << endl;
	cin >> j;
	for (int t = 0;t < j;t++) {
		if (S.top[i] == S.bot[i])
			{
			    cout << "该栈已为空栈" << endl;
			    break;
			    }
		if (i == 0)
			S.V[S.top[0]--];
		else
			S.V[S.top[1]++];
	}
	system("pause");
	system("cls");
}
void PrintDblStack(DblStack &S) {
	if (S.top[0] == S.bot[0])
		cout << "第0栈为空栈。无法打印" << endl;
	else {
		cout << "第0栈的数据" << endl;
		for (int i = 0; i < S.top[0] - S.bot[0];i++)
		{
			cout << S.V[i];
			cout << " \t";
		}
		cout << endl;
	}
	if (S.top[1] == S.bot[1])
		cout << "第1栈为空栈。无法打印" << endl;
	
	else {
		cout << "第1栈的数据" << endl;
		for (int i = S.m;i > S.top[1];i--)
		{
			cout << S.V[i - 1];
			cout << "\t";
		}
		cout << endl;
	}
	//本实验打印后就退出
		system("pause");
		exit(0);
}
int main() {
	DblStack S;
	int i;
	while (1) {
		ShowMenu();
		cout << "请选择你的操作" << endl;
		cin >> i;
		switch(i)
		{
			case 0:{
				//初始化双向栈
				InitDblStack(S);
				break;
				}
			case 1:{
				//给栈添加数据
				DblPush(S);
				break;
				}
			case 2:{
				//删除栈中数据
				DblPop(S);
				break;
				}
			case 3:{
				//打印数据
				PrintDblStack(S);
				break;
				}
			default:
				break;
		}
		}
	}
}
 

 
 
 
 
 
 本代码仅是为了完成数据结构的作业，所以还不完善，见谅。
 。。。。。。。。
 其实是敲不动了
 。。。。。。。。

一、共享栈的优点
 
共享栈是为了有效的利用存储空间，两个栈的空间可以相互调节
 
二、共享栈的概念
 
因为栈底位置不变，所以让两个顺序栈共享一个数组空间，两个栈的栈底分别设置在两端，两个栈顶向数组中间延伸。
 
 
 
三、共享栈栈满问题
 
判断栈满的条件，就是判断两个栈顶的位置的状态，其根本原因是由两个栈顶指针的操作方式决定的。
 
用入栈操作来说：①栈顶指针先加1，再赋值，那么栈顶指针所指的地方，则最后入栈的元素
 
                           ②若先赋值，栈顶指针再加1，则指针指向的位置则在最后入栈元素的后面1位，指向的地方也为空值。
 
 
 
下面为会发生的四种情况：
 
①初始值：top0=-1,top1=10 ，栈底指针都是先加1，再赋值
 
 
 
 
②初始值：top0=-1,top1=9 ，top0:先加1，再赋值，           top1：先赋值，再加1
 
 
 
 
③初始值：top0=0,top1=10 ，top0:先赋值，再加1              top1：先加1，再赋值
 
 
 
 
 
④初始值：top0=0,top1=9 ，栈顶指针都是：先赋值，再加1
 
 
 
此时还有两个剩余空间