编程题-每日温度（中等）

题目：

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

解法一（暴力）：

重初始位置0依次遍历temperatures中所有元素的值，并通过while找到大于此温度temperautres[i]的温度值temperautres[j]，并记录其位置。此方法利用的双层for循环均与temperatures数组的长度有直接关系，因此当数组很大时，时间复杂度为O(n^2)超限。并没有利用题目中给出的提示信息，温度在30<temperatures[i]<100条件来降低时间复杂度（通过构建next重末尾第一次出现温度高于比较数值的索引位置的数据结构限制约束条件来降低时间复杂度）。

class Solution {
public:
    vector<int> dailyTemperatures(vector<int>& temperatures) {
        vector<int> result;
        int length = temperatures.size();
        //重头遍历temperatures中所有数组，通过while直到找到大于此温度temperatures[i]的值temperatures[j]
        for(int i=0; i<length;i++){
            int l = i+1;
            int r = length-1;
            while(l<=r){
                if(temperatures[l] > temperatures[i]){
                    result.push_back(l-i);
                    break;
                }
                else{
                    l++;
                }
            }
            if(l>r){
                result.push_back(0);
            }
        }
        return result;
    }
};

解法二（暴力-利用提示信息减少重复遍历）：

对于温度列表中的每个元素temperatures[i]，需要找到最小的下标j，使得i<j且temperatures[i]<temperatures[j]。由于温度范围在 [30, 100] 之内，因此可以维护一个数组 next 记录每个温度第一次出现的下标。数组 next 中的元素初始化为无穷大，在遍历温度列表的过程中更新 next 的值。

反向遍历温度列表。对于每个元素 temperatures[i]，在数组 next 中找到从 temperatures[i] + 1 到 100 中每个温度第一次出现的下标，将其中的最小下标记为 warmerIndex，则 warmerIndex 为下一次温度比当天高的下标。如果 warmerIndex 不为无穷大，则 warmerIndex - i 即为下一次温度比当天高的等待天数，最后令 next[temperatures[i]] = i。

为什么上述做法可以保证正确呢？因为遍历温度列表的方向是反向，当遍历到元素 temperatures[i] 时，只有 temperatures[i] 后面的元素被访问过，即对于任意 t，当 next[t] 不为无穷大时，一定存在 j 使得 temperatures[j] == t 且 i < j。又由于遍历到温度列表中的每个元素时都会更新数组 next 中的对应温度的元素值，因此对于任意 t，当 next[t] 不为无穷大时，令 j = next[t]，则 j 是满足 temperatures[j] == t 且 i < j 的最小下标。如下为实现代码：

class Solution {
public:
    vector<int> dailyTemperatures(vector<int>& temperatures) {
        int n = temperatures.size();
        //定义ans返回结果
        //next（101数组长度，INT_MAX初始化大小）表示每个温度第一次出现的下标
        vector<int> ans(n), next(101, INT_MAX);
        for (int i = n - 1; i >= 0; --i){
            int warmerIndex = INT_MAX;
            //找到大于此温度temperatures[i]的并且最近一次出现的最小的下标
            for (int t = temperatures[i] + 1; t <= 100; ++t) {
                warmerIndex = min(warmerIndex, next[t]);
            }
            if (warmerIndex != INT_MAX) {
                ans[i] = warmerIndex - i;
            }
            next[temperatures[i]] = i;
        }
        return ans;
    }
};

时间复杂度：O(nm)，其中 n 是温度列表的长度，m 是数组 next 的长度，在本题中温度不超过 100，所以 m 的值为 100。反向遍历温度列表一遍，对于温度列表中的每个值，都要遍历数组 next 一遍。空间复杂度：O(m)，其中 m 是数组 next 的长度。除了返回值以外，需要维护长度为 m 的数组 next 记录每个温度第一次出现的下标位置。

解法三（单调栈）：

可以维护一个存储下标的单调栈，从栈底到栈顶的下标表示列表中的温度依次递减。如果一个下标在单调栈里，则表示尚未找到下一次温度更高的下标。

正向遍历温度列表。对于温度列表中的每个元素temperatures[i]，如果栈为空，则直接将i进栈，如果栈不为空，则比较栈顶元素prevIndex对应的温度temperatures[preIndex]和当前温度temperatures[i]，如果temperatures[i]>temperatures[prevIndex]，则将prevIndex移除，并将prevIndex对应的等待天数赋值为i-prevIndex，重复上述操作直到栈为空或者栈顶元素对应的温度小于等于当前温度，然后将i进栈。

为什么可以在弹栈的时候更新ans[preIndex]呢？因为在这种情况下，即将进展的i对应的temperatures[i]一定是temperatures[prevIndex]右边第一个比它大的元素，试想如果prevIndex和i有比它大的元素，假设下标为j，那么prevIndex一定会在下标j的那一轮被弹掉。

由于单调栈满足从栈底到栈顶元素对应的温度递减，因此每次有元素进栈时，会将温度更低的元素全部移除，并更新出栈元素对应的等待天数，这样可以确保等待天数一定是最小的。如下为实现代码：

class Solution {
public:
    vector<int> dailyTemperatures(vector<int>& temperatures) {
        int n = temperatures.size();
        //记录返回值ans
        vector<int> ans(n);
        stack<int> s;
        //依次重头遍历temperatures中所有元素，剔除栈顶中不满足要求的元素并将对ans进行赋值
        //栈s为不为空并且temperatures[i]大于栈顶元素时，将temperatures[i]元素入栈
        for (int i = 0; i < n; ++i) {
            while (!s.empty() && temperatures[i] > temperatures[s.top()]) {
                int previousIndex = s.top();
                ans[previousIndex] = i - previousIndex;
                s.pop();
            }
            s.push(i);
        }
        return ans;
    }
};

时间复杂度：O(n)，其中 n 是温度列表的长度。正向遍历温度列表一遍，对于温度列表中的每个下标，最多有一次进栈和出栈的操作。空间复杂度：O(n)，其中 n 是温度列表的长度。需要维护一个单调栈存储温度列表中的下标。

笔者小记：

1、题目提示信息的利用（常数项的for循环可降低时间复杂度）：利用题目给定的一些提示信息，可以创建常数量的数组（数据结构），减少时间复杂度O(n^2)的产生降为O(n*k)，其中k为常数。在本题中，没有利用提示信息需要将数组中后续所有温度值都需要进行一次遍历（会使得温度相同时，重复遍历的情况，使时间复杂度升高）。当利用提示信息后，仅需要遍历访问，温度在范围内并且大于此值的数组元素（常数个时间复杂度的次数），记录最近一次出现过温度大于此数值的项，防止在temperatures数组中相同温度的重复访问。将原有temperatures数组中许多重复冗余元素信息，通过创建一个常数项数组（数据结构）将temperatures数组中有效信息进行提取与整合，从而减少时间复杂度，实现问题的有效解决。

2、单调栈的利用：单调栈是一种特殊的栈，通常用于解决一些涉及序列元素比较的问题，如寻找下一个更大或者更小的元素。它具有一个特殊的性质：栈中的元素保持单调顺序。单调栈可以是单调递增栈或单调递减栈。单调栈在许多常见的算法题中非常有用，尤其是处理与数组或序列相关的问题时，通过利用栈的特点可以有效地优化时间复杂度。