Johnson-Trotter（JT）算法求全排列

Johnson-Trotter算法描述

算法　　JohnsonTrotter(n)

　　　//實現用來生成排序的 Johnson-Trotter 算法

　　　//輸入：正整數n（代表序列1,2，···，n）

　　　//輸出：{1,2，···，n}的全排列

　　　將第一個全排列初始化為

 

　　　while  存在一個移動元素 do

　　　　求最大的移動元素 k

　　　　把 k 和它箭頭指向的相鄰元素互換

　　　　調轉所有大於 k 的元素的方向

　　　　將新排列添加到排列中

以 n=3 為例

 

 

 

 

下面我將貼出Johnson-Trotter算法的JAVA代碼

package JT;

import java.util.Scanner;

public class Johnson_Trotter {
    //求最大的移動元素
    public static int maxk(int n, int[] array, boolean[] f) {
        //k存儲最大移動元素的下標
        int k = -1, max = 0;
        for(int i = 0; i < n; i++) {
            //當前元素的方向是左邊，則與左邊的元素比較看是否可以移動
            //若可移動則與當前可移動最大值比較
            if(f[i] == false) {
                if(i > 0 && array[i] > array[i - 1] && array[i] > max) {
                    k = i;
                    max = array[i];
                }
            }
            //右邊
            else {
                if(i < n - 1 && array[i] >array[i + 1] && array[i] > max) {
                    k = i;
                    max = array[i];
                }
            }
        }
        return k;
    }
    //元素和方向的交換
    public static int[] swap2(int[] array, boolean[] f, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
        boolean temp1 = f[i];
        f[i] = f[j];
        f[j] = temp1;
        return array;
    }
    //調轉方向
    public static boolean[] Reverseid(int[] array, int k, boolean[] f) {
        for(int i = 0; i < array.length; i++) {
            if(array[i] > array[k]) {
                f[i] = f[i] ? false : true;
            }
        }
        return f;
    }

    public static void Jt(int n) {
        //方向數組，false為左，true為右
        boolean[] flag = new boolean[n];
        //數字數組
        int[] idata = new int[n];
        //k為當前可移動元素的最大值
        int k = 0;
        //初始化兩個數組
        for(int i = 0; i < n; i++) {
            idata[i] = i + 1;
            flag[i] = false;
        }
        //輸出第一個初始化的排列，此排列不會自動生成
        for(int i = 0; i < n; i++) {
            System.out.print(idata[i]);
            System.out.print(flag[i]);
        }
        System.out.println();
        //初始化k，獲取第一個可移動的最大元素
        k = maxk(n, idata, flag);
        //循環直到沒有可移動的元素
        while(k != -1) {
            //可向右移動
            if(flag[k]) {
                //移動時，將元素和方向都交換
                idata = swap2(idata, flag, k, k + 1);
                //此時k所在的元素已經向右交換，k也需要對應加1
                k++;
            }
            //可向左移動
            else {
                idata = swap2(idata, flag, k, k - 1);
                k--;
            }
            flag = Reverseid(idata, k, flag);//調轉所有大於k的元素的方向
            //輸出當前的一個排列
            for(int i = 0; i < n; i++) {
                System.out.print(idata[i]);
                System.out.print(flag[i]);
            }
            System.out.println();
            k = maxk(n, idata, flag);//獲取下一個k
        }
    }

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();//輸入n
        Jt(n);//調用算法
        scan.close();
    }
}

代碼運行結果如下：(帶有元素方向)

Please put in n :4
1false2false3false4false
1false2false4false3false
1false4false2false3false
4false1false2false3false
4true1false3false2false
1false4true3false2false
1false3false4true2false
1false3false2false4true
3false1false2false4false
3false1false4false2false
3false4false1false2false
4false3false1false2false
4true3true2false1false
3true4true2false1false
3true2false4true1false
3true2false1false4true
2false3true1false4false
2false3true4false1false
2false4false3true1false
4false2false3true1false
4true2false1false3true
2false4true1false3true
2false1false4true3true
2false1false3true4true

Process finished with exit code 0

 此文章為原創，轉載需說明出處。