在一个数组里面实现三个栈

* 使用一个数组来实现三个栈：
* 这个问题是数组实现一个栈的升级版本，
* 一个数组实现两个栈比较的简单，可以从数组的两端到中间，也可以从中间到两端，以至于实现三个四个五个栈都行，关键是要记住栈的开始处，当栈的容量不够时做好调整
* 就单单对这个问题而言，一个数组实现三个栈又有一下两种处理方式：
* 1、把数组均分成三部分 [0, n/3) [n/3, 2n/3) [2n/3, n-1)
* 这种做法有个弊端，就是三个栈的大小都是固定的，有时某个栈实际使用的空间可能很小，而有的栈的空间却又不够用，于是造成了很大的浪费，有一种可以考虑的做法就是事先预估
* 这三个栈各自可能的大小，按需分配空间大小。实践中更有意义的做法是使用下面弹性大小的方法
* 2、所谓弹性大小的方法，就是记录各个栈的初试位置，然后就可以快乐的使用栈了，当某个栈的空间不够时就移动栈。
* 这种想法来实现三个栈时，恰恰又有一个小诀窍之处：数组的两端作为两个栈的base，第三个栈同时标记栈顶和栈顶，数组头和数组尾栈均向数组中间长，中间的数组向数组
* 低地址长，任何一个数组push操作空间不够时 就需要 shift中间的栈
* 还有就是注意，中间的栈左右移动的距离每次是1，本来想设计的 是可以自己随意修改这个移动的步长，但是发现这样没有实际意义，还是不如每次移动一个步长

ublic class Arr3Stack {
    public static void main(String[] args) {
        ThreeStackUsingOneArray<Integer> arr = new ThreeStackUsingOneArray<Integer>();
        
        System.out.println("array is full : "+arr.isFull());
        
        arr.push(0,1);
        arr.push(1, 3);
        arr.push(1, 2);
        arr.push(2, 5);
        arr.push(2, 4);
        
        System.out.println("array is full : "+arr.isFull());
        
        arr.print();
    }
}

class ThreeStackUsingOneArray <AnyType>{
    private AnyType[] array = null;
    private int arrayLength = 5;    //定义数组的初试长度
    
    // 以为 stack2 stack3的栈底是 数组的首和尾所以 定义这两个站的 栈顶
    int stackOneTop;    // stack 1的栈顶
    int stackTwoTop;    // stack 2 的栈顶
    int stackTwoBase;    //stack 2的
    int stackThreeTop;    //stack 3的栈顶
    /*
     * 中间栈需要移动的方向
     * 0 不用搬动，Array is full
     * 1 向后移动
     * -1 向前移动
     */
    int flag = -2;
    
    public ThreeStackUsingOneArray()
    {
        init();
    }
    public ThreeStackUsingOneArray(int len)
    {
        arrayLength = len;
        init();
    }
    
    public void init()
    {
        array = (AnyType[]) new Object[arrayLength];    //应对创建 泛型数组的问题
        
        stackOneTop = 0;
        stackThreeTop = arrayLength - 1;
        stackTwoBase = (arrayLength-1) * 2 / 3;
        stackTwoTop = stackTwoBase;
        
    }
    
    //print the array
    public void print()
    {
        for (int i = 0; i < array.length; i ++)
        {
            System.out.println(array[i]);
        }
    }

    // 判断当前数组是不是full
    public boolean isFull()
    {
        if(stackOneTop > stackTwoTop && stackTwoBase >= stackThreeTop)
            return true;
        return false;
    }
    
    /**
     * 后面的栈的操作 一律都带有一个栈的标号 stackNum = 0 , 1, 2， 表示堆第stacjNum进行操作
     */
    public void push(int stackNum, AnyType x)
    {
        if(isFull())
            throw new RuntimeException(new Exception("array is full"));
        
        
        if(stackNum == 0)
        {
            if(flag == 1)    // 需要把中间的一个栈 往后面移动
                shiftStackTwo();
            
            array[stackOneTop ++] = x;
            
        }else if(stackNum == 1){
            if(flag == 1)
                shiftStackTwo();
            
            array[stackTwoTop --] = x;
            
        }else if(stackNum == 2){
            if(flag == -1)
                shiftStackTwo();
            array[stackThreeTop --] = x;
            
        }else
            throw new RuntimeException(new Exception("stackNum is out"));
    
        if(isFull())
            flag = 0;    //array os full
        if(stackOneTop > stackTwoTop)
        {
            flag = 1;    //中间的栈 往后面移动
        }
        if (stackTwoBase == stackThreeTop)
        {
            flag = -1;    //中间的栈 往前面移动
        }
    }

    public void shiftStackTwo() {
        switch(flag)
        {
            case 0:
                throw new RuntimeException(new Exception("array is full"));
            case 1:    //中间的栈 向后移动 step
                // 检查 还有没有可以往后移动的空间
                if(stackTwoBase+1 > stackThreeTop)
                    throw new RuntimeException(new Exception("array is full"));
                for( int i = stackTwoBase; i >= stackTwoTop-1; i --)
                    array[i+1] = array[i];
                stackTwoTop ++; stackTwoBase ++;
                break;
            case -1:
                // 检查前面还有没空间
                if(stackOneTop-1 > stackTwoTop)
                    throw new RuntimeException(new Exception("array is full"));
                for(int i = stackTwoTop-1; i <= stackTwoBase; i++)
                    array[i-1] = array[i];
                stackTwoTop --; stackTwoBase --;
                break;
            default:
                break;
        }
    }
    
    public boolean isEmpty(int stackNum)
    {
        boolean b = false;
        switch (stackNum) {
        case 0:
            if(stackOneTop == 0) b = true;
            break;
            
        case 1:
            if(stackTwoTop == stackTwoBase) b = true;
            break;

        case 2:
            if(stackThreeTop == arrayLength-1) b = true;
            break;
            
        default:
            throw new RuntimeException(new Exception("stacknum is out"));
        }
        return b;
    }
    
    /*
     * 出站操作
     */
    public AnyType pop(int stackNum)
    {
        AnyType x ;
        switch (stackNum) {
        case 0:
            if(isEmpty(stackNum))
                throw new RuntimeException(new Exception("stack"+stackNum+" is empty"));
            x = array[--stackOneTop];
            break;
        
        case 1:
            if(isEmpty(stackNum))
                throw new RuntimeException(new Exception("stack"+stackNum+" is empty"));
            x = array[++stackTwoTop];
            break;
            
        case 2:
            if(isEmpty(stackNum))
                throw new RuntimeException(new Exception("stack"+stackNum+" is empty"));
            x = array[++stackThreeTop];
            break;
            
        default:
            throw new RuntimeException(new Exception("stacknum is out"));
        }
        return x;
    }
    
}