[leetcode]Next Greater Element

第一题：寻找子集合中每个元素在原集合中右边第一个比它大的数。

想到了用哈希表存这个数的位置，但是没有想到可以直接用哈希表存next great，用栈存还没找到的数，没遍历一个数就考察栈中的元素小，小的话，这个数就是栈中数的next great，栈中的数肯定是下大上小。

public int[] nextGreaterElement(int[] nums1, int[] nums2) {
         /*
        通过map建立当前元素和其next great的映射
        在建立映射时，用栈记录还没有映射（就是还没有找到next great）的数，每新遍历一个数，就考察栈顶元素能不能映射，能就
        建立映射，弹出栈顶，并继续考察新栈顶。不能建立后，压入该数。
        一开始不明白，会不会有下边小，上边大的情况，如果有这种情况的话，下边的数是建立不了映射的，但是想了想是不可能出现的，
        因为每当有大的数的时候，小的会被弹出，大的会压入，所以栈顶是最小的数。
         */
        Stack<Integer> st = new Stack<>();
        Map<Integer,Integer> map = new HashMap<>();
        int[] res = new int[nums1.length];
        for (int num :
                nums2) {
            while (!st.isEmpty() && st.peek() < num)
            {
                map.put(st.peek(),num);
                st.pop();
            }
            st.push(num);
        }
        for (int i = 0; i < res.length; i++) {
            res[i] = map.getOrDefault(nums1[i],-1);
        }
        return res;
    }

第二题：和第一题的不同点是这次是求一个循环数列中各个元素的next，而且可能有重复

循环的解决方法是遍历两轮，每次下标对n取余，这样两轮的下标就相同了

重复的解决方法是stack记录下标，而不是记录数据，每次有了next，直接存到res的相应位置

最后的res就相当于一个哈希表

public int[] nextGreaterElements2(int[] nums) {
        /*
        相对第一题的改变时数组成了循环数组，遍历到最后一个数之后可以再从第一个数开始
        自己想的方案是暴力解，两层for
        看了答案，这种循环数组遍历，下标的问题是用取余的方法，第二遍第1个数，相当于n+1个数，n+1%n = 1,正好是第一个数
        以后遇上循环数组，就遍历两倍长度，%n取余后，两次遍历的下标就一样了
         */
        int l = nums.length;
        int[] res = new int[l];
        //有的找不到，直接初始化数组为-1
        Arrays.fill(res,-1);
        Stack<Integer> st = new Stack<>();
        //循环数组，遍历两倍长度的数组，每次都取余，这样每个元素都可以把它前后的元素都遍历到，对于第二轮遍历下标不对应的解决方法是
        //取余，对n取余，下表就对应了。时间复杂度O（2n）
        //还要考虑这次有重复，所以不能记录数，要记录下标
        for (int i = 0; i < 2*l; i++) {
            int num = nums[i%l];
            while (!st.isEmpty() && nums[st.peek()] < num)
            {
                res[st.peek()] = num;
                st.pop();
            }
            //只在第一轮遍历时记录下标
            if (i<l) st.push(i);
        }
        return res;
    }

第三题：找全排列的下一个数，之前做过，但是没做出来，f**k

public int nextGreaterElement3(int n) {
        /*
        没做出来
        策略是:如果从第K为到末尾是递减的，且第k位大于第K-1位（也就是递减序列最高位是k），那么就倒序排列递减序列，并且找到
        比k-1为大的那个最小数，交换位置
        之前做过一个题，找全排列的下一个数，和这个一模一样
         */
        String str = n+"";
        int l = str.length();
        if (l == 1)
            return -1;
        //注意这里k的初始值不是0，是l-1。因为是倒着开始判断，如果没有判断到则k不会改变，递减数列应该是从l-1开始，也就是最后一个数
        int k = l-1;
        //处理成数列好操作，StringBuilder也可以
        char[] ch = str.toCharArray();
        //找到递减数列开始的地方
        for (int i = l-2; i >=0; i--) {
            if (ch[i] < ch[i+1])
            {
                k = i+1;
                break;
            }
        }
        //翻转递减数列，这里也可以转为字符串用string自带的翻转
        for (int i = k; i < k+(l-k)/2; i++) {
            char temp = ch[i];
            ch[i] = ch[l-1-(i-k)];
            ch[l-1-(i-k)] = temp;
        }
        //更换位置
        for (int i = k; i < l; i++) {
            if (ch[i] > ch[k-1])
            {
                char temp = ch[i];
                ch[i] = ch[k-1];
                ch[k-1] = temp;
                break;
            }
        }
        String res = new String(ch);
        //判断是不是超过了int最大值
        Long a = Long.parseLong(res);
        if (a >Integer.MAX_VALUE)
            return -1;
        int b = Integer.parseInt(res);
        //如果数没有改变说明这个数是全排列中最大的数，没有下一个，输出-1，要判断一下
        if (b == n)
            return -1;
        return b;
    }