排列組合演算法用途廣泛, 需要掌握, 為降低門檻, 本文主要關注演算法的邏輯和簡易性, 未重視演算法效率. 結合網路書本上的實現和自己的需求, 這裡列有四個目標:
1. 所有元素的全排列: ab的全排列是ab, ba(順序相關);
2. 所有元素的全組合: ab的全組合是a, b, ab(順序無關);
3. 求n個元素中選取m個元素的組合方式有哪些: abc中選2個元素的組合是ab, ac, bc;
4. 求n個元素中選取m個元素的排列方式有哪些: abc中選2個元素的排列是ab, ba, ac, ca, bc, cb;

可以發現, 求n個元素中選取m個元素的排列方式其實是在求出n個元素中選取m個元素的組合方式後, 對每個組合組成的元素集(陣列)做全排列, 所以它是一個拼裝函式, 未列出示例, 其他三個目標, 看程式碼:

public final class PermutationCombinationHolder {

    /** 陣列元素的全組合 */
    static void combination(char[] chars) {
        char[] subchars = new char[chars.length]; //儲存子組合資料的陣列
        //全組合問題就是所有元素(記為n)中選1個元素的組合, 加上選2個元素的組合...加上選n個元素的組合的和
        for (int i = 0; i < chars.length; ++i) {
            final
 
 int m = i + 1;
            combination(chars, chars.length, m, subchars, m);
        }
    }

    /**
     *  n個元素選m個元素的組合問題的實現. 原理如下:
     *  從後往前選取, 選定位置i後, 再在前i-1個裡面選取m-1個.
     *  如: 1, 2, 3, 4, 5 中選取3個元素.
     *  1) 選取5後, 再在前4個裡面選取2個, 而前4個裡面選取2個又是一個子問題, 遞迴即可;
     *  2) 如果不包含5, 直接選定4, 那麼再在前3個裡面選取2個, 而前三個裡面選取2個又是一個子問題, 遞迴即可;
     *  3) 如果也不包含4, 直接選取3, 那麼再在前2個裡面選取2個, 剛好只有兩個.
     *  縱向看, 1與2與3剛好是一個for迴圈, 初值為5, 終值為m.
     *  橫向看, 該問題為一個前i-1箇中選m-1的遞迴.
     */
 

    static void combination(char[] chars, int n, int m, char[] subchars, int subn) {
        if (m == 0) { //出口
            for (int i = 0; i < subn; ++i) {
                System.out.print(subchars[i]);
            }
            System.out.println();
        } else {
            for (int i = n; i >= m; --i) { // 從後往前依次選定一個
                subchars[m - 1] = chars[i - 1]; // 選定一個後
                combination(chars, i - 1, m - 1, subchars, subn); // 從前i-1個裡面選取m-1個進行遞迴
            }
        }
    }

    /** 陣列元素的全排列 */
    static void permutation(char[] chars) {
        permutation(chars, 0, chars.length - 1);
    }

    /** 陣列中從索引begin到索引end之間的子陣列參與到全排列 */
    static void permutation(char[] chars, int begin, int end) {
        if (begin == end) { //只剩最後一個字元時為出口
            for (int i = 0; i < chars.length; ++i) {
                System.out.print(chars[i]);
            }
            System.out.println();
        } else {
            for (int i = begin; i <= end; ++i) { //每個字元依次固定到陣列或子陣列的第一個
                if (canSwap(chars, begin, i)) { //去重
                    swap(chars, begin, i); //交換
                    permutation(chars, begin + 1, end); //遞迴求子陣列的全排列
                    swap(chars, begin, i); //還原
                }
            }
        }
    }

    static void swap(char[] chars, int from, int to) {
        char temp = chars[from];
        chars[from] = chars[to];
        chars[to] = temp;
    }

    static boolean canSwap(char[] chars, int begin, int end) {
        for (int i = begin; i < end; ++i) {
            if (chars[i] == chars[end]) {
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args) {
        final char[] chars = new char[] {'a', 'b', 'c'};
        permutation(chars);
        System.out.println("===================");
        combination(chars);
    }
}