How to use multiple stacks to implement a dequeu (using three stacks)

这是 Implement Deque Using Two Stacks 的升华版本， 存一半有效的把时间复杂度最坏情况降低到O(N/2) 

 这里最好，最坏的情况正好和  Implement Deque Using Two Stacks 相反。

最好的情况: 雨露均沾

最坏的情况：专宠一人

/*
dequeu can add/remove from two sides
stack can add/remove from only one side
* */
public class ImplementDequeUsingThreeStacks {
    private Deque<Integer> stackLeft;
    private Deque<Integer> stackRight ;
    private Deque<Integer> stackBuffer;

    public ImplementDequeUsingThreeStacks() {
        stackLeft = new LinkedList<>();
        stackRight = new LinkedList<>();
        stackBuffer = new LinkedList<>();
    }
    public void addLeft(int value){
        stackLeft.push(value);
    }
    public void addRight(int value){
        stackRight.push(value);
    }
    /*
        ->       <-
         1 2 | 3 4
        <-       ->
    this is very interesting: if left is not empty, return left
    if left is empty, then:
     1) shuffle the first 1/2 right into the buffer to host,
     2) and then shift the 2nd half into the left
     3) pop from the left

    just remember that after each stack shuffle, the order is changed. thats exactly what we need: 3
    * */
    //     | 3 4
    public Integer removeLeft(){
        if (!stackLeft.isEmpty()){
            return stackLeft.pop();
        }
        //corner case
        if (isEmpty()){
            return null;
        } else{
            //left:[] buffer:[] right:[3,4]
            int mid = stackRight.size()/2 ;
            // < since its index based
            // left:[]   buffer: [4] right:[3]
            for (int i = 0; i <mid ; i++) {
                stackBuffer.push(stackRight.pop());
            }
            // left:[3] buffer: [4] right:[]
            while (!stackRight.isEmpty()){
                stackLeft.push(stackRight.pop());
            }
            //left:[3] buffer: [] right:[4]
            while (!stackBuffer.isEmpty()){
                stackRight.push(stackBuffer.pop());
            }
            return stackLeft.pop();
        }
    }
    // 1 2 |
    public Integer removeRight(){
        if (!stackRight.isEmpty()){
            return stackRight.pop();
        }
        //corner case
        if (isEmpty()){
            return null;
        } else{
            // left:[1,2] buffer:[] right:[]
            int mid = stackRight.size()/2 ;
            // < since its index based
            // left:[2]   buffer: [1] right:[]
            for (int i = 0; i <mid ; i++) {
                stackBuffer.push(stackLeft.pop());
            }
            // left:[] buffer: [1] right:[2]
            while (!stackRight.isEmpty()){
                stackRight.push(stackLeft.pop());
            }
            //left:[1] buffer: [] right:[2]
            while (!stackBuffer.isEmpty()){
                stackLeft.push(stackBuffer.pop());
            }
            return stackRight.pop();
        }
    }


    public boolean isEmpty(){
        return stackLeft.isEmpty() && stackRight.isEmpty() ;
    }
    //lazy
    public int size(){
        return stackLeft.size() + stackRight.size() ;
    }

    public static void main(String[] args) {
        ImplementDequeUsingThreeStacks deque = new ImplementDequeUsingThreeStacks();
        //1 2 | 3 4
        deque.addLeft(2);
        deque.addRight(3);
        deque.addRight(4);
        deque.addLeft(1);
        System.out.println(deque.removeLeft());//1
        System.out.println(deque.removeRight());//4
        System.out.println(deque.removeRight());//3
        System.out.println(deque.size()); //1
        System.out.println(deque.removeLeft()); //2
        System.out.println(deque.size()); //0
    }
}