Leetcode 556. Next Greater Element III

最新推荐文章于 2022-07-03 00:26:59 发布

原创最新推荐文章于 2022-07-03 00:26:59 发布 · 602 阅读

0 ·

CC 4.0 BY-SA版权

Leetcode 专栏收录该内容

83 篇文章

订阅专栏

本文介绍了一个算法，用于找出比给定32位正整数更大的最小整数，且该整数包含与原数相同的数字组合。若不存在这样的整数，则返回-1。文章通过实例详细解释了算法的步骤。

Given a positive 32-bit integer n, you need to find the smallest 32-bit integer which has exactly the same digits existing in the integer nand is greater in value than n. If no such positive 32-bit integer exists, you need to return -1.

Example 1:

Input: 12
Output: 21

Example 2:

Input: 21
Output: -1

index: 012345
given: 124651
ans : 125146
procedure:
Starting from the rightmost digit, going to left. Find the first digit which is smaller than the previous digit.
In this example, 4 is smaller than 6. Remember 4 and its index 2.
Going from rightmost again. This time, find the first digit which is bigger than 4. It is 5 here.
Swap 4 and 5. The number becomes 125641.
Reverse all the digits which are right to 4's original index (That is 2), 641 should be reversed to 146 here.
And the answer is reached which is 125146.

    public int nextGreaterElement(int n) {
        char[] a = String.valueOf(n).toCharArray();
        int i = a.length - 2;
        while (i >= 0 && a[i + 1] <= a[i]) {
            i--;
        }
        if(i < 0) return -1;
        int j = a.length - 1;
        while (j >= 0 && a[j] <= a[i]) {
            j--;
        }
        swap(a, i, j);
        reverse(a, i + 1);
        try{
           return Integer.parseInt(new String(a));
        }
        catch(Exception e){
           return -1;
        }
    }
    private void reverse(char[] a, int start) {
        int i = start, j = a.length - 1;
        while (i < j) {
            swap(a, i, j);
            i++;
            j--;
        }
    }
    private void swap(char[] a, int i, int j) {
        char temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }