【力扣刷题学习笔记06（栈与队列）】

232.用栈实现队列

力扣题目链接(opens new window)

使用栈实现队列的下列操作：

push(x) -- 将一个元素放入队列的尾部。
pop() -- 从队列首部移除元素。
peek() -- 返回队列首部的元素。
empty() -- 返回队列是否为空。

示例:

MyQueue queue = new MyQueue();
queue.push(1);
queue.push(2);
queue.peek();  // 返回 1
queue.pop();   // 返回 1
queue.empty(); // 返回 false

说明:

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

class MyQueue {
    Stack<Integer> stackIn;
    Stack<Integer> stackOut;
    public MyQueue() {
        stackIn = new Stack<>();
        stackOut = new Stack<>();
    }
    //将元素 x 推到队列的末尾
    public void push(int x) {
        stackIn.push(x);
    }
    //从队列的开头移除并返回元素
    public int pop() {
        dumpstackIn();
        return stackOut.pop();
    }
    //返回队列开头的元素
    public int peek() {
        dumpstackIn();
        return stackOut.peek();
    }
    
    public boolean empty() {
        return stackIn.isEmpty() && stackOut.isEmpty();
    }
    //如果stackOut为空，将输入栈中元素全部放入输出栈
    private void dumpstackIn(){
        if(!stackOut.isEmpty())return;
        while(!stackIn.isEmpty()){
            stackOut.push(stackIn.pop());
        }
    }
}

225. 用队列实现栈

力扣题目链接(opens new window)

使用队列实现栈的下列操作：

• push(x) -- 元素 x 入栈
• pop() -- 移除栈顶元素
• top() -- 获取栈顶元素
• empty() -- 返回栈是否为空

注意:

• 你只能使用队列的基本操作-- 也就是 push to back, peek/pop from front, size, 和 is empty 这些操作是合法的。
• 你所使用的语言也许不支持队列。 你可以使用 list 或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。
• 你可以假设所有操作都是有效的（例如, 对一个空的栈不会调用 pop 或者 top 操作）。

class MyStack {
    Queue<Integer> queue;
    public MyStack() {
        queue = new LinkedList<>();
    }
    
    public void push(int x) {
        queue.offer(x);
        int size = queue.size();
        // 将除了最后添加的元素以外的所有元素依次出队再入队
        // 这样新添加的元素就被移动到了队列的前面，模拟栈的LIFO特性
        while (size-- > 1)
            queue.offer(queue.poll());
    }
    
    public int pop() {
        return queue.poll();
    }
    
    public int top() {
        return queue.peek();
    }
    
    public boolean empty() {
        return queue.isEmpty();
    }
}

20. 有效的括号

力扣题目链接(opens new window)

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

有效字符串需满足：

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

示例 1:

• 输入: "()"
• 输出: true

示例 2:

• 输入: "()[]{}"
• 输出: true

示例 3:

• 输入: "(]"
• 输出: false

示例 4:

• 输入: "([)]"
• 输出: false

示例 5:

• 输入: "{[]}"
• 输出: true

class Solution {
    public boolean isValid(String s) {
        Deque<Character> deque = new LinkedList<>();
        char ch;
        for (int i = 0; i<s.length();i++){
            ch = s.charAt(i);
            if(ch == '('){
                deque.push(')');
            }else if (ch == '['){
                deque.push(']');
            }else if (ch == '{'){
                deque.push('}');
            }
            //判断是否为空或者栈头字符不等于ch，如果都不是说明等于ch
            else if (deque.isEmpty() || deque.peek() != ch){
                return false;
            //ch等于栈首字符，pop该字符
            }else{deque.pop();}
        }
        return deque.isEmpty();
    }
}

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

力扣题目链接(opens new window)

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

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

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

示例：

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

提示：

• 1 <= S.length <= 20000
• S 仅由小写英文字母组成。

//使用 Deque 作为堆栈
class Solution {
    public String removeDuplicates(String s) {
        ArrayDeque<Character> deque = new ArrayDeque<>();
        char ch;
        for(int i=0;i<s.length();i++){
            ch = s.charAt(i);
            if(deque.isEmpty() || ch != deque.peek()){
                deque.push(ch);
            }else{deque.pop();}
        }
        String str = "";
        while( !deque.isEmpty() ){
            str = deque.pop() + str;
        }
        return str;
    }
}

//字符串直接作为栈，省去了栈还要转为字符串的操作
class Solution {
    public String removeDuplicates(String s) {
        StringBuffer res = new StringBuffer();
        int top = -1;
        for(int i=0;i<s.length();i++){
            char c = s.charAt(i);
            if(top >= 0 && res.charAt(top) == c){
                res.deleteCharAt(top);
                top--;
            }else{
                res.append(c);
                top++;
            }
        }
        return res.toString();
    }
}

150. 逆波兰表达式求值

力扣题目链接(opens new window)

根据 逆波兰表示法，求表达式的值。

有效的运算符包括 + ,  - ,  * ,  / 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。

说明：

整数除法只保留整数部分。 给定逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。

示例 1：

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

示例 2：

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

示例 3：

• 输入: ["10", "6", "9", "3", "+", "-11", " * ", "/", " * ", "17", "+", "5", "+"]

• 输出: 22

class Solution {
    public int evalRPN(String[] tokens) {
        Deque<Integer> stack = new LinkedList();
        for(String s : tokens) {
            if("+".equals(s))stack.push(stack.pop() + stack.pop());
            else if("-".equals(s))stack.push(-stack.pop() + stack.pop());
            else if("*".equals(s))stack.push(stack.pop() * stack.pop());
            else if("/".equals(s)){
                Integer temp1 = stack.pop();
                Integer temp2 = stack.pop();
                stack.push(temp2/temp1);
            }else stack.push(Integer.valueOf(s));
        }
        return stack.pop();
    }
}

239. 滑动窗口最大值

力扣题目链接(opens new window)

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

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

进阶：

你能在线性时间复杂度内解决此题吗？

提示：

• 1 <= nums.length <= 10^5
• -10^4 <= nums[i] <= 10^4
• 1 <= k <= nums.length

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        if(nums.length == 1){return nums;}
        int len = nums.length - k + 1;
        int[] res = new int[len];
        int index = 0;
        MyQueue myqueue = new MyQueue();
        for(int i=0;i<k;i++){
            myqueue.add(nums[i]);
        }
        res[index++] = myqueue.peek();
        for(int i=k;i<nums.length;i++){
            myqueue.poll(nums[i-k]);
            myqueue.add(nums[i]);
            res[index++] = myqueue.peek();
        }
        return res;
    }
}

//自定义单调递减排列队列
class MyQueue {
    Deque<Integer> deque = new LinkedList<>();
    //弹出元素时比较是否等于头部元素，如果不是说明之前弹出过了，不做任何处理
    void poll(int val){
        if(!deque.isEmpty() && deque.peek()==val) deque.poll();
    }
    //添加元素时，如果要添加的元素大于入口处的元素，就将入口元素弹出
    //保证队列元素单调递减
    void add(int val){
        while(!deque.isEmpty() && val > deque.getLast()) deque.removeLast();
        deque.add(val);
    }
    //队列头部元素始终为最大值
    int peek() {return deque.peek();}
}

347.前 K 个高频元素

力扣题目链接(opens new window)

给定一个非空的整数数组，返回其中出现频率前 k 高的元素。

示例 1:

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

示例 2:

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

提示：

• 你可以假设给定的 k 总是合理的，且 1 ≤ k ≤ 数组中不相同的元素的个数。
• 你的算法的时间复杂度必须优于 $O(n \log n)$ , n 是数组的大小。
• 题目数据保证答案唯一，换句话说，数组中前 k 个高频元素的集合是唯一的。
• 你可以按任意顺序返回答案。

class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        //优先队列：堆通常用来实现优先队列，在大顶堆中可以快速访问和删除最大元素，在小顶堆中可以快速访问和删除最小元素。
        //排序：堆排序利用堆结构进行排序，利用大顶堆可以实现升序排序，利用小顶堆可以实现降序排序
        Map<Integer,Integer> map = new HashMap<>();
        for (int num : nums) {
            map.put(num, map.getOrDefault(num, 0) + 1);
        }
        //定义优先队列（小顶堆）出现次数按从队头到队尾的顺序是从小到大排,出现次数最低的在队头
        PriorityQueue<int[]> pq = new PriorityQueue<>((pair1, pair2) -> pair1[1] - pair2[1]);
        for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
            if(pq.size() < k) { //小顶堆元素个数小于k个时直接加
                pq.add(new int[]{entry.getKey(), entry.getValue()});
            }else {
                if (entry.getValue() > pq.peek()[1]){//当前元素出现次数大于小顶堆的根结点(这k个元素中出现次数最少的那个)
                    pq.poll();//弹出队头(小顶堆的根结点),即把堆里出现次数最少的那个删除,留下的就是出现次数多的了
                    pq.add(new int[]{entry.getKey(), entry.getValue()});
                }
            }
        }
        int[] ans = new int[k];
        for(int i = k-1;i >= 0; i--) {
            //依次弹出小顶堆,先弹出的是堆的根,出现次数少,后面弹出的出现次数多
            ans[i] = pq.poll()[0];
        }
        return ans;
    }
}