496. Next Greater Element I + 503. Next Greater Element II + 556. Next Greater Element III

▶ 给定一个数组与它的一个子列，对于数组中的一个元素，定义它右边第一个比他大的元素称为他的后继，求所给子列的后继构成的数组

▶ 第 496 题，规定数组最后一个元素即数组最大元素的后继均为 -1

● 自己的版本，12 ms，最快的解法算法与之相同

class Solution
{
public:
    vector<int> nextGreaterElement(vector<int>& findNums, vector<int>& nums)
    {        
        const int m = findNums.size(), n = nums.size();
        int i, j;
        unordered_map<int, int> table;
        vector<int> output;
        for (i = 0; i < n; table[nums[i]] = i, i++);
        for (i = 0; i < m; i++)
        {
            if (findNums[i] == nums[n - 1])
            {
                output.push_back(-1);
                continue;
            }
            for (j = table[findNums[i]] + 1; j < n && nums[j] < findNums[i]; j++);
            if (j == n)
                output.push_back(-1);
            else
                output.push_back(nums[j]);
        }
        return output;
    }
};

▶ 第 503 题，数组换成环状，只有数组最大元素的后继为 -1

● 自己的代码，124 ms，添加一个标记 mark 的线性搜索方法

class Solution
{
public:
    vector<int> nextGreaterElements(vector<int>& nums)
    {
        const int n = nums.size();
        int i, mark;
        vector<int> output(n, -1);
        for (mark = 0; mark < n - 1 && nums[mark] <= nums[n - 1]; mark++);
        if (mark < n - 1)   // 找到了某个位置，标记上，若 mark == n - 1，说明 nums[n - 1] 就是最大的
            output[n - 1] = nums[mark];
        for (i = n - 2; i >= 0; i--)
        {
            if (nums[i] < nums[i + 1])
            {
                output[i] = nums[i + 1];
                mark = i + 1;
            }
            else
            {
                for (; mark != i && nums[mark] <= nums[i]; mark = (mark + 1) % n);
                if (mark != i)
                    output[i] = nums[mark];
            }
        }        
        return output;
    }
};

● 大佬的代码，111 ms

class Solution
{
public:
    vector<int> nextGreaterElements(vector<int>& nums)
    {
        const int n = nums.size();
        int i, num, ind;
        stack<int> st;             // 栈维护 num 的单调递减的子列的下标，遇到较大的当前值的时候出栈，出到元素值大于当前值为止
        vector<int> result(n, -1);
        for (i = 0; i < 2 * n; i++)// 扫描两趟，确保末尾的元素找到后继
        {
            for (num = nums[i % n]; !st.empty() && num > nums[st.top()]; ind = st.top(), st.pop(), result[ind] = num);
                // 若 num 较大，则把栈中的较小元素都指向 num
            st.push(i % n); // 空栈，或者剩余部分的值大于当前值，将当前值压栈
        }
        return result;
    }
};

● 大佬的代码，103 ms，两步走战略

class Solution
{
public:
    vector<int> nextGreaterElements(vector<int> nums)
    {
        const int n = nums.size();
        if(n==0)
            return vector<int>();
        vector<int> res(n);
        int i, maxValue, index, real; 
        for (maxValue = nums[0], i = index = 0; i < n; i++)// 第一轮，将两种情况的第 k 元素进行标记：
        {                                                  // ① nums[ k ] < nums[ k + 1 ]
            if (nums[i] > maxValue)                        // ② nums[ k ] >= nums[ k + 1 ] ... nums[ k + m ] 且 nums[ k ] < nums[ k + m ]
            {                                              // 注意第一轮结束时 index 等于数组最大元素的下标
                res[i - 1] = i;
                res[index] = i;
                maxValue = nums[i];
                index = i;
            }
        }        
        for (res[index] = -1, i = index - 1; i > index - n; i--)// 将数组最大元素的输出值置 -1，从最大元素开始向左遍历数组
        {
            real = (i + n) % n;
            if (res[real] != 0)
                continue;
            res[real] = (real == n - 1 ? 0 : real + 1);// 让该元素的输出值初始化为它右边那个元素
            for (; res[real] != -1 && nums[real] >= nums[res[real]]; res[real] = res[res[real]]);// 寻找该元素的真实输出值
        }
        for (i = 0; i < n; i++)// 将下标置换回元素的值
        {
            if (res[i] != -1)
                res[i] = nums[res[i]];
        }
        return res;
    }
};

● 其他方法，枚举，时间复杂度 O(n²)