LeetCode刷题日记精选例题（解析+代码+链接）

Posted 2021-12-24 温文艾尔

文章目录

• 一、用栈模拟队列
• 二、用队列模拟栈
• 三、有效的括号
• • 解法一
  • 解法二
• 四、删除字符串中所有相邻重复项
• 五、逆波兰表达式求值
• 六、滑动窗口最大值
• 七、前k个高频元素

一、用栈模拟队列

因为队列先进先出，而栈先进后出，所以我们用两个栈，一个输入栈，一个输出栈来模拟队列，当添加数据时，将其加在输入栈，当输出数据时，输出输出栈的数据即可

题目链接

    Stack<Integer> inStack;
    Stack<Integer> outStack;
    public MyQueue() 
        inStack = new Stack<>();
        outStack = new Stack<>();
    

    //进栈
    public void push(int x) 
        inStack.push(x);
    

    //出栈
    public int pop() 
        if (outStack.empty())
            //如果输出栈为空，则将输入栈中的全部元素移到输出栈
            while (!inStack.isEmpty())
                outStack.push(inStack.pop());
            
        
        return outStack.pop();
    

    //返回队列首部元素，不出栈
    public int peek() 
        if (outStack.empty())
            //如果输出栈为空，则将输入栈中的全部元素移到输出栈
            while (!inStack.isEmpty())
                outStack.push(inStack.pop());
            
        
        return outStack.peek();
    

    //返回队列是否为空
    public boolean empty() 
        return inStack.empty()&&outStack.empty();
    

二、用队列模拟栈

题目链接

    Queue<Integer> queue1;
    Queue<Integer> queue2;

    public MyStack() 
        queue1 = new LinkedList<>();
        queue2 = new LinkedList<>();
    

    public void push(int x) 
        queue2.offer(x);
        while (!queue1.isEmpty())
            queue2.offer(queue1.poll());
        
        Queue temp = queue1;
        queue1 = queue2;
        queue2 = temp;
    

    public int pop() 
        return queue1.poll();
    

    public int top() 
        return queue1.peek();
    

    public boolean empty() 
        return queue1.isEmpty();
    

三、有效的括号

经典例题


用栈即可解决
题目链接

解法一

    public static boolean isValid(String s) 
        if (s.length()%2==1)
            return false;
        
        Map<Character,Character> map = new HashMap<>();
        map.put(')','(');
        map.put('','');
        map.put(']','[');
        char[] chars = s.toCharArray();
        Stack stack = new Stack();
        for (char aChar : chars) 
            if (stack.size()>0&&map.containsKey(aChar)&&map.get(aChar).equals(stack.peek()))
                stack.pop();
            else 
                stack.push(aChar);
            
        
        return stack.size()==0;
    

解法二

    public static boolean isValid(String s) 
        char[] chars = s.toCharArray();
        Stack<Character> stack = new Stack();
        for (char aChar : chars) 
            if (aChar=='(')
                stack.push(')');
            else if (aChar=='[')
                stack.push(']');
            else if (aChar=='')
                stack.push('');
            else if (stack.isEmpty()||stack.peek()!=aChar)
                return false;
            else 
                stack.pop();
            
        
        return stack.isEmpty();
    

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

题目链接

思路解析：

和我们平时玩的消消乐的原理差不多，让元素入栈，判断将要入栈的元素与已经入栈的顶层元素是否相同即可

//ArrayDeque会比LinkedList在删除元素这一点外要快 
public static String removeDuplicates2(String s) 
        ArrayDeque<Character> stack  =new ArrayDeque();
        for (int i=s.length()-1;i>=0;i--)
            if (!stack.isEmpty()&&stack.peek()==s.charAt(i))
                stack.pop();
            else 
                stack.push(s.charAt(i));
            
        
        StringBuilder sb = new StringBuilder();
        while (!stack.isEmpty())
            sb.append(stack.pop());
        
        return new String(sb);
    

五、逆波兰表达式求值

这道题可以看我以前写的博文，对逆波兰表达式的介绍与代码实现
一文介绍逆波兰表达式及求值实现

题目链接

逆波兰表达式遵从的原则无非就是，数字入栈，有符号位则弹出栈顶的两个数字进行计算，再将结果入栈

    public static int evalRPN(String[] tokens) 
        Deque<Integer> stack = new LinkedList<>();
        for (String token : tokens) 
            char c = token.charAt(0);
            if (!isOper(token))
                stack.addFirst(Integer.parseInt(token));
            else if (c=='+')
                stack.push(stack.pop()+stack.pop());
            else if (c=='-')
                stack.push(-(stack.pop()-stack.pop()));
             else if (c=='*')
                stack.push(stack.pop()*stack.pop());
            else
                int num1 = stack.pop();
                int num2 = stack.pop();
                stack.push( num2/num1);
            
        
        return stack.pop();
    

    //判断字符是否为符号
    private static   boolean isOper(String s)
        return s.length() == 1 && s.charAt(0) <'0' || s.charAt(0) >'9';
    

六、滑动窗口最大值

题目链接

此题我们需要解决滑动窗口的移动问题，以及如何选出每次移动的最大值，我们可以自定义一个队列，在添加元素时进行操作，使队列保持一种递减趋势，这样每次出队列的元素一定会是本轮中的最大值，每次移动使队首元素出队，下一个数组元素进入队尾

public class MQueue 
    Deque<Integer> deque = new LinkedList();

    //出队列
    public void poll(int value)
        if (!deque.isEmpty()&&value==deque.peek())
            deque.poll();
        
    

    //进队列，保证队列递减
    public void add(int value)
        while (!deque.isEmpty()&&value>deque.getLast())
            deque.removeLast();
        
        deque.add(value);
    

    //展示队列首部元素
    public int peek()
        return deque.peek();
    

class Solution

    public static int[] maxSlidingWindow(int[] nums, int k)
        if (k>nums.length)
            return null;
        
        int[] arr = new int[nums.length-k+1];
        MQueue mQueue = new MQueue();
        int temp=0;
        //加入初始元素
        while (temp<k)
            mQueue.add(nums[temp]);
            temp++;
        
        arr[0]=mQueue.peek();
        for (int i=k;i<nums.length;i++)
            //移除滑动窗口首部元素，判断其是否与数组元素一致，一致则删除，否则不做变化
            mQueue.poll(nums[i-k]);
            //添加新元素
            mQueue.add(nums[i]);
            //队列顶部元素一定为最大值
            arr[i-k+1]=mQueue.peek();
        
        return arr;
    

七、前k个高频元素

题目链接

解题思路：

> 此题我们面临三个问题
> 1. 统计元素出现的频率
> 2. 对频率进行排序
> 3. 找出频率前k高的元素

对于问题1，我们使用map集合实现，问题二我们采用小顶堆，当堆内元素数量大于k时，每次将频率最小的元素弹出堆顶，然后将堆重元素放入数组进行返回

    public static int[] topKFrequent(int[] nums, int k) 
        if (nums.length==k)
            return nums;
        
        int[] arr = new int[k];
        Map<Integer,Integer> map = new HashMap<>();
        for (int num : nums) 
            map.put(num,map.getOrDefault(num,0)+1);
        
        PriorityQueue<Map.Entry<Integer,Integer>> queue = new PriorityQueue<>((v1,v2)->v1.getValue()-v2.getValue());
        Set<Map.Entry<Integer, Integer>> entries = map.entrySet();
        for (Map.Entry<Integer,Integer> entry:entries)
            queue.offer(entry);
            if (queue.size()>k)
                queue.poll();
            
        
        //将堆中元素的前k个元素放到数组中
        for (int i=k-1;i>=0;i--)
            arr[i]=queue.poll().getKey();
        
        return arr;