有关辅助栈的使用场景

辅助栈的使用：

@Test//(剑指 Offer 31. 栈的压入、弹出序列)
    public void test31() {

        int[] pushed = {1, 2, 3, 4, 5};
        int[] popped = {4, 5, 3, 2, 1};

        System.out.println(validateStackSequences(pushed, popped));

    }

    public static boolean validateStackSequences(int[] pushed, int[] popped) {


        //答案方法：使用辅助堆栈。
        Stack<Integer> stack = new Stack<>();

        int i = 0;

        for (int a : pushed) {

            stack.push(a);

            while (!stack.isEmpty() && stack.peek() == popped[i]) {

                stack.pop();
                i++;

            }

        }

        return stack.isEmpty();
    }

#双端队列：ArrayDeque（既可以作为queue使用，又可以作为stack使用）：

ArrayDeque不是线程安全的。
ArrayDeque不可以存取null元素，因为系统根据某个位置是否为null来判断元素的存在。
当作为栈使用时，性能比Stack好；当作为队列使用时，性能比LinkedList好。

1.添加元素
addFirst(E e)在数组前面添加元素
addLast(E e)在数组后面添加元素
offerFirst(E e) 在数组前面添加元素，并返回是否添加成功
offerLast(E e) 在数组后天添加元素，并返回是否添加成功

2.删除元素
removeFirst()删除第一个元素，并返回删除元素的值,如果元素为null，将抛出异常
pollFirst()删除第一个元素，并返回删除元素的值，如果元素为null，将返回null
removeLast()删除最后一个元素，并返回删除元素的值，如果为null，将抛出异常
pollLast()删除最后一个元素，并返回删除元素的值，如果为null，将返回null
removeFirstOccurrence(Object o) 删除第一次出现的指定元素
removeLastOccurrence(Object o) 删除最后一次出现的指定元素

3.获取元素
getFirst() 获取第一个元素,如果没有将抛出异常
getLast() 获取最后一个元素，如果没有将抛出异常

4.队列操作
    add(E e) 在队列尾部添加一个元素
    offer(E e) 在队列尾部添加一个元素，并返回是否成功
    remove() 删除队列中第一个元素，并返回该元素的值，如果元素为null，将抛出异常(其实底层调用的是removeFirst())
       poll()  删除队列中第一个元素，并返回该元素的值,如果元素为null，将返回null(其实调用的是pollFirst())
       element() 获取第一个元素，如果没有将抛出异常
    peek() 获取第一个元素，如果返回null
  

5.栈操作
    push(E e) 栈顶添加一个元素
    pop(E e) 移除栈顶元素,如果栈顶没有元素将抛出异常
    

6.其他
    size() 获取队列中元素个数
    isEmpty() 判断队列是否为空
    iterator() 迭代器，从前向后迭代
    descendingIterator() 迭代器，从后向前迭代
    contain(Object o) 判断队列中是否存在该元素
    toArray() 转成数组
    clear() 清空队列
    clone() 克隆(复制)一个新的队列

参考链接：ArrayDeque

@Test//(剑指 Offer II 025. 链表中的两数相加)
    public void test24() {

    }

    public static ListNode addTwoNumbers(ListNode l1, ListNode l2) {


        //使用栈：看到逆序，会想到栈，利用int carry存进位，进位肯定要想到是从后向前   (看答案)
        Deque<Integer> stack1 = new ArrayDeque<>();
        Deque<Integer> stack2 = new ArrayDeque<>();

        while (l1 != null) {
            stack1.push(l1.val);
            l1 = l1.next;
        }

        while (l2 != null) {
            stack2.push(l2.val);
            l2 = l2.next;
        }

        int carry = 0;//保存进位
        ListNode temp = null;

        while (!stack1.isEmpty() || !stack2.isEmpty() || carry != 0) {

            int a = stack1.isEmpty() ? 0 : stack1.pop();
            int b = stack2.isEmpty() ? 0 : stack2.pop();

            int value = a + b + carry;

            carry = value / 10;
            value = value % 10;

            ListNode cur = new ListNode(value);

            cur.next = temp;
            temp = cur;

        }

        return temp;
    }