两栈共享空间

1.共有栈的实现

package edu.tcu.soft;

/**
 * 两栈共享空间
 */
public class MyBothStack<E> {
	// 定义一个数组
	private Object[] object = new Object[5];
	// 分别定义两个栈栈顶指针
	private int top1, top2;

	// 初始化栈
	public MyBothStack() {
		this.top1 = -1;
		this.top2 = object.length;
	}

	// 入栈操作
	public void push(int i, E e) {
		// 判断栈是否满
		if (top1 == top2 - 1) {
			object=increaseStack(object,top1,top2);
			System.out.println("栈溢出");
		}else {
			// 如果i=1,入左栈
			if (i == 1) {
				object[++top1] = e;
			}
			// 如果i=2,入右栈
			if (i == 2) {
				object[--top2] = e;
			}
		}
	}
	// 出栈操作
	@SuppressWarnings("unchecked")
	public E pop(int i) {
		// 如果i=1,将左栈的栈顶元素出栈
		if (i == 1) {
			if(top1==-1){
				System.out.println("左栈弹出栈顶元素异常");
			}
			return (E) object[top1--];
		}
		// 如果i=2,将右栈的栈顶元素出栈
		if (i == 2) {
			if(top2==object.length){
				System.out.println("右栈弹出栈顶元素异常");
			}
			return (E) object[top2++];
		}
		return null;
	}
	// 获取栈顶元素
	@SuppressWarnings("unchecked")
	public E peek(int i){
		if(i==1){
			return (E) object[top1];
		}
		if(i==2){
			return (E) object[top2];
		}
		return null;
	}
	
	//当两栈满时，自动将栈的长度增长为原来的1倍
	private Object[] increaseStack(Object[] object2, int top12, int top22) {
		//将object数组的长度变为原来的1倍
		int oldLength=object2.length;
		int newLength=object.length;
		object=new Object[object2.length*2];
		for(int i=0;i<=top12;i++){
			object[i]=object2[i];
		}
		for(int j=newLength-1;j>newLength-(oldLength-top22);j--){
			object[j]=object2[--oldLength];
		}
		return object;
	}
	//获取栈的长度
	public int size(){
		return object.length;
	}
}

2.测试类

package edu.tcu.soft;

public class Test {
   public static void main(String[] args) {
	MyBothStack<Integer> stack=new MyBothStack<Integer>();
	stack.push(1, 1);
	stack.push(1, 2);
	stack.push(1, 3);
	stack.push(2, 4);
	stack.push(2, 5);
	System.out.println(stack.peek(1)+"---");//预期输出3
	stack.push(1, 4);
	System.out.println(stack.size()+"---栈数组的长度");
}
}

通过亲手写代码，你才会发现栈、共享栈的实现方式其实是差不多。

共点：通过一个数组和栈顶指针来实现栈元素的存放和弹出      

不同点：顺序栈是单方向延伸，共享栈是相向延伸

共享栈优点：如果在一个程序中同时使用相同数据类型和两个栈是，我们想到最直接的办法是为每个栈开辟一个数组空间，不过这样做的结果可能出现一个栈的空间已被占满而无法进行插入操作，同时另一个栈的空间仍有剩余而没得到利用的情况，从而造成存储空间的浪费。共享栈利用一个数组来存储两个栈，让一个栈的栈底为该数组的始端，另一个栈的栈顶为该数组的末端，每个栈从各自的端点向中间延伸。