栈&队列

1、用两个栈实现队列

add：压入栈后pushToPop

poll：pushToPop后弹出栈

peek：pushToPop后得到队首元素

public class TwoStacksQueue {
        public Stack<Integer> stackPush;
        public Stack<Integer> stackPop;

        public TwoStacksQueue() {
            stackPush = new Stack<Integer>();
            stackPop = new Stack<Integer>();
        }

        private void pushToPop() {
            if (stackPop.empty()) {
                while (!stackPush.empty()) {
                    stackPop.push(stackPush.pop());
                }
            }
        }

        public void add(int pushInt) {
            stackPush.push(pushInt);
            pushToPop();
        }

        public int poll() {
            if (stackPop.empty() && stackPush.empty()) {
                throw new RuntimeException("Queue is empty!");
            }
            pushToPop();
            return stackPop.pop();
        }

        public int peek() {
            if (stackPop.empty() && stackPush.empty()) {
                throw new RuntimeException("Queue is empty!");
            }
            pushToPop();
            return stackPop.peek();
        }
}

2、用一个队列实现栈

push：入队列后把前面的n个元素依次换到后面去

pop：把队首元素弹出

class StackByQueue {
        queue<int> q;
    public:
        /** Initialize your data structure here. */
        MyStack() {

        }

        /** Push element x onto stack. */
        void push(int x) {
            q.push(x);
            int cnt=q.size();
            while(--cnt) {
                q.push(q.front());
                q.pop();
            }
        }

        /** Removes the element on top of the stack and returns that element. */
        int pop() {
            int temp=q.front();
            q.pop();
            return temp;
        }

        /** Get the top element. */
        int top() {
            return q.front();
        }

        /** Returns whether the stack is empty. */
        bool empty() {
            return q.empty()? true : false;
        }
};

3、用两个队列实现栈

push：入队queue

pop：将队列的前面元素依次换到help队列里面去（只保留一个元素在queue队列），弹出queue队列唯一的元素res，交换队列指针并返回res

peek：将队列的前面元素依次换到help队列里面去（只保留一个元素在queue队列），弹出queue队列唯一的元素res然后将其入help队列，交换队列指针并返回res

public static class TwoQueuesStack {
        private Queue<Integer> queue;
        private Queue<Integer> help;

        public TwoQueuesStack() {
            queue = new LinkedList<Integer>();
            help = new LinkedList<Integer>();
        }

        public void push(int pushInt) {
            queue.add(pushInt);
        }

        public int peek() {
            if (queue.isEmpty()) {
                throw new RuntimeException("Stack is empty!");
            }
            while (queue.size() != 1) {
                help.add(queue.poll());
            }
            int res = queue.poll();
            help.add(res);
            swap();
            return res;
        }

        public int pop() {
            if (queue.isEmpty()) {
                throw new RuntimeException("Stack is empty!");
            }
            while (queue.size() > 1) {
                help.add(queue.poll());
            }
            int res = queue.poll();
            swap();
            return res;
        }

        private void swap() {
            Queue<Integer> tmp = help;
            help = queue;
            queue = tmp;
        }

}

4、设计一个有 getMin 功能的栈

法一：

两个栈：data和min，待压入的数据：newnum

push：对于data，压入；对于min，当newnum<=min.top()或min栈空，压入

pop：对于data，弹出栈顶元素value；对于min，当value=min.top()，弹出，当value>min.top()，不弹出。返回value

getMin：返回min.top()

public static class MyStack1 {
        private Stack<Integer> stackData;
        private Stack<Integer> stackMin;

        public MyStack1() {
            this.stackData = new Stack<Integer>();
            this.stackMin = new Stack<Integer>();
        }

        public void push(int newNum) {
            if (this.stackMin.isEmpty()) {
                this.stackMin.push(newNum);
            } else if (newNum <= this.getmin()) {
                this.stackMin.push(newNum);
            }
            this.stackData.push(newNum);
        }

        public int pop() {
            if (this.stackData.isEmpty()) {
                throw new RuntimeException("Your stack is empty.");
            }
            int value = this.stackData.pop();
            if (value == this.getmin()) {
                this.stackMin.pop();
            }
            return value;
        }

        public int getmin() {
            if (this.stackMin.isEmpty()) {
                throw new RuntimeException("Your stack is empty.");
            }
            return this.stackMin.peek();
        }
}

法二：

两个栈：data和min，待压入的数据：newnum

push：对于data，压入；对于min，当newnum<min.top()或栈空，压入newnum，当newnum>=min.top()，压入min.top()

pop：对于min，弹出；对于data，弹出并返回

getMin：返回min.top()

public static class MyStack2 {
        private Stack<Integer> stackData;
        private Stack<Integer> stackMin;

        public MyStack2() {
            this.stackData = new Stack<Integer>();
            this.stackMin = new Stack<Integer>();
        }

        public void push(int newNum) {
            if (this.stackMin.isEmpty()) {
                this.stackMin.push(newNum);
            } else if (newNum < this.getmin()) {
                this.stackMin.push(newNum);
            } else {
                int newMin = this.stackMin.peek();
                this.stackMin.push(newMin);
            }
            this.stackData.push(newNum);
        }

        public int pop() {
            if (this.stackData.isEmpty()) {
                throw new RuntimeException("Your stack is empty.");
            }
            this.stackMin.pop();
            return this.stackData.pop();
        }

        public int getmin() {
            if (this.stackMin.isEmpty()) {
                throw new RuntimeException("Your stack is empty.");
            }
            return this.stackMin.peek();
        }
}

法三：

class MinStack {
        stack<int> x_stack;
        stack<int> min_stack;
    public:
        MinStack() {
            min_stack.push(INT_MAX);
        }

        void push(int x) {
            int min = min_stack.top()<x? min_stack.top() : x;
            x_stack.push(x);
            min_stack.push(min);
        }

        void pop() {
            x_stack.pop();
            min_stack.pop();
        }

        int top() {
            return x_stack.top();
        }

        int min() {
            return min_stack.top();
        }
};

5、验证栈的压入、弹出序列

压入一个，弹出若干

public boolean validateStackSequences(int[] pushed, int[] popped) {
    Stack<Integer> stack = new Stack<>();
    int i = 0;
    for(int num : pushed) {
        stack.push(num); // num 入栈
        while(!stack.isEmpty() && stack.peek() == popped[i]) { // 循环判断与出栈
            stack.pop();
            i++;
        }
    }
    return stack.isEmpty();
}

6、用一个栈实现另一个栈的排序

想模型：设置一个主栈stack,一个辅助站help,将元素从：stack->help->stack

public static void sortStackByStack(Stack<Integer> stack) {
    Stack<Integer> help = new Stack<Integer>();
    while (!stack.isEmpty()) {
        int cur = stack.pop();
        while (!help.isEmpty() && help.peek() < cur) {
            stack.push(help.pop());
        }
        help.push(cur);
    }
    while (!help.isEmpty()) {
        stack.push(help.pop());
    }
}

7、仅用递归函数和栈操作逆序一个栈

public static int getAndRemoveLastElement(Stack<Integer> stack) {
    int result = stack.pop();
    if (stack.isEmpty()) {
        return result;
    } else {
        int last = getAndRemoveLastElement(stack);
        stack.push(result);
        return last;
    }
}
public static void reverse(Stack<Integer> stack) {
    if (stack.isEmpty()) {
        return;
    }
    int i = getAndRemoveLastElement(stack);
    reverse(stack);
    stack.push(i);
}

8、逆波兰表达式求值（后缀表达式->中缀表达式->求值）

public int evalRPN(String[] tokens) {
    Stack<Integer> stack = new Stack<>();
    int a = 0, b = 0;
    for (String val:tokens) {
        if ("+-*/".contains(val)) {
            a = stack.pop();
            b = stack.pop();
        }
        switch(val) {
            case "+": stack.push(b + a);break;
            case "-": stack.push(b - a);break;
            case "*": stack.push(b * a);break;
            case "/": stack.push(b / a);break;
            default : stack.push(new Integer(val));
        } 
    }
    return stack.pop();
}