有关队列、栈练习题整理

不是最优解，基于自己能够理解的解法写，主要记录第一次刷力扣自己或者学习别人的答题思路

 一、最近的请求次数

解题思路：这个题整体不难，难的是阅读理解！简单来说，在某个时间段内的请求次数，

而某个请求所在的时间段是t-3000,t，所以只要判断之前的请求是否在当前请求的时间范围段即可

使用队列，每次进行出队判断，即队列中的数在当前请求范围内即可，最后返回队列个数

class RecentCounter {
        Queue<Integer> queue;
        public RecentCounter() {
            queue = new LinkedList<>();
        }

        public int ping(int t) {
            queue.add(t);
            while(queue.peek() < t-3000){
                queue.poll();
            }
            return queue.size();
        }
}

二、有效的括号

 

解题思路:使用栈，左括号全部入栈，遇到右括号时，判断栈顶的左括号是否能匹配，如果可以即出栈，直到循环完毕即可

三种括号在ascii编码里都是和右括号差1或2

    public static boolean isValid(String s) {
        if (s.length() % 2 != 0) {
            return false;
        }
        //设置一个栈  左括号入栈 右括号出栈找对应的
        Stack<Character> stack = new Stack<>();
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (c == '{' || c == '(' || c == '[') {
                stack.push(c);
                continue;
            } else {
                if (stack.isEmpty()) {
                    return false;
                }
                Character peek = stack.peek();
                //栈顶的元素如果不匹配则直接返回false
                if (peek == c - 1 || peek == c - 2) {
                    stack.pop();
                    continue;
                } else {
                    return false;
                }
            }
        }
        return stack.isEmpty(); //如果栈中还有剩余肯定也是不匹配
    }

 三、最小栈

 解题思路:随着出栈，最小值是变化的，所以设置两个栈，最小栈记录入栈时数据对应的最小值

class MinStack {
        Stack<Integer> stack;
        Stack<Integer> minStack;
        int min = 0 ;

        public MinStack() {
            stack = new Stack<>();
            minStack = new Stack<>();
        }

        public void push(int val) {
            if(stack.isEmpty()){
                min = val;
            }
            stack.push(val);
            min = Math.min(min,val);
            minStack.push(min);
        }

        public void pop() {
            minStack.pop();
            stack.pop();
            if(!minStack.isEmpty()){
                min = minStack.peek(); //出栈的时候最小值指针也应该变成最小栈的栈顶数
            }
        }

        public int top() {
            return stack.peek();
        }

        public int getMin() {
            return minStack.peek();
        }
}

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

解题思路：跟括号那个题差不多，用栈来确定是否有相邻字母，本来用LInkedList做栈，结果提交打败5%，看了下题解，居然还有用StringBuffer做栈这种操作，小丑竟是我自己.jpg

class Solution {
    public String removeDuplicates(String s) {
        StringBuffer stack2 = new StringBuffer();
        int last = -1;
        for(int i = 0 ; i < s.length() ; i++){
            char ch = s.charAt(i);
            if(last >= 0  && stack2.charAt(last) == ch){
                stack2.deleteCharAt(last);
                last--;
                continue;
            }

           stack2.append(ch);
           last++;
        }
        return stack2.toString();
    }
}