Next Greater Number

    例子1
    给你⼀个数组 [2,1,2,4,3]，你返回数组 [4,2,4,-1,-1]。
    解释：第⼀个 2 后⾯⽐ 2 ⼤的数是 4; 1 后⾯⽐ 1 ⼤的数是 2；第⼆个 2 后⾯ ⽐ 2 ⼤的数是 4; 4 后⾯没有⽐ 4 ⼤的数，填 -1；3 后⾯没有⽐ 3 ⼤的数，填 -1。

    1. vector<int> nextGreaterElement(vector<int>& nums) { 
    2. vector<int> ans(nums.size()); // 存放答案的数组 
    3. stack<int> s; 
    4. for (int i = nums.size() - 1; i >= 0; i--) { // 倒着往栈⾥放 
    5. while (!s.empty() && s.top() <= nums[i]) { // 判定个⼦⾼矮 
    6. s.pop(); // 矮个起开，反正也被挡着了。。。 
    7. }
    8. ans[i] = s.empty() ? -1 : s.top(); // 这个元素⾝后的第⼀个⾼个 
    9. s.push(nums[i]); // 进队，接受之后的⾝⾼判定吧！ 
    10. }
    11. return ans; 
    12. }

    例子2
    给你⼀个数组 T = [73, 74, 75, 71, 69, 72, 76, 73]，这个数组存放的是近⼏天
    的天⽓⽓温（这⽓温是铁板烧？不是的，这⾥⽤的华⽒度）。你返回⼀个数
    组，计算：对于每⼀天，你还要⾄少等多少天才能等到⼀个更暖和的⽓温；
    如果等不到那⼀天，填 0 。
    举例：给你 T = [73, 74, 75, 71, 69, 72, 76, 73]，你返回 [1, 1, 4, 2, 1, 1, 0, 0]。
    解释：第⼀天 73 华⽒度，第⼆天 74 华⽒度，⽐ 73 ⼤，所以对于第⼀天，
    只要等⼀天就能等到⼀个更暖和的⽓温。后⾯的同理。

    1. vector<int> dailyTemperatures(vector<int>& T) { 
    2. vector<int> ans(T.size()); 
    3. stack<int> s; // 这⾥放元素索引，⽽不是元素 
    4. for (int i = T.size() - 1; i >= 0; i--) { 
    5. while (!s.empty() && T[s.top()] <= T[i]) { 
    6. s.pop(); 
    7. }
    8. ans[i] = s.empty() ? 0 : (s.top() - i); // 得到索引间距 
    9. s.push(i); // 加⼊索引，⽽不是元素 
    10. }
    11. return ans; 
    12. }

    例子3
    假设给你的数组是个环形的，如何处理？
    给你⼀个数组 [2,1,2,4,3]，你返回数组 [4,2,4,-1,4]。

    可以把这个双倍⻓度的数组构造出来，然后套⽤算法模
    板。但是，我们可以不⽤构造新数组，⽽是利⽤循环数组的技巧来模拟

    1. vector<int> nextGreaterElements(vector<int>& nums) { 
    2. int n = nums.size(); 
    3. vector<int> res(n); // 存放结果 
    4. stack<int> s; 
    5. // 假装这个数组⻓度翻倍了 
    6. for (int i = 2 * n - 1; i >= 0; i--) { 
    7. while (!s.empty() && s.top() <= nums[i % n]) 
    8. s.pop(); 
    9. res[i % n] = s.empty() ? -1 : s.top(); 
    10. s.push(nums[i % n]); 
    11. }
    12. return res; 
    13. }