LeetCode503：下一个更大元素||

题目：

给定一个循环数组 nums （ nums[nums.length - 1] 的下一个元素是 nums[0] ），返回 nums 中每个元素的 下一个更大元素 。

数字 x 的 下一个更大的元素 是按数组遍历顺序，这个数字之后的第一个比它更大的数，这意味着你应该循环地搜索它的下一个更大的数。如果不存在，则输出 -1 。

示例 1:

输入: nums = [1,2,1]
输出: [2,-1,2]
解释: 第一个 1 的下一个更大的数是 2；
数字 2 找不到下一个更大的数； 
第二个 1 的下一个最大的数需要循环搜索，结果也是 2。
示例 2:

输入: nums = [1,2,3,4,3]
输出: [2,3,4,-1,4]
 

提示:

1 <= nums.length <= 10^4
-10^9<= nums[i] <= 10^9

思路：题目的要求就是找到下一个比目标值大的元素，如果是数组中的最大值，则直接返回-1；因为是查找的是一个完整的数组，所以要从目标值的下标分成左右两边，如果在右边找到比目标值大的元素，则直接返回，并且break。如果没有，则在左边查找。

定义完成返回的数组vector，对每个元素进行再一次的数组遍历。

先从左边遍历寻找最大值

for (int j = i + 1; j < nums.size(); j++)
            {
                if (nums[j] > nums[i])
                {
                    path.push_back(nums[j]);
                    break;
                }
                if (nums[j] <= nums[i] && j == nums.size() - 1)
                {
                    res = -1;
                }
            }

如果在右边找到，需要将下标对应的数组值存放在对应的path数组中，否则左边遍历

            if (res == -1 || i == nums.size() - 1)
            {
                for (int k = 0; k < i; k++)
                {
                    if (nums[k] > nums[i])
                    {
                        path.push_back(nums[k]);
                        break;
                    }
                    if (nums[k] <= nums[i] && k == i - 1)
                    {
                        path.push_back(-1);
                    }
                }
                if (res == -1 && i == 0)
                {
                    path.push_back(-1);
                }
            }

左边遍历的条件就是最后一个下标元素（因为没法进行右边遍历，res！= -1）或者res=-1（相当于右边没有找到比目标值大的数）。

还有一种特殊情况就是遍历第一个元素i=0时，没有找到比目标值大的数，res=-1，需要再次将-1存放在对应的path数组中。

这里就有读者会问了，那直接将左边遍历的if（）语句中的

if (nums[k] <= nums[i] && k == i - 1)
                    {
                        path.push_back(-1);
                    }

在右边再添加一个不久不需要i=0的那个条件了嘛。这里是为了预防出现一个下标元素冒出来两个-1的情况。就把所有条件放在了遍历左边数组中了。

还有一种特殊情况就是nums.size()=1时，是直接返回-1的

if (nums.size() == 1)
        {
            path.push_back(-1);
        }

最后直接返回数组path即可。

完整代码：

class Solution
{
public:
    vector<int> nextGreaterElements(vector<int> &nums)
    {
        vector<int> path;
        int res = 0;
        for (int i = 0; i < nums.size(); i++)
        {
            res = 0;
            for (int j = i + 1; j < nums.size(); j++)
            {
                if (nums[j] > nums[i])
                {
                    path.push_back(nums[j]);
                    break;
                }
                if (nums[j] <= nums[i] && j == nums.size() - 1)
                {
                    res = -1;
                }
            }
            if (res == -1 || i == nums.size() - 1)
            {
                for (int k = 0; k < i; k++)
                {
                    if (nums[k] > nums[i])
                    {
                        path.push_back(nums[k]);
                        break;
                    }
                    if (nums[k] <= nums[i] && k == i - 1)
                    {
                        path.push_back(-1);
                    }
                }
                if (res == -1 && i == 0)
                {
                    path.push_back(-1);
                }
            }
        }
        if (nums.size() == 1)
        {
            path.push_back(-1);
        }
        return path;
    }
};

本道题的思路就是这样了！