其他栈相关问题

1. 包含min函数的栈

来源
leetcode155 https://leetcode.com/problems/min-stack/
剑指offer21

Design a stack that supports push, pop, top, and retrieving the minimum element in constant time.
push(x) -- Push element x onto stack.
pop() -- Removes the element on top of the stack.
top() -- Get the top element.
getMin() -- Retrieve the minimum element in the stack.
注：这几个函数要在常数时间内完成。

思路：push,pop,top正常来说肯定是常数时间内的，但是如何让getMin也能保持在常数时间呢。
单独维护一个单调递减栈来存储栈中最小值。

class MinStack {
    Deque<Integer> deque = new ArrayDeque<Integer>();
    Deque<Integer> minDeque = new ArrayDeque<Integer>();
    public void push(int x) {
        deque.add(x);
        if(minDeque.size() == 0 || x <= minDeque.peekLast()) minDeque.add(x);
    }
    public void pop() {
        int x = deque.pollLast();
        if(x == minDeque.peekLast()) minDeque.pollLast();
    }
    public int top() {
        return deque.peekLast();
    }
    public int getMin() {
        return minDeque.peekLast();
    }
}

---

2. 用两个栈实现队列

维护两个栈，每次Push进一个栈中，每次getHead从另一个栈中取，当取栈空了，则将push栈中的弹入取栈中。这样保证了先进的一定比后进的先出。弹出元素的平均时间复杂度O(1)

class QueueImpl {
    Deque<Integer> deque_push = new ArrayDeque<Integer>();
    Deque<Integer> deque_pop = new ArrayDeque<Integer>();

    public void push(int x) {
        deque_push.add(x);
    }
    public int getHead() {
        if(deque_pop.size() == 0){
                while(deque_push.size() != 0) deque_pop.add(deque_push.pollLast());
        }
        return deque_pop.pollLast();
    }
}

---

3. 用两个队列实现栈

维护两个队列，每次向有元素的队列压入元素（两个队列会交替压入），每次弹出元素时要将有元素队列中的元素放入另一个队列中，留下一个元素在原来的队列弹出。弹出的平均时间复杂度O(n)。

class StackImpl {
    Deque<Integer> deque1 = new ArrayDeque<Integer>();
    Deque<Integer> deque2 = new ArrayDeque<Integer>();

    public void push(int x) {
        Deque<Integer> deque = deque1.size() == 0 ? deque2 : deque1;
        deque.add(x);
    }
    public int pop() {
        Deque<Integer> deque_pop = deque1.size() == 0 ? deque2 : deque1;
        Deque<Integer> deque_push = deque1.size() == 0 ? deque1 : deque2;
        while(deque_pop.size() > 1) deque_push.add(deque_pop.pollLast());
        return deque_pop.pollLast();
    }
}

---

4. 用一个数组实现两个栈

说明如何用一个数组A[1..n]来实现两个栈，使得两个栈中的元素总和不到n时，两个都不会发生上溯。注意PUSH和POP操作的时间应为O(1)
思路：两个栈从数组的前后开始向中间存储。

class Stack {
    int[] arr;
    int flag1 = -1, flag2  = -1;
    public Stack(n){
        arr = new int[n];
        flag2 = n;
    }
    public void push1(int x) {
        if(flag1 == (flag2 - 1)) return;
        arr[++flag1] = x; 
    }
    public void push2(int x) {
        if(flag1 == (flag2 - 1)) return;
        arr[--flag2] = x; 
    }
    public int pop1() {
        if(flag1 > -1) return arr[flag1--]; 
    }
    public int pop2() {
        if(flag2 < n) return arr[flag2++]; 
    }
}

思考：用一个数组实现三个栈呢。
可以使用交叉索引，像上一题存两个栈的话，一个栈可以存储在0,2,4,6…/另一存储在1,3,5,7…
若三个栈就可以存储成0,3,6,9…./1,4,7,10…/2,5,8,11….
若还沿用上题方法，可以将第三个栈存储为：mid, mid+1, mid-1, mid+2, mid-2这样对称存储。

---

5. 栈对递归思想的考察

翻转栈中所有元素，要求额外空间复杂度o(1)
用递归来实现（与汉诺塔思想类似）
首先弹出栈顶元素top1，将剩余n-1栈递归反转，反转后弹出当前栈顶元素top2，再递归反转n-2栈。
放入top1元素，反转n-1栈。
最后放入top2元素。

public void reverseStack(Deque<Integer> deque){
    if(deque.size() == 0) return;
    int top1 = deque.pollLast();
    reverseStack(deque);
    if(deque.size() == 0) deque.add(top1);
    else{
        int top2 = deque.pollLast();
        reverseStack(deque);
        deque.add(top1);
        reverseStack(deque);
        deque.add(top2);
    }
}

-给栈中元素排序
类似冒泡排序的递归思想，每次将最小的值弹到栈顶，然后从下一个元素开始进行下轮的冒泡递归

public void sortStack(Deque<Integer> deque){
    if(deque.size() == 0) return;
    int top1 = deque.pollLast();
    sortStack(deque);
    if(deque.size() == 0) deque.add(top1);
    else{
        int top2 = deque.pollLast();
        if(top1 <= top2) {
            deque.add(top2);
            deque.add(top1);
        }
        else{
            deque.add(top1);
            sortStack(deque);
            deque.add(top2);
        }
    }
}