135、LeetCode-739.每日温度

题目：

给定一个整数数组 temperatures ，表示每天的温度，返回一个数组 answer ，其中 answer[i] 是指对于第 i 天，下一个更高温度出现在几天后。如果气温在这之后都不会升高，请在该位置用 0 来代替。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/daily-temperatures

思路：

遇到和顺序相关的题目，可以想到 单调栈、堆、二分、排序等思路！

栈的相关内容和排序的知识需要再看看！

1)两层for循环的暴力解法，简单的思路；时间复杂度O(N^2)

2)单调栈：常见问题：一维数组中，寻找某个元素左边或者右边第一个更大或者更小的元素！

维护一个栈中元素保持单调的栈：可以是单调递增也可以是单调递减！不允许波动

该题中，遇到stack空，就入栈；遇到更大的时，说明之前的位置可以处理，就直接处理掉，然后入栈；遇到更小的说明不能处理，此时就暂时放入栈中，直到遇到更大的再处理，弹出后会依次处理前面的！

所以本题中，维护的是一个递减的单调栈！

本题中有三种情况：栈为空，直接入栈；栈不空，判断元素，如果小于栈顶元素，直接入栈；如果大于栈顶元素，就需要一系列处理，当小于栈顶元素或者栈为空时，入栈！

代码：

1）暴力解法：O(N^2)

class Solution {
    public int[] dailyTemperatures(int[] temperatures) {
        //想法：按顺序存储数字，并且记录下标
        //暴力解法：时间复杂度o(N^2)
        int len = temperatures.length;
        int[] index = new int[len];
        for(int i = 0;i < len;i++){
            int num = temperatures[i];//拿到当前值
            int flag = 1;//用来记录长度
            for(int j = i + 1;j < len;j++){
                if(temperatures[j] > temperatures[i]){
                    index[i] = flag;
                    break;
                    //continue是跳过后面的继续下次循环；break是挑出本次循环；return是方法返回
                }
                else{
                    flag += 1;
                }
            }
        }
        return index;
    }
}

2）单调栈：O(N)！

class Solution {
    public int[] dailyTemperatures(int[] temperatures) {
        //单调栈，维护一个栈中数组递减的单调栈
        Stack<Integer> stack = new Stack<>();
        int[] res = new int[temperatures.length];//此时初始化都是0
        for(int i = 0;i < temperatures.length;i++){
            if(stack.isEmpty() || temperatures[stack.peek()] >= temperatures[i]){
                //如果栈中为空，或者此时的元素小于栈顶元素，就入栈
                stack.push(i);//只加入下标即可
            }
            else{
                while(!stack.isEmpty() && temperatures[i] > temperatures[stack.peek()]){
                    int j = stack.pop();//栈顶元素，永远都是下一个要更新的位置！其永远是栈里最小的；它更新之后，要继续判断，还能不能继续更新
                    res[j] = i - j;
                }
                //全部更新完成，将此时的内容入栈
                stack.push(i);
            }
        }
        return res;
    }
}

合并处理情况：

class Solution {
    public int[] dailyTemperatures(int[] temperatures) {
        //单调栈，维护一个栈中数组递减的单调栈
        Stack<Integer> stack = new Stack<>();
        int[] res = new int[temperatures.length];//此时初始化都是0
        for(int i = 0;i < temperatures.length;i++){
            //如果栈中有元素，就需要判断：当前元素将里面元素处理好再入栈
            while(!stack.isEmpty() && temperatures[i] > temperatures[stack.peek()]){
                int j = stack.pop();
                res[j] = i - j;
            }
            //此时可能
            stack.push(i);
        }
        return res;
    }
}

3）从后往前的思想：也可以尝试用while替代内层for

class Solution {
    public int[] dailyTemperatures(int[] temperatures) {
      //从后往前的思想
      int len = temperatures.length;
      int[] res = new int[len];//初始都是0
      for(int i = len - 2;i >= 0;i--){
          for(int j = i + 1;j < len;j += res[j]){
              if(temperatures[i] < temperatures[j]){//找到了，最近的更大值
                //更新i
                res[i] = j - i;
                break;//此时的i找完
              }
              else if(res[j] == 0){//此时没找到，说明j处的值小于i，要找距离j处最近的最大值；如果还没找到，继续找下一个j处的最大值;
              //如果res[j]==0，表示后续不存在更大值了，可以直接跳出
                break;
              }
          }
      }
      return res;
    }
}

class Solution {
    public int[] dailyTemperatures(int[] temperatures) {
      //从后往前的思想
      int len = temperatures.length;
      int[] res = new int[len];//初始都是0
      for(int i = len - 2;i >= 0;i--){
          int j = i + 1;
          while(j < len){
              if(temperatures[i] < temperatures[j]){//找到了，最近的更大值
                //更新i
                res[i] = j - i;
                break;//此时的i找完
              }
              else if(res[j] == 0){//此时没找到，说明j处的值小于i，要找距离j处最近的最大值；如果还没找到，继续找下一个j处的最大值;
              //如果res[j]==0，表示后续不存在更大值了，可以直接跳出
                break;
              }
              else{
                  j += res[j];
              }
          }
      }
      return res;
    }
}