减治法在生成全排列中的应用（JAVA）--回溯、Johnson-Trotter算法、自字典序

减治法在生成组合对象问题中的应用

在深入浅出讲算法思想--蛮力法思想分析及应用这篇文章的最优解问题中中已经初步讲解了这类应用，下面我们将使用减治法再次思考这类问题。

1、全排列问题，在数学中求解一个n个数组合的全排列问题会产生n！个组合的情况。暴力枚举的确是个方法，但是除非n非常的小，不然这个时间复杂度是非常庞大的，但是如果运用减治思想就可以解决这种问题，我们便可以将我们可以将生成n！个排雷的问题变为求解(n-1)！个全排列的问题，之后再将n插入n-1个元素每种排列中n可能的位置中去。因为n*(n-1)!=n!，所以这就是该算法的可行性分析。

1）简单回溯实现：

public class Main {
    static int[] a = new int[4];
    static int[] visit = new int[4];
    public static void main(String[] args) {
        int n = 3;
        f(0, n);
    }
    private static void f(int cur, int n) {
        if (cur == n) {
            for (int i = 0; i < n; i++) {
                if ((i+1) % 3 == 0) {
                    System.out.print(a[i] + " ");
                    System.out.println();
                } else {
                    System.out.print(a[i] + " ");
                }
            }
        }
        for (int i = 1; i <= n; i++) {
            if (visit[i] == 0) {
                visit[i] = 1;
                a[cur] = i;
                f(cur+1, n);
                visit[i] = 0;
            }
        }
    }
}

2）Johnson-Trotter算法实现：参考 johnson_trotter(生成排列算法)

3）字典序实现：第二种算法实现的结果输出是从最后一个开始的，不过，按照习惯上的写法，我们总是希望结果是按照升序排列的，而字典序可以实现这种即高效又是升序的效果。

public class Main {
    public static void main(String[] args) {
        int arr[] = new int[]{1,2,3};
        
        sort(arr);
        
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]);
        }
        System.out.println();

        while(nextPermutation(arr))
        {
            for(int value : arr)
                System.out.print(value);
            System.out.println();
        }
    }

    public static boolean nextPermutation(int[] arr)
    {
        int pos1 = 0;
        int pos2 = 0;
        /**
         * 找到使得a[i] < a[i+1]的最大的i，赋给pos1
         * 用于将123变为132这样的情况
         * */
        int flag = 0;
        for(int i = arr.length - 2;i >= 0;i--) {
            if(arr[i] < arr[i + 1]) {
                pos1 = i;
                flag = 1;
                break;
            }
        }
        if(flag == 0) {
            return false;
        }
        /**
         * 找到使得a[i] arr[pos1]) {
                pos2 = j;
            }
        }
        /**
         * 交换a[pos1]与a[pos2]
         * */
        int temp = arr[pos1];
        arr[pos1] = arr[pos2];
        arr[pos2] = temp;

        /**
         * 对a[i+1]到a[n]逆序
         * */
        for (int i = pos1+1; i < arr.length; i++) {
            for (int j = arr.length-1; j > i ; j--) {
                temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        return true;
    }
    /**
    * 冒泡
    * */
    public static void sort(int[] arr) {
        for(int i = 0;i < arr.length - 2;i++) {
            for(int j = 0;j < arr.length - i - 1;j++) {
                if(arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }
}