DAY25-力扣刷题

1.逆波兰表达式求值

方法一：栈

150. 逆波兰表达式求值 - 力扣（LeetCode）

class Solution {
    public int evalRPN(String[] tokens) {
        Stack<Integer> stack=new Stack<>();
        for(String s:tokens){
            if(!isOpera(s)){
                //数字：放入栈当中
                stack.push(Integer.parseInt(s));//将字符串转成整数
            }
            else{
                //弹出栈顶的两个元素
                int num2=stack.pop();
                int num1=stack.pop();
                switch(s){
                    case "+":
                        stack.push(num1+num2);
                        break;
                    case "-":
                        stack.push(num1-num2);
                        break;
                    case "*":
                        stack.push(num1*num2);
                        break;
                    case "/":
                        stack.push(num1/num2);
                        break;
                }
            }
            
        }
        return stack.pop();
    }


    public boolean isOpera(String s){
        if(s.equals("+")||s.equals("-")||s.equals("*")||s.equals("/")){
            return true;
        }
        return false;
    }
}

2.反转字符串中的单词

5分钟了解一下，String.trim()到底做了什么事_stringtrim()在当前字符串首尾加空格-CSDN博客

split()函数与正则表达式：‘\s+‘_正则表达式:s+-CSDN博客

非常好用的正则表达式"\\s+"_正则 s+-CSDN博客

方法一：使用语言特性

class Solution {
    public String reverseWords(String s) {
        //除去开头和末尾的空白字符
        s=s.trim();
        // 正则匹配连续的空白字符作为分隔符分割
        List<String> wordList = Arrays.asList(s.split("\\s+"));
        Collections.reverse(wordList);
        return String.join(" ", wordList);
    }
}

方法二：双端队列

class Solution {
    public String reverseWords(String s) {
        int left = 0, right = s.length() - 1;
        // 去掉字符串开头的空白字符
        while (left <= right && s.charAt(left) == ' ') {
            ++left;
        }

        // 去掉字符串末尾的空白字符
        while (left <= right && s.charAt(right) == ' ') {
            --right;
        }

        Deque<String> d = new ArrayDeque<String>();
        StringBuilder word = new StringBuilder();
        
        while (left <= right) {
            char c = s.charAt(left);
            if ((word.length() != 0) && (c == ' ')) {
                // 将单词 push 到队列的头部
                d.offerFirst(word.toString());
                word.setLength(0);
            } else if (c != ' ') {
                word.append(c);
            }
            ++left;
        }
        d.offerFirst(word.toString());

        return String.join(" ", d);
    }
}

3.乘积最大子数组

给你一个整数数组 nums ，请你找出数组中乘积最大的非空连续子数组（该子数组中至少包含一个数字），并返回该子数组所对应的乘积。

测试用例的答案是一个 32-位 整数。

 方法一：动态规划

class Solution {
    public int maxProduct(int[] nums) {
        int maxF = nums[0], minF = nums[0], ans = nums[0];
        int length = nums.length;
        for (int i = 1; i < length; ++i) {
            int mx = maxF, mn = minF;
            maxF = Math.max(mx * nums[i], Math.max(nums[i], mn * nums[i]));
            minF = Math.min(mn * nums[i], Math.min(nums[i], mx * nums[i]));
            ans = Math.max(maxF, ans);
        }
        return ans;
    }
}

无法通过！！！

import java.math.BigInteger;

class Solution {
    public int maxProduct(int[] nums) {
        int n = nums.length;
        BigInteger[] maxCj = new BigInteger[n];
        BigInteger[] minCj = new BigInteger[n];
        maxCj[0] = BigInteger.valueOf(nums[0]);
        minCj[0] = BigInteger.valueOf(nums[0]);
        for (int i = 1; i < n; i++) {
            BigInteger numI = BigInteger.valueOf(nums[i]);
            BigInteger curMaxCj = numI.multiply(maxCj[i - 1]);
            BigInteger curMinCj = numI.multiply(minCj[i - 1]);
            maxCj[i] = numI.max(curMaxCj.max(curMinCj));
            minCj[i] = numI.min(curMaxCj.min(curMinCj));
        }
        BigInteger ans = BigInteger.valueOf(nums[0]);
        for (int i = 1; i < n; i++) {
            ans = ans.max(maxCj[i]);
        }
        return ans.intValue();
    }
}

4.寻找旋转排序数组中的最小值

153. 寻找旋转排序数组中的最小值 - 力扣（LeetCode）

方法一：二分查找

class Solution {
    public int findMin(int[] nums) {
        int low = 0;
        int high = nums.length - 1;
        while (low < high) {
            int pivot = low + (high - low) / 2;
            if (nums[pivot] < nums[high]) {
                high = pivot;
            } else {
                low = pivot + 1;
            }
        }
        return nums[low];
    }
}

5.最小栈

155. 最小栈 - 力扣（LeetCode）

import java.util.Stack;

class MinStack {
    private Stack<Integer> stack ;
    private Stack<Integer> minStack ;
    public MinStack() {
        stack = new Stack<>();
        minStack = new Stack<>();
    }
    
    public void push(int val) {
        stack.push(val);
        //第一次在最小栈当中存储元素
        if(minStack.empty()) {
            minStack.push(val);
        }else {
            if(val <= minStack.peek()) {
                minStack.push(val);
            }
        }
    }
    
    public void pop() {
        //栈为空 则不能进行弹出元素
        if(stack.empty()) {
            return;
        }
        int val = stack.pop();
        if(val == minStack.peek()) {
            minStack.pop();
        }
    }
    //获取栈顶元素 和 最小栈没有关系
    public int top() {
        if(stack.empty()) {
            return -1;
        }
        return stack.peek();
    }

    //获取元素 不是删除元素
    public int getMin() {
        return minStack.peek();
    }
    
}