TwoStackInOneArray.java

package algorithm.stack;

import java.util.Arrays;
import java.util.EmptyStackException;

/**
 * 用一个数组实现两个栈
 * 将数组的起始位置看作是第一个栈的栈底，将数组的尾部看作第二个栈的栈底，压栈时，栈顶指针分别向中间移动，直到两栈顶指针相遇，则扩容。
 *
 * @author liuxin
 */
public class TwoStackInOneArray {
    private Object[] data = new Object[10];

    private int top1 = 0;
    private int top2 = data.length - 1;

    /**
     * 向第一个栈中压入元素
     *
     * @param o
     */
    public void push1(Object o) {
        ensureCapacity();
        data[top1++] = o;
    }

    /**
     * 从第一个栈中弹出元素
     *
     * @return
     */
    public Object pop1() {
        if (top1 <= 0) {
            throw new EmptyStackException();
        }
        return data[--top1];
    }

    /**
     * 获取第一个栈的栈顶元素
     *
     * @return
     */
    public Object peek1() {
        if (top1 <= 0) {
            throw new EmptyStackException();
        }
        return data[top1 - 1];
    }

    public int size1() {
        return top1 - 1;
    }

    /*
     * 向第二个栈压入元素
     */
    public void push2(Object o) {
        ensureCapacity();
        data[top2--] = o;
    }

    /**
     * 从第二个栈弹出元素
     *
     * @return
     */
    public Object pop2() {
        if (top2 >= data.length - 1) {
            throw new EmptyStackException();
        }
        return data[++top2];
    }

    /**
     * 获取第二个栈的栈顶元素
     *
     * @return
     */
    public Object peek2() {
        if (top2 >= data.length - 1) {
            throw new EmptyStackException();
        }
        return data[top2 + 1];
    }

    public int size2() {
        return data.length - top2 - 1;
    }

    private void ensureCapacity() {
        if (top1 > top2) {
            int nextCapacity = nextCapacity(data.length);
            Object[] newArray = new Object[nextCapacity];

            System.arraycopy(data, 0, newArray, 0, size1());

            int size2 = size2();
            int srcPos = data.length - size2;
            int destPos = nextCapacity - size2;
            System.arraycopy(data, srcPos, newArray, destPos, size2);
            top2 = destPos - 1;

            Arrays.fill(data, null);
            data = newArray;
        }
    }

    private int nextCapacity(int currentCapacity) {
        return currentCapacity * 2;
    }

}