獲取所有組合算法、獲取全排列算法（java）

轉載聲明：原文轉自:http://www.cnblogs.com/xiezie/p/5574516.html 

受到ACM1015的影響，個人感覺，有必要對統計學上的 全組合和全排列 進行一個簡單的總結

 

組合數：從m個不同元素中取出n（n≤m）個元素的所有組合的個數，叫做從m個不同元素中取出n個元素的組合數（Combination）。

如1,2,3三個元素的全組合為：

1
2
3
12
13
23
123

以下是java實現的獲取全組合及其個數的算法：

import java.io.BufferedInputStream;
import java.util.ArrayList;
import java.util.Scanner;

public class GetCombination {

    public static void main(String[] args) {
        Scanner scan = new Scanner(new BufferedInputStream(System.in));
        String s = scan.next();
        ArrayList<String> list = new ArrayList<>();
        ArrayList<Character> com = new ArrayList<>();
        int len = s.length() + 1;
        for(int i = 1 ; i != len ; i ++){
            getCombinations(list,s.toCharArray(),0,i,com);
        }
        for(int i = 0 ; i != list.size() ; i ++){
            System.out.println(list.get(i));
        }
        System.out.println(getCountOfCombinations(s.length(),s.length()));
        scan.close();
    }
    
    static void getCombinations(ArrayList<String> list ,char[] cs, int start,int len,ArrayList<Character> com){//len為組合的長度
        if(len == 0){
            String s = "";
            for(int i = 0 ; i != com.size() ; i ++){
                s = s.concat(com.get(i).toString());
            }
            list.add(s);
            return;
        }
        if(start==cs.length){
            return;
        }
        com.add(cs[start]);
        getCombinations(list,cs,start+1,len-1,com);
        com.remove(com.size()-1);
        getCombinations(list,cs,start+1,len,com);
    }
    
    static int getCountOfCombinations(int arrLen,int len){//獲取長度為len的組合數
        int m = 1;
        for(int i = 0 ; i != len ; i ++ ){
            m*=arrLen-i;
        }
        int n = 1;
        for(int i = len ; i != 1 ; i --){
            n*=i;
        }
        return m/n;
    }
    
}

 

 

 

 

全排列：從n個不同元素中任取m（m≤n）個元素，按照一定的順序排列起來，叫做從n個不同元素中取出m個元素的一個排列。當m=n時所有的排列情況叫全排列。

如1,2,3三個元素的全排列為：
1,2,3
1,3,2
2,1,3
2,3,1
3,1,2
3,2,1
共3*2*1=6種 3！

以下是java實現的獲取全排列及其個數的算法：

import java.io.BufferedInputStream;
import java.util.ArrayList;
import java.util.Scanner;

public class GetAllPermutations {

    public static void main(String[] args) {
        Scanner scan = new Scanner(new BufferedInputStream(System.in));
        String s = scan.next();
        ArrayList<String> list = new ArrayList<>();
        getAllPermutations(list,s.toCharArray(),0,s.length());
        System.out.println("----------非字典序----------");
        for(int i = 0 ; i != list.size() ; i ++){
            System.out.println(list.get(i));
        }
        list.clear();
        System.out.println("----------字典序----------");
        getAllPermutations2(list,s.toCharArray(),0,s.length());
        for(int i = 0 ; i != list.size() ; i ++){
            System.out.println(list.get(i));
        }
        System.out.println(getCountOfAllPermutations(s.toCharArray(),0,s.length()));
        scan.close();
    }

    static int getCountOfAllPermutations(char[] cs,int start,int len){//start為數組序號
        int count = 1;
        int n = start + len ;
        for(int i = start ; i != n ; i ++ ){
            count *= i+1;
        }
        return count;
    }

    //非字典序
    static void getAllPermutations(ArrayList<String> answers,char[] cs,int start,int len){
        if(start == len ){
            answers.add(String.valueOf(cs));
            return;
        }
        for(int i = start ; i != len ; i ++){
            swap(cs,i,start);
            getAllPermutations(answers,cs,start+1,len);
            swap(cs,i,start);
        }
    }
    
    //字典序
    static void getAllPermutations2(ArrayList<String> list, char[] cs, int i, int length) {
        sort(cs);
        permutations(list,cs,i,length);
    }
    
    static void sort(char[] a) {//對字符數組進行快排
        int len = a.length;
        int low = 0,high = len - 1;
        quickSort(a, low, high);
    }

    static void quickSort(char[] a, int l ,int h){
        if(l>=h){
            return;
        }
        int low = l;
        int high = h;
        char k = a[low];
        while(low< high){
            //
            while(high>low&&a[high]>=k){//尋找元素右邊比其小的
                high --;
            }
            a[low] = a[high];//進行交換，K指向high
            while(low<high&&a[low]<=k){//尋找元素左邊比其大的
                low++;
            }
            a[high] = a[low];//進行交換，K指向low
        }
        a[low] = k;//將K賦給low
        quickSort(a, l, low-1);
        quickSort(a, low+1, h);
    }

    static void permutations(ArrayList<String> answers,char[] cs,int start,int len){//cs為字典序數組
        if(cs==null)
            return;
        while(true)
        {
            answers.add(String.valueOf(cs));
            int j=start+len-2,k=start+len-1;
            while(j>=start && cs[j]>cs[j+1])
                --j;
            if(j<start)
                break;

            while(cs[k]<cs[j])
                --k;

            swap(cs,k,j);

            int a,b;
            for(a=j+1,b=start+len-1;a<b;++a,--b)
            {
                swap(cs,a,b);
            }
        }
    }

    static void swap(char[] cs , int i , int j){
        char t;
        t = cs[i];
        cs[i] = cs[j];
        cs[j] = t;
    }
}