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

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

    public ImplementDequeUsingTwoStacks() {
        stackLeft = new LinkedList<>();
        stackRight = 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 shuffle from right into left and then pop the left
    just remember that after each stack shuffle, the order is changed. thats exactly what we need: 3
    * */
    public Integer removeLeft(){
        return shuffleAndPop(stackRight, stackLeft);
    }
    public Integer removeRight(){
        return shuffleAndPop(stackLeft, stackRight);
    }
    /*
    * from: the stack items from
    * to: the stack items goes into and then pop
    * */
    private Integer shuffleAndPop(Deque<Integer> from , Deque<Integer> to){
        if (isEmpty()) return null;
        if (!to.isEmpty()){
            return to.pop();
        }
        else{
            while (!from.isEmpty()){
                to.push(from.pop());
            }
            return to.pop();
        }
    }

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

    public static void main(String[] args) {
        ImplementDequeUsingTwoStacks deque = new ImplementDequeUsingTwoStacks();
        //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
    }
}

个人感想： 这并没有优化太多，因为SHUFFLE 把整个都搬过去另一边，

WORST CASE 的情况是 “雨露均沾”： 当你SHUFFLE 从左边到右边的时候， 马上REMOVELEFT， 那你就得马上再从右边SHUFFLE 到左边。。。 和捉迷藏一样，每次POP 都是O（N） 所以是很糟糕的一个算法。 

最好的结果： 专宠一人。  时间复杂度可以AMORTIZE 近似为O(1)

优化版本 using three stacks 在这里