用Java实现给a[n]数组进行全排序，找到一个组合的前一个组合，比如a[3]{[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2], [3,2,1]}，给出[2,3,1,]，找到他的前序是[2,1,3]

可以使用字典序算法来解决这个问题。具体步骤如下：

1. 从右往左找到第一个比后面数字小的数，记为 a[i]。

2. 在 a[i+1] 到 a[n-1] 中找到比 a[i] 大的数中最小的一个，记为 a[j]。

3. 交换 a[i] 和 a[j]。

4. 将 a[i+1] 到 a[n-1] 排序，使其从小到大排列。

例如，对于数组 [1, 2, 3]，其全排列为 [1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]。

要找到 [2, 3, 1] 的前一个排列，按照上述步骤进行操作：

1. 找到比后面数字小的数，即 2。

2. 在 [3, 1] 中找到比 2 大的数中最小的一个，即 3。

3. 交换 2 和 3，得到 [3, 2, 1]。

4. 将 [2, 1] 排序，得到 [1, 2]。

因此，[2, 3, 1] 的前一个排列为 [2, 1, 3]。

相关问题

用Java实现给a[n]数组进行全排序，找到一个组合的前一个组合，比如a[3]{[2,2,3],[2,3,2],[2,2,3],[2,3,2],[3,2,2], [3,2,2]}，给出[2,3,2,]，找到他的前序是[2,2,3]

可以使用字典序算法来实现给a[n]数组进行全排序，并找到给定组合的前一个组合。具体实现步骤如下：

1. 从右往左找到第一个非递增的数a[i]，记录i的位置。
2. 从右往左找到第一个大于a[i]的数a[j]，记录j的位置。
3. 交换a[i]和a[j]。
4. 将i+1后的所有元素按照从小到大的顺序排列，即得到下一个排列。

代码示例：

public void prevPermutation(int[] nums) {
    int i = nums.length - 2;
    while (i >= 0 && nums[i] <= nums[i + 1]) {
        i--;
    }
    if (i >= 0) {
        int j = nums.length - 1;
        while (j >= 0 && nums[j] >= nums[i]) {
            j--;
        }
        swap(nums, i, j);
    }
    reverse(nums, i + 1, nums.length - 1);
}

private void swap(int[] nums, int i, int j) {
    int temp = nums[i];
    nums[i] = nums[j];
    nums[j] = temp;
}

private void reverse(int[] nums, int i, int j) {
    while (i < j) {
        swap(nums, i++, j--);
    }
}

使用示例：

int[] nums = {2, 3, 2};
prevPermutation(nums);
System.out.println(Arrays.toString(nums)); // 输出 [2, 2, 3]

注意：如果给定的组合已经是最小的排列，则返回最大的排列。

用Java代码实现给a[n]数组进行全排序，找到一个组合的前一个组合，比如a[3]{[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2], [3,2,1]}，给出[2,3,1,]，找到他的前序是[2,1,3]

以下是Java代码实现：

import java.util.Arrays;

public class Permutation {
    public static void main(String[] args) {
        int[] a = {1, 2, 3};
        int[] prev = prevPermutation(a);
        System.out.println(Arrays.toString(prev));
    }

    public static int[] prevPermutation(int[] a) {
        int n = a.length;
        int i = n - 2;
        while (i >= 0 && a[i] <= a[i + 1]) {
            i--;
        }
        if (i < 0) {
            return null;
        }
        int j = n - 1;
        while (j >= 0 && a[j] >= a[i]) {
            j--;
        }
        swap(a, i, j);
        reverse(a, i + 1, n - 1);
        return a;
    }

    public static void swap(int[] a, int i, int j) {
        int temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }

    public static void reverse(int[] a, int i, int j) {
        while (i < j) {
            swap(a, i++, j--);
        }
    }
}

运行结果为：

[2, 1, 3]

其中，`prevPermutation` 方法实现了上述字典序算法，`swap` 方法实现了交换数组中两个元素的功能，`reverse` 方法实现了翻转数组中指定范围内的元素的功能。