一道经典面试题-寻找全排列的下一个数

一：题目说明

给出一个正整数，找出这个正整数所有数字的全排列的下一个数。简单来说，就是在一个整数所包含的全部组合中，找到一个大于且且仅大于原数的新整数。例子如下：

1. 如果输出12345,则返回12354
2. 如果输入12354，则返回12435
3. 如果输入12435，则返回12453

二：具体说明

<1>解题思路

举一个例子:给出1、2、3、4、5这几个数字。最大的组合:54321最小的组合:12345

例如：给出整数12345，它包含的数字是1、2、3、4、5,如何找到这些数字全排列之后仅大于原数的新整数呢？为了和原数接近，我们需要尽量保持最高位不变，低位在最小的范围内变换顺序

至于变换顺序的范围大小，则取决于当前整数的逆序区域

如图所示,12345的逆序区域是最后两位，仅看这两位数已经是当前的最大组合。若想最接近原数，又比原数更大，必须从倒数第3位开始改变

12345的倒数第3位是3，我们需要从后面的逆序区域中找到大于3的最小数字，让其和3的位置进行互换。

互换后的临时结果是12345，倒数第3位已经确定，这个时候最后两位仍然是逆序状态。我们需要把最后两位转变为顺序状态，以此保证在倒数第3位数值为4的情况下，后两位尽可能小。

<2>基本步骤

第一步，从后向前查看逆序区域，找到逆序区域的前一位，也就是数字置换的边界。

第二步，让逆序区域的前一位和逆序区域中大于它的最小的数字交换位置。

第三步，把原来的逆序区域转为顺序状态。

<3>代码实现

public class GetAllQueue {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};
        // 打印12345之后的10个全排列整数
        for(int i = 0; i < 10; i++) {
            numbers = findNearestNumber(numbers);
            outputNumbers(numbers);
        }
    }

    public static void outputNumbers(int[] numbers) {
        for(int i : numbers) {
            System.out.println(i);
        }
        System.out.println();
    }

    /**
     *
     * @param numbers 整型数组
     * @return 整型数组
     */
    public static int[] findNearestNumber(int[] numbers) {
        // 1.从后向前查看逆序区域，找到逆序区域的前一位，也就是数字置换的边界
        int index = findTransferPoint(numbers);
        // 如果数字置换边界是0，说明整个数组已经逆序，无法得到更大的相同数
        // 字组成的整数，返回null
        if(index == 0) {
            return null;
        }
        // 2.把逆序区域的前一位和逆序取月中刚刚大于它的数字交换位置
        // 复制并入参，避免直接改入参
        int[] numbersCopy = Arrays.copyOf(numbers,numbers.length);
        exchangeHead(numbersCopy, index);
        // 3.把原来的逆序区域转为顺序
        reverse(numbersCopy, index);
        return numbersCopy;
    }

    /**
     *
     * @param numbers 整型数组
     * @return 逆序区域的前一位
     */
   private static int findTransferPoint(int[] numbers) {
          for(int i = numbers.length - 1; i > 0; i--) {
                 if(numbers[i] > numbers[i - 1]) {
                     return i;
                 }
          }
          return 0;
   }

   private static int[] exchangeHead(int[] numbers, int index) {
       int head = numbers[index - 1];
       for(int i = numbers.length - 1; i > 0;i--) {
           if(head < numbers[i]) {
               numbers[index - 1] = numbers[i];
               numbers[i] = head;
               break;
           }
       }
       return numbers;
   }

   public static int[] reverse(int[] num, int index) {
          for(int i = index,j = num.length-1;i<j;i++,j--) {
              int temp = num[i];
              num[i] = num[j];
              num[j] = temp;
          }
          return num;
   }

算法3个步骤每一步的时间复杂度都是O（n）,所以整体的时间复杂度也是O(n)

这种解法叫作：字典序算法。