JAVA用遞迴實現全排列演算法的示例程式碼

阿新 • • 發佈：2020-07-06

求一個n階行列式，一個比較簡單的方法就是使用全排列的方法，那麼簡述以下全排列演算法的遞迴實現。

首先舉一個簡單的例子說明演算法的原理，既然是遞迴，首先說明一下出口條件。以[1,2]為例

首先展示一下主要程式碼(完整程式碼在後面)，然後簡述

//對陣列array從索引為start到最後的元素進行全排列  public void perm(int[]array,int start) {
    if(start==array.length) { //出口條件
      for(int i=0;i<array.length;i++) {
//        this.result[row][i] = array[i];
        System.out.print(array[i]+" ");
      }
//      System.out.print(++this.row+": ");
//      System.out.println("逆序數是："+ this.against(array));
      System.out.print('\n');
    }
    else {
      for(int i=start;i<array.length;i++) {
        swap(array,start,i); //交換陣列array中索引為start與i的兩個元素
        perm(array,start+1); 
        swap(array,i);
      }
    }
  }

首先陣列[1,2]分析，在else的部分

呼叫了swap(array,0)然後呼叫perm(array,1)

　　呼叫swap(array,1,1)然後呼叫perm(array,2)，然後在if裡面2 == 2成立，列印[1,2]

　　呼叫swap(array,1)把之前交換的swap(array,1)復原，雖然看起來沒有變化

回到上一層

呼叫swap(array,1) 然後呼叫perm(array,2)，然後在if裡面2 == 2成立，列印[2,1]

　　呼叫swap(array,1)復原，雖然看起來沒有變化

回到上一層

跳出迴圈，程式結束。

這就是對[1,2]的全排列。

那麼放到一般情況，[1,2,3]呢？

呼叫了swap(array,1)

　　然後對[2,3]進行全排列，其中輸出[1,3]， [1,3,2]

再次呼叫swap(array,0)復原

呼叫了swap(array,1)

　　然後對[1,3]進行全排列，輸出[2,3],[2,1]

再次呼叫swap(array,1)復原

呼叫了swap(array,2)然後呼叫perm(array,1)

　　然後對[2,1]進行全排列，輸出[3,1],[3,2)復原

更高階的就是同理了！

那麼我們的程式碼如下：

package matrix;

import java.util.Arrays;

public class Permutation {

  /**
   * author:ZhaoKe
   * college: CUST
   */
  //當前列印的第幾個排列
  private int row = 0;
  //儲存排列的結果
  private int[][] result;
  
  public Permutation(int[] array) {
    this.row = 0;
    this.result = new int[this.factor(array.length)][array.length];
  }
  
  public int[][] getResult() {
    return result;
  }

  //求陣列a的逆序數
  public int against(int a[]) {
    int nn = 0;
    for (int i = 0; i < a.length-1; i++) {
      for (int j = i+1; j<a.length; j++) {
        if (a[i] > a[j]) {
          nn++;
        }
      }
    }
    return nn;
  }

  //排列數
  public int factor(int a) {
    int r = 1;
    for (; a>=1; a--) {
      r *= a;
    }
    return r;
  }

  public void perm(int[]array,int start) {
    if(start==array.length) {
      System.out.print((this.row+1)+": ");
      for(int i=0;i<array.length;i++) {
        this.result[row][i] = array[i];
        System.out.print(array[i]+" ");
      }
      this.row++;
      System.out.println("逆序數是："+ this.against(array));
      System.out.print('\n');
    }
    else {
      for(int i=start;i<array.length;i++) {
        swap(array,i);
        perm(array,start+1);
        swap(array,i);
      }
    }
  } 
  
  public void swap(int[] array,int s,int i) {
    int t=array[s];
    array[s]=array[i];
    array[i]=t;
  }
  
  public void printResult() {
    for (int i = 0; i < result.length; i++) {
        System.out.println(Arrays.toString(this.result[i]));
    }
  }
  
  public static void main(String[] args) {
    int[] a = {1,3};
    Permutation p = new Permutation(a);
    p.perm(a,0);
    p.printResult();
  }
}

執行該程式結果如下：