leetcode496 503 下一个更大的元素 Ⅰ Ⅱ Ⅲ

leetcode496 下一个更大的元素Ⅰ

给你两个 没有重复元素 的数组 nums1 和 nums2 ，其中nums1 是 nums2 的子集。

请你找出 nums1 中每个元素在 nums2 中的下一个比其大的值。

nums1 中数字 x 的下一个更大元素是指 x 在 nums2 中对应位置的右边的第一个比 x 大的元素。如果不存在，对应位置输出 -1 。

示例 1:

输入: nums1 = [4,1,2], nums2 = [1,3,4,2]. 输出: [-1,3,-1] 解释:
对于 num1 中的数字 4 ，你无法在第二个数组中找到下一个更大的数字，因此输出 -1 。
对于 num1 中的数字 1 ，第二个数组中数字1右边的下一个较大数字是 3 。
对于 num1 中的数字 2 ，第二个数组中没有下一个更大的数字，因此输出 -1 。 示例 2:

输入: nums1 = [2,4], nums2 = [1,2,3,4]. 输出: [3,-1] 解释:
对于 num1 中的数字 2 ，第二个数组中的下一个较大数字是 3 。
对于 num1 中的数字 4 ，第二个数组中没有下一个更大的数字，因此输出 -1 。

示例 2:

输入: nums1 = [2,4], nums2 = [1,2,3,4]. 输出: [3,-1] 解释:
对于 num1 中的数字 2 ，第二个数组中的下一个较大数字是 3 。
对于 num1 中的数字 4 ，第二个数组中没有下一个更大的数字，因此输出 -1 。

思路1

暴力解法
两重循环

class Solution {
    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
        int[] result = new int[nums1.length];
       //Map<Integer,Integer> map = new HashMap<>();
        for(int i = 0;i<nums1.length;i++){
            boolean flag = false;
            for(int j =0;j<nums2.length;j++){
                if(nums1[i] == nums2[j]){
                    flag = true;
                }
                if(flag){
                    if(nums2[j] > nums1[i]){
                        result[i] = nums2[j];
                        break;
                    }
                }
            }
            if(result[i] == 0){
                result[i] = -1;
            }
        }
        return result;
    }
}

思路2

用栈存储还没找到比它大的数字

class Solution {
    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
        int[] result = new int[nums1.length];
        Map<Integer, Integer> map = new HashMap<>();
        Stack<Integer> indexStack = new Stack<>();
        for (int i = 0; i < nums2.length; i++) {
            map.put(nums2[i], -1);
            if (indexStack.empty() || nums2[i] < indexStack.peek()) {
                indexStack.push(nums2[i]);
            }
            while (!indexStack.empty() && nums2[i] > indexStack.peek()) {
                int top = indexStack.pop();
                map.put(top, nums2[i]);
            }
            indexStack.push(nums2[i]);
        }
        for (int i = 0; i < nums1.length; i++) {
            result[i] = map.get(nums1[i]);
        }
        return result;
    }
}

503. 下一个更大元素 II

题目描述：

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

示例 1:

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

暴力

不写了

双重循环

    public static int[] nextGreaterElements(int[] nums) {
        if (nums == null) {
            return null;
        }
        //栈中维护的是index，并且从底向上是严格非升序，可能相等，但是非升序
        Stack<Integer> indexStack = new Stack<>();
        int[] result = new int[nums.length];
        //初始化一次即可
        Arrays.fill(result, -1);
        //循环2次
        for (int i = 0; i < nums.length * 2; i++) {
        	//这里会重复赋值一边已经执行正确的，是为了循环执行
            while (!indexStack.empty() && nums[indexStack.peek()] < nums[i % nums.length]) {
                result[indexStack.pop()] = nums[i % nums.length];
            }
            indexStack.push(i % nums.length);
        }
        return result;
    }

下一个更大元素Ⅲ

思路1：全排序

https://blog.csdn.net/m0_37561165/article/details/118465298
给出全排列链接

思路2：子串反转

1. 先从右往左找到降序的第一个元素i
2. 从i往右找到第一个更大的元素j
3. 替换i和j的位置
4. 反转i+1往右的子串

class Solution {
    public int nextGreaterElement(int n) {
        String str = String.valueOf(n);
        char front = '0';
        int i = str.length() - 1;
        for (; i >= 0; i--) {
            char a = str.charAt(i);
            if (front > a) {
                break;
            }
            front = a;
        }
        if (i == -1) {
            return -1;
        }
        int j = i + 1;
        for (; j < str.length(); j++) {
            if (str.charAt(j) <= str.charAt(i)) {
                break;
            }
        }

        j--;
        str = swap(str, i, j);
        str = reverse(str, i + 1, str.length() - 1);

        try {
            return Integer.valueOf(str);
        } catch (NumberFormatException e) {
            return -1;
        }
    }

    private String swap(String s, int i, int j) {
        return s.substring(0, i) +
                s.charAt(j) +
                (i + 1 < j ? s.substring(i + 1, j) : "") +
                s.charAt(i) +
                (j + 1 < s.length() ? s.substring(j + 1) : "");
    }

    private String reverse(String s, int i, int j) {
        while (i < j) {
            s = swap(s, i++, j--);
        }
        return s;
    }
}