代码随想录Day62

739.每日温度

题目：739. 每日温度 - 力扣（LeetCode）

思路：双指针，一个指针遍历元素，一个指针寻找下一个更大值

尝试（部分AC—47/48—超时）

class Solution {
    public int[] dailyTemperatures(int[] temperatures) {
        int[] answer = new int[temperatures.length];
        for(int i =0; i<temperatures.length; i++){
            for(int j =i; j< temperatures.length; j++){
                if(temperatures[j] > temperatures[i]){
                    answer[i] = j-i;
                    break;
                }
            }
        }
        return answer;
    }
}

答案

class Solution {
    public int[] dailyTemperatures(int[] temperatures) {
        int lens=temperatures.length;
        int[] res=new int[lens];
        Deque<Integer> stack=new LinkedList<>();
        for(int i=0;i<lens;i++){
            while(!stack.isEmpty()&&temperatures[i]>temperatures[stack.peek()]){
                res[stack.peek()]=i-stack.peek();
                stack.pop();
            }
            stack.push(i);
        }
        return  res;
    }
}

小结

1. 注意，栈存放的是下标
2. 保证从栈头到栈底是递增的，遍历元素，逐个判断，当放入元素比栈内元素大时，就弹出
3. result[ deque.peek() ] = i - deque.peek()

 

496.下一个更大元素I

题目：496. 下一个更大元素 I - 力扣（LeetCode）

思路：这个不就是上一道题多加一层for循环？

尝试（AC!）

class Solution {
    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
        int lens1 = nums1.length;
        int lens2 = nums2.length;
        int[] answer = new int[lens1];
        int temp = 0;
        int tempA = 0;
        Deque<Integer> stack = new LinkedList<>();
        for(int i=0; i<lens1; i++){
            for(int j=0; j<lens2; j++){
                if(nums1[i] == nums2[j]){
                    temp = j;
                    tempA = nums2[j];
                    stack.push(j);
                    answer[i] = -1;
                    while(j+1<lens2){
                        if(nums2[j+1]>tempA){
                            answer[i] = nums2[j+1];
                            break;
                        }
                        j++;
                    }
                    j = temp;
                }
            }
        }
        return answer;
    }
}

答案

class Solution {
    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
        HashMap<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums1.length; i++) {
            map.put(nums1[i], i);
        }

        int[] res = new int[nums1.length];
        Stack<Integer> stack = new Stack<>();
        Arrays.fill(res, -1);

        for (int i = 0; i < nums2.length; i++) {
            while (!stack.isEmpty() && nums2[stack.peek()] < nums2[i]) {
                int pre = nums2[stack.pop()];
                if (map.containsKey(pre)) {
                    res[map.get(pre)] = nums2[i];
                }
            }
            stack.push(i);
        }

        return res;
    }
}

小结

stack.push要在while之后，因为要先处理完较小的元素，才能推入元素

503.下一个更大元素II

题目：503. 下一个更大元素 II - 力扣（LeetCode）

思路：循环遍历，每次要遍历到自己的下标，我需要写一个函数，从自己的下标出发，再回到自己的下标，找到比自己大的值

尝试（超时）

class Solution {
    public int[] nextGreaterElements(int[] nums) {
        Stack<Integer> stack = new Stack<>();
        int[] res = new int[nums.length];
        Arrays.fill(res,-1);
        int count =0;
        int temp = 0;
        for(int i=0; i<nums.length; i++){
            temp = i;
            while(count<nums.length){
                while(!stack.isEmpty()&&stack.peek()<nums[i]){
                    res[stack.peek()] = nums[i];
                }
                stack.push(i);
                i++;
                if(i==nums.length) i=0;
                count++;
            }
            count=0;
            i = temp;
        }
        return res;
    }
}

答案

class Solution {
    public int[] nextGreaterElements(int[] nums) {
        //边界判断
        if(nums == null || nums.length <= 1) {
            return new int[]{-1};
        }
        int size = nums.length;
        int[] result = new int[size];//存放结果
        Arrays.fill(result,-1);//默认全部初始化为-1
        Stack<Integer> st= new Stack<>();//栈中存放的是nums中的元素下标
        for(int i = 0; i < 2*size; i++) {
            while(!st.empty() && nums[i % size] > nums[st.peek()]) {
                result[st.peek()] = nums[i % size];//更新result
                st.pop();//弹出栈顶
            }
            st.push(i % size);
        }
        return result;
    }
}

小结

1. 环形比较，用取模的方式，实现成环比较的过程
2. 就是在每日温度的基础代码上，加入了取模的操作