next greater element 系列

496. Next Greater Element I

给定两个数组nums1和nums2，nums1是nums2的子集，返回一个数组，这个数组对应nums1中每个数在nums2中按顺序的下一个比他大的值

Input: nums1 = [4,1,2], nums2 = [1,3,4,2].
Output: [-1,3,-1]

Input: nums1 = [2,4], nums2 = [1,2,3,4].
Output: [3,-1]

两个数组都没有重复的数。

思路：首先将nums2的所有数即下一个大树写到map中去。这里采用的是栈结构，如果栈为空或者是递减的，就把元素写入栈，如果当前元素大于栈顶，就持续的出栈写入map，直到不大于栈顶元素。最后栈中可能还有一些数，这些数不做处理。最后的结果是存在下一个最大元素的数都写入到map中了。其他数没有。

然后遍历第一个数组，在map中寻找。找不到就是-1，找到了就是相应键对应的值。

代码如下：

class Solution {
public:
    vector<int> nextGreaterElement(vector<int>& findNums, vector<int>& nums) {
        map<int,int> inp;
        vector<int> res;
        int n=nums.size();
        stack<int> q;
        for(auto s:nums)
        {
            while(!q.empty()&&q.top()<s)
            {
                inp[q.top()]=s;
                q.pop();
            }
            q.push(s);
        }
        for(auto s:findNums)
        {
            if(inp.find(s)!=inp.end())
                res.push_back(inp[s]);
            else
                res.push_back(-1);
        }
        return res;
    }
};

503. Next Greater Element II

这道题将nums2改成了环状数组，只输入一个数组，而且数组中可能出现重复的数。

我的：思路。第一次循环，元素入栈，第二次循环，元素不入栈，而且，放入map的键不是具体的数，而是元素的下标与他对应的下一个最大数。入栈的也不是具体的数，而是元素的位置。

class Solution {
public:
    vector<int> nextGreaterElements(vector<int>& nums) {
        //仿照第一个题的方法，首先循环一次，栈要把所有的待选元素放入
        //然后再循环一次，这一次不再把元素放进去
        map<int,int> inp;
        vector<int> res;
        int n=nums.size();
        stack<int> q;
        for(int i=0;i<n;i++)
        {
            while(!q.empty()&&nums[q.top()]<nums[i])
            {
                inp[q.top()]=nums[i];
                q.pop();
            }
            q.push(i);
        }
        if(!q.empty())
        {
            for(int i=0;i<n;i++)
            {
                while(!q.empty()&&nums[q.top()]<nums[i])
            {
                inp[q.top()]=nums[i];
                q.pop();
            }
                //这一次不再把元素放入栈中
            }
        }
        for(int i=0;i<n;i++)
        {
            if(inp.count(i))
                res.push_back(inp[i]);
            else
                res.push_back(-1);
        }
        return res;
    }
};

上述解法的改进版本：

可以不使用map，预先设定res数组的初始值是-1，每次找到一个最大值就更新res中相应的位置。这里使用了取模运算。

class Solution {
public:
    vector<int> nextGreaterElements(vector<int>& nums) {
        int n = nums.size();
        vector<int> res(n, -1);//初始化全部是-1
        stack<int> st;
        for (int i = 0; i < 2 * n; ++i) {//循环2倍
            int num = nums[i % n];//使用取模运算找到当i大于n时的对应位置
            while (!st.empty() && nums[st.top()] < num) {
                res[st.top()] = num; st.pop();//找到当前下标的下一个最大值就更新res
            }
            if (i < n) st.push(i);
        }
        return res;
    }
};

leetcode提供的解法：

（1）暴力递归

首先将原数组复制一份，然后从第一个数开始，针对每个数往后遍历找到第一个大于他的数。时间复杂度 n方

public class Solution {

    public int[] nextGreaterElements(int[] nums) {
        int[] res = new int[nums.length];
        int[] doublenums = new int[nums.length * 2];
        System.arraycopy(nums, 0, doublenums, 0, nums.length);
        System.arraycopy(nums, 0, doublenums, nums.length, nums.length);
        for (int i = 0; i < nums.length; i++) {
            res[i]=-1;
            for (int j = i + 1; j < doublenums.length; j++) {
                if (doublenums[j] > doublenums[i]) {
                    res[i] = doublenums[j];
                    break;
                }
            }
        }
        return res;
    }
}

（2）暴力递归更新版本，上述方法有无用功，因为每一个数的下一个大于他的数是在除去他之后的后面n-1个数中寻找的。所以第二层循环最多只需遍历n-1个数。

而且不需要将原来的数组扩大，通过使用模运算就可定位到大于数组长度的位置折返到环状前的数，这个和循环队列是一样的道理。

时间复杂度n方，空间复杂度n

public class Solution {
    public int[] nextGreaterElements(int[] nums) {
        int[] res = new int[nums.length];
        for (int i = 0; i < nums.length; i++) {
            res[i] = -1;
            for (int j = 1; j < nums.length; j++) {
                if (nums[(i + j) % nums.length] > nums[i]) {//通过使用取模运算，将大于数组长度的值折返到前面的位置
                    res[i] = nums[(i + j) % nums.length];
                    break;
                }
            }
        }
        return res;
    }
}

（3）使用栈的方法 比较难理解

https://leetcode.com/problems/next-greater-element-ii/solution/

556. Next Greater Element III

给定一个32位的数，找到一个数和这个数的各位数字相同，只是顺序不一样，这个数是第一个大于原来数的那个，如果不存在，就返回-1

这个题和next permutation思路完全一样  http://blog.csdn.net/m0_37693059/article/details/76304045#t1

需要注意溢出问题

class Solution {
public:
    int nextGreaterElement(int m) {
        string nums=to_string(m);
        int n=nums.size();
        if(n<=1) return -1;
        int left=n-1;
        int right=n-1;
        int posMin=n-1;
        while(left>0&&nums[left]<=nums[left-1])
        {
         left--;
        }
        if(left==0)//如果当前数是最大数
        {
            return -1;
        }
        while(nums[right]<=nums[left-1])
            right--;
        swap(nums[right],nums[left-1]);
        doReverse(nums,left,n-1);
        long long res=stoll(nums);
        return res>numeric_limits<int>::max()?-1:res;   //有可能超过32位数
    }
    void doReverse(string& nums,int left,int right){
        while(left<right)
        {
            int temp=nums[left];
            nums[left++]=nums[right];
            nums[right--]=temp;
        }
    }
};