栈和队列相关

232 用栈实现队列

请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：

实现 MyQueue 类：

void push(int x) 将元素 x 推到队列的末尾
int pop() 从队列的开头移除并返回元素
int peek() 返回队列开头的元素
boolean empty() 如果队列为空，返回 true ；否则，返回 false
说明：

你 只能 使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。
你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。

示例 1：

输入：
[“MyQueue”, “push”, “push”, “peek”, “pop”, “empty”]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 1, 1, false]

解释：
MyQueue myQueue = new MyQueue();
myQueue.push(1); // queue is: [1]
myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)
myQueue.peek(); // return 1
myQueue.pop(); // return 1, queue is [2]
myQueue.empty(); // return false

提示：

1 <= x <= 9
最多调用 100 次 push、pop、peek 和 empty
假设所有操作都是有效的 （例如，一个空的队列不会调用 pop 或者 peek 操作）

class MyQueue {
    Stack<Integer> stack1;
    Stack<Integer> stack2;
    public MyQueue() {
        this.stack1 = new Stack();
        this.stack2 = new Stack();
    }
    
    public void push(int x) {
        while(!stack1.isEmpty()){
            stack2.push(stack1.pop());
        }
        stack1.push(x);
        while(!stack2.isEmpty()){
            stack1.push(stack2.pop());
        }
    }
    
    public int pop() {
        return stack1.pop();
    }
    
    public int peek() {
        return stack1.peek();
    }
    
    public boolean empty() {
        if(stack1.isEmpty()){
            return true;
        }
        return false;
    }
}

/**
 * Your MyQueue object will be instantiated and called as such:
 * MyQueue obj = new MyQueue();
 * obj.push(x);
 * int param_2 = obj.pop();
 * int param_3 = obj.peek();
 * boolean param_4 = obj.empty();
 */

225 用队列实现栈

请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。

实现 MyStack 类：

void push(int x) 将元素 x 压入栈顶。
int pop() 移除并返回栈顶元素。
int top() 返回栈顶元素。
boolean empty() 如果栈是空的，返回 true ；否则返回false

class MyStack {
    Queue <Integer> queue1;
    Queue <Integer> queue2;
    public MyStack() {
        queue1 = new LinkedList();
        queue2 = new LinkedList();
    }
    
    public void push(int x) {
        while(!queue1.isEmpty()){
            queue2.add(queue1.remove());
        }
        queue1.add(x);
        while(!queue2.isEmpty()){
            queue1.add(queue2.remove());
        }
    }
    
    public int pop() {
        return queue1.remove();
    }
    
    public int top() {
        return queue1.peek();
    }
    
    public boolean empty() {
        if(queue1.isEmpty()){
            return true;
        }
        return false;
    }
}

/**
 * Your MyStack object will be instantiated and called as such:
 * MyStack obj = new MyStack();
 * obj.push(x);
 * int param_2 = obj.pop();
 * int param_3 = obj.top();
 * boolean param_4 = obj.empty();
 */

20 有效的括号

给定一个只包括 ‘(’，‘)’，‘{’，‘}’，‘[’，‘]’ 的字符串，判断字符串是否有效。

有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
注意空字符串可被认为是有效字符串。
示例 1:

输入: “()”
输出: true
示例 2:

输入: “()[]{}”
输出: true
示例 3:

输入: “(]”
输出: false

思路：用栈来完成，循环判断字符串，当碰到左括号的时候，将其右括号入栈；若不是左括号，就判断栈是否为空或者该字符是否不等于栈顶，若有一项成立，则返回false；循环退出后，判断若栈为空，则代表左右括号一一对应，已经比对完成，返回true，否则返回false；

class Solution {
    public boolean isValid(String s) {
        Stack<Character> stack = new Stack();
        for(int i=0;i<s.length();i++){
            char c = s.charAt(i);
            if(c=='('){
                stack.push(')');
            }else if(c=='['){
                stack.push(']');
            }else if(c=='{'){
                stack.push('}');
            }else if(stack.isEmpty()||stack.pop()!=c){
                return false;
            }
        }
        if(stack.isEmpty()){
            return true;
        }
        return false;
    }
}

1047 删除字符串中所有相邻的重复项

给出由小写字母组成的字符串 S，重复项删除操作会选择两个相邻且相同的字母，并删除它们。

在 S 上反复执行重复项删除操作，直到无法继续删除。

在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。

示例：

输入：“abbaca”
输出：“ca”
解释：
例如，在 “abbaca” 中，我们可以删除 “bb” 由于两字母相邻且相同，这是此时唯一可以执行删除操作的重复项。之后我们得到字符串 “aaca”，其中又只有 “aa” 可以执行重复项删除操作，所以最后的字符串为 “ca”。

思路：使用栈来解决。若栈为空，则直接加入，若新加入的元素与栈顶元素相等，则元素出栈，循环继续往后判断。最后用一个tmp栈，将原始栈中的元素移入，从tmp中出栈记录，则为最终答案。

class Solution {
    public String removeDuplicates(String s) {
        Stack <Character> stack = new Stack();
        Stack <Character> tmp = new Stack();
        for(int i=0;i<s.length();i++){
            char c = s.charAt(i);
            if(stack.isEmpty()){
                stack.push(c);
            }else{
                if(stack.peek()!=c){
                    stack.push(c);
                }else{
                    stack.pop();
                }
            }
        }
        while(!stack.isEmpty()){
            tmp.push(stack.pop());
        }
        StringBuilder res = new StringBuilder();
        while(!tmp.isEmpty()){
            res.append(tmp.pop());
        }
        return res.toString();
    }
}

150 逆波兰表达式求值

给你一个字符串数组 tokens ，表示一个根据 逆波兰表示法 表示的算术表达式。

请你计算该表达式。返回一个表示表达式值的整数。

注意：

有效的算符为 ‘+’、‘-’、‘*’ 和 ‘/’ 。
每个操作数（运算对象）都可以是一个整数或者另一个表达式。
两个整数之间的除法总是 向零截断 。
表达式中不含除零运算。
输入是一个根据逆波兰表示法表示的算术表达式。
答案及所有中间计算结果可以用 32 位 整数表示。

示例 1：

输入：tokens = [“2”,“1”,“+”,“3”,“*”]
输出：9
解释：该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9
示例 2：

输入：tokens = [“4”,“13”,“5”,“/”,“+”]
输出：6
解释：该算式转化为常见的中缀算术表达式为：(4 + (13 / 5)) = 6

思路：用栈来完成。循环数组，当元素tokens[i]为数字的时候，直接入栈；为运算符时，从栈中pop两个元素，进行运算后，重新入栈，循环往复即可。

class Solution {
    public int evalRPN(String[] tokens) {
        Stack<String> stack = new Stack();
        int num = 0;
        for(int i=0;i<tokens.length;i++){
            if(isNumber(tokens[i])){
                stack.push(tokens[i]);
            }else{
                String a,b;
                b = stack.pop();
                a = stack.pop();
                stack.push(cal(a,b,tokens[i]));
            }
        }
        return Integer.valueOf(stack.pop());
    }
    public boolean isNumber(String c){
        if(c.equals("+")||c.equals("-")||c.equals("*")||c.equals("/")){
            return false;
        }
        return true;
    }
    public String cal(String a,String b,String c){
        if(c.equals("+")){
            return Integer.valueOf(a)+Integer.valueOf(b)+"";
        }else if(c.equals("-")){
            return Integer.valueOf(a)-Integer.valueOf(b)+"";
        }else if(c.equals("*")){
            return Integer.valueOf(a)*Integer.valueOf(b)+"";
        }else{
            return Integer.valueOf(a)/Integer.valueOf(b)+"";
        }
    }
}

239 滑动窗口最大值

给定一个数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。

返回滑动窗口中的最大值。

思路：定义i指针和j指针，i指针初始指向1-k，j指针指向0，i与j同时向右移动。定义单调队列deque，维护deque中的值从头至尾单调递减，对窗口右端来说，当nums[j]进入时，需要删掉deque中小于nums[j]的值；对窗口左端来说，当nums[i-1]==deque的队列头（最大值），则需要从deque中删除头元素，因为nums[i-1]不是最大值，deque中已经提前删除了该值，不需要进行维护。

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        if(k==0){
            return new int[]{};
        }
        Deque<Integer> deque = new LinkedList();
        int[] res = new int[nums.length-k+1];
        for(int i=1-k,j=0;j<nums.length;i++,j++){
            if(i>0&&nums[i-1]==deque.peekFirst()){
                deque.removeFirst();
            }
            while(!deque.isEmpty()&&deque.peekLast()<nums[j]){
                deque.removeLast();
            }
            deque.addLast(nums[j]);
            if(i>=0){
                res[i] = deque.peekFirst();
            }
        }
        return res;
    }
}

347 前k个高频元素

给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。你可以按 任意顺序 返回答案。

示例 1:

输入: nums = [1,1,1,2,2,3], k = 2
输出: [1,2]
示例 2:

输入: nums = [1], k = 1
输出: [1]

提示：

1 <= nums.length <= 105
k 的取值范围是 [1, 数组中不相同的元素的个数]
题目数据保证答案唯一，换句话说，数组中前 k 个高频元素的集合是唯一的

思路：先使用hashmap，存储每一个元素出现的频率。再使用优先级队列，将hashmap中每一项的键值对加入到优先级队列中，并根据出现次数排序降序排列。

class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        Map<Integer,Integer> map = new HashMap<>();
        for(int i=0;i<nums.length;i++){
            map.put(nums[i],map.getOrDefault(nums[i],0)+1);
        }
        PriorityQueue<int[]> queue = new PriorityQueue<>((a,b) -> b[1] - a[1]);
        for(Map.Entry<Integer,Integer> each:map.entrySet()){
            queue.offer(new int[]{each.getKey(),each.getValue()});
        }
        int[] res = new int[k];
        for(int i=0;i<k;i++){
            res[i] = queue.poll()[0];
        }
        return res;
    }
}