栈的两栈共享空间结构的实现

两栈共享空间结构

本质就是两个ArrayStack尾部相接
top1为左栈栈顶 开始于-1 = leftTop
top2为右栈栈顶 开始于data.lenght = rightTop

构造方法

public class ArrayListDoubleEnd<E> implements Stack<E> {
	enum Direction{			//定义枚举类型 左右
		LEFT,RIGHT;
	}
	private E[] data;
	private int leftTop;	//左端栈的栈顶，开始在-1	
	private int rightTop;	//右端栈顶，开始在data.lenght	
	private static int DEFAULT_SIZE = 10;	//默认容量10
	
	public ArrayListDoubleEnd() {
		this(DEFAULT_SIZE);	//调用有参构造
	}
	public ArrayListDoubleEnd(int capaticy) {
		data = (E[]) new Object[capaticy];
		leftTop = -1;
		rightTop = data.length;
	}

getSize()方法的实现

指定端元素个数 getSize(Direction dir)

	public int getSize(Direction dir){
		if(dir==Direction.LEFT){
			return leftTop+1;
		}else{
			return data.length-rightTop;
		}
	}

元素总数

	public int getSize() {
		return getSize(Direction.LEFT)+getSize(Direction.RIGHT);
	}

判断是否为空 isEmpty()

	/**
	 * 判断左右端是否全为空
	 * @return Boolean
	 */
	public boolean isEmpty() {
		return isEmpty(Direction.LEFT)&&isEmpty(Direction.RIGHT);
	}
	//指定端是否为空
	public boolean isEmpty(Direction dir) {
		if(dir==Direction.LEFT){
			return leftTop==-1;
		}else{
			return rightTop==data.length;
		}
	}

判断是否容量满

	//判断是否满
	public boolean isFull(){
		return leftTop+1==rightTop;
	}

压栈过程

	/**
	 * 那端少进那端
	 */
	public void push(E e) {
		if(getSize(Direction.LEFT)>getSize(Direction.RIGHT)){
			push(Direction.RIGHT,e);
		}else{
			push(Direction.LEFT, e);
		}
	}
	/**
	 * 指定端进栈
	 * @param dir 指定端
	 * @param e	元素
	 */
	public void push(Direction dir,E e){
		if(isFull()){
			resize(data.length*2);
		}
		if(dir==Direction.LEFT){
			data[++leftTop] = e; 	//指针先右移再进行入栈
		}else{
			data[--rightTop] = e;	//指针先左移再入栈
		}
	}

容量更新过程 resize()

	private void resize(int newLen) {
		E [] newdata = (E[]) new Object [newLen];
		//复制左边
		for (int i=0;i<=leftTop;i++){
			newdata[i] = data[i];
		}
		//复制右边
		/*
		 * 创建两个标记位
		 * index 旧表最后一位元素所在位置
		 * i 新表最后一位元素所在位置
		 * data.length-rightTop 为旧表元素个数
		 * 新表长度-元素个数就是右指针的位置
		 * 指针位置向左移1及跳出循环
		 */
		int i;
		int index = data.length-1;
		for (i=newdata.length-1;i>=newdata.length-(data.length-rightTop);i--){
			newdata[i] = data[index--];
		}
		rightTop = i+1; 	//循环跳出时i在右指针前一位，也就是左边一位
		data = newdata		//更新数组
	}

弹栈过程 pop()

	/**
	 * 那端多弹那端
	 */
	public E pop() {
		if(isEmpty()){
			throw new IllegalArgumentException("两端栈都为空");
		}
		if(getSize(Direction.LEFT)>=getSize(Direction.RIGHT)){
			return pop(Direction.LEFT);
		}else{
			return pop(Direction.RIGHT);
		}
	}
	/**
	 * 指定端出
	 * @param dir
	 * @return e 
	 */
	public E pop(Direction dir) {
		if(dir==Direction.LEFT){
			if(leftTop==-1){
				throw new IllegalArgumentException("左端栈为空");
			}
			E e = data[leftTop--]; 	//先取出再移动
			//缩容
			if(data.length>DEFAULT_SIZE&&getSize()<=data.length/4){
			//长度不能小于默认长度，元素个数小于长度1/4
				resize(data.length/2);	//缩1/2
			}
			return e;
		}else{
			if(rightTop==data.length){
				throw new IllegalArgumentException("右端栈为空");
			}
			E e = data[rightTop++];	
			//缩容
			if(data.length>DEFAULT_SIZE&&getSize()<=data.length/4){
				resize(data.length/2);
			}
			return e;
		}
	}

获取栈顶元素（不出栈）peek()

/**
	 * 获取栈顶元素,多得一端，不出栈
	 */
	public E peek() {
		if(isEmpty()){
			throw new IllegalArgumentException("两端栈为空");
		}
		if(getSize(Direction.LEFT)>=getSize(Direction.RIGHT)){
			return peek(Direction.LEFT);
		}else{
			return peek(Direction.RIGHT);
		}
	}
	/**
	 * 取指定端
	 * @param dir
	 * @return e
	 */
	public E peek(Direction dir){
		if(dir==Direction.LEFT){
			if(leftTop==-1){
				throw new IllegalArgumentException("左端栈为空");
			}
			return data[leftTop];	//不出栈，指针位置没有变化
		}else{
			if(rightTop==data.length){
				throw new IllegalArgumentException("右端栈为空");
			}
			return data[rightTop];	//不出栈，指针位置没有变化
		}
	}

清空栈 clear()

	/**
	 * 同时清空
	 */
	public void clear() {
		clear(Direction.LEFT);
		clear(Direction.RIGHT);
	}
	public void clear(Direction dir){
		if(dir==Direction.LEFT){
			leftTop = -1;	//置为初始值
		}else{
			rightTop = data.length;
		}
	}

equals()的重写

	@Override
	public boolean equals(Object obj) {
		if(obj==null){
			return false;
		}
		if(obj==this.data){
			return true;
		}
		if(obj instanceof ArrayListDoubleEnd){
			ArrayListDoubleEnd<E> doubleEnd = (ArrayListDoubleEnd<E>) obj;
			if(doubleEnd.getSize()==getSize()){
				//创建两个线性表用来存储自身与传入的obj中有效元素
				ArrayList<E> list1 = new ArrayList<E>(getSize());
				ArrayList<E> list2 = new ArrayList<E>(getSize());
				//拼接自身左边
				for(int i=0;i<=leftTop;i++){
					list1.addLast(data[i]);
				}
				//拼接自身右边
				for(int i=rightTop;i<data.length;i++){
					list1.addLast(data[i]);
				}
				//栈里才有数组
				//拼接传进的双端栈左边
				for(int i=0;i<=doubleEnd.leftTop;i++){
					list2.addLast(doubleEnd.data[i]);
				}
				//拼接传入栈的右边
				for(int i=doubleEnd.rightTop;i<doubleEnd.data.length;i++){
					list2.addLast(doubleEnd.data[i]);
				}
				return list1.equals(list2);
			}
		}
		return false;
	}

toString()的重写

	@Override
	public String toString() {
		StringBuilder sb = new StringBuilder();
		sb.append("ArrayListDoubleEnd size="+getSize()+",capacity ="+data.length+"\n");
		if(getSize()==0){
			sb.append("[]");
		}else{
			sb.append('[');
			int count = 0;	//用来标记循环到那个元素
			//循环取出左边
			for(int i=0;i<=leftTop;i++){
				sb.append(data[i]);
				count++;
				if(count==getSize()){
					sb.append(']');
				}else{
					sb.append(',');
				}
			}
			//循环取出右边
			for(int i=rightTop;i<data.length;i++){
				sb.append(data[i]);
				count++;
				if(count==getSize()){
					sb.append(']');
				}else{
					sb.append(',');
				}
			}
		}
		return sb.toString();
	}