計算一維組合數的java實現

背景很簡單，就是從給定的m個不同的元素中選出n個，輸出所有的組合情況！

 

例如：從1到m的自然數中，選擇n(n<=m)個數，有多少種選擇的組合，將其輸出！

 

本方案的代碼實現邏輯是比較成熟的方案：

* 一個bit位（boolean）一維數組中，初始化全為0(false), 然后給左邊的n個位初始化為1(true)。
* <1> 從左向右找第一個10的位置，將10換位程01，然后將這個01左邊的所有的1全都移位到數組的最左邊，此時得到的1所在位置下標對應序列即為一個組合數。 
* <2> 循環重復上面的<1>步驟的操作，直到所有的1都移動到最右邊為止。

 

先不多說其他的，直接將代碼貼在這里，以供有需要的伙伴借鑒：

/**
 * @author "shihuc"
 * @date   2016年12月1日
 */
  6 
import java.util.ArrayList;
import java.util.Arrays;

/**
 * @author chengsh05
 * 
 * 組合算法實現，支持產品列表頁的篩選模塊實現全靜態化。
 * 
 * 給定m個不同的數，從中選擇出n個數的不同選擇方法有多少種？
 * 答案：一共有 n!/(n-m)!*m!
 * 
 * 存儲計算出來的組合結構，組合元素之間用逗號分隔
 *         例如1,2,3的全組合：
 *         "1,", "2,", "3,","1,2,", "1,3,", "2,3,", "1,2,3,"
 */
public class Combination {
    
    /**
     * 從m個元素中取出n個元素，獲取排序好了的組合數列表，同一個組合中的元素按從小到大排序。
     * 
     * @param m 組合的元素基數
     * @param n 組合的被選元素個數
     * @return 排序好后的組合列表
     * @throws Exception 
     */
    public ArrayList<String> getCombinations(int m, int n) throws Exception{
        
        if(m < n){
            throw new IllegalCombinationInputException();
        }
        
        ArrayList<String> resCom = calcCombination(m, n);
        
        return resCom;
    }
    
    /**
     * 通過移位方式，計算給定m個數中取出n個數的組合列表。
     * 
     * 具體思路：
     * 一個bit位（boolean）數組中，初始化全為0(false), 然后給左邊的n個位初始化為1(true)。
     * <1> 從左向右找第一個10的位置，將10換位程01，然后將這個01左邊的所有的1全都 移位到數組的最左邊，此時得到的1所在位置下標對應的序列即為一個組合數。 
     * <2> 循環重復上面的<1>步驟的操作，直到所有的1都移動到最右邊為止。
     * 
     * @param m 輸入的基數個數
     * @param n 組合被選元素格式
     * @return 原始組合數列表，即沒有排序的組合
     */
    private ArrayList<String> calcCombination(int m, int n){
        boolean base[] = new boolean[m];
        Arrays.fill(base, false);
        for(int i=0; i<n; i++){
            base[i] = true;
        }
        return combination(base,m,n);
    }
    
    private ArrayList<String> combination(boolean a[], int m, int n){
        ArrayList<String> combination = new ArrayList<String>();        
        while(!isAllZeroLeft(a, m, n)){
            for(int i=0; i<m-1; i++){
                if(a[i] == true && a[i+1] == false){
                    String elem = calcElement(a);    //計算出一個組合元素
                    //System.out.println(elem);
                    combination.add(elem);
                    oneZeroSwap(a, i, i+1);          //完成10/01換位                    
                    moveFrontOneToLeft(a, i);        //完成剩余左邊的1全向最左邊搬移操作                    
                    break;
                }
            }
        }
        
        //最后一個元素也是組合的一個，即所有的1(true)都到了數組的最右邊
        combination.add(calcElement(a));
        return combination;
    }
    
    /**
     * 異或操作實現不開辟新的存儲空間完成兩個數的位置交換。
     * 
     * @param a 待操作數所在的數組
     * @param x 待交換位置的第一個數在數組中的下標
     * @param y 待交換位置的第二個數在數組中的下標
     */
    private void oneZeroSwap(boolean a[], int x, int y){
        a[x] = a[x] ^ a[y];
        a[y] = a[y] ^ a[x];
        a[x] = a[x] ^ a[y];
    }
    
    /**
     * 判斷10作01交換位置后，是否實現了數組a中右端的n個元素全為1(true),這個結果作為10/01換位結束標識
     * 
     * @param a 10/01換位的輸入數組
     * @param m 計算組合的元數據個數
     * @param n 計算組合的被選取元素個數
     * @return true表示10/01換位結束，false表示還可以繼續
     */
    private boolean isAllZeroLeft(boolean a[], int m, int n){
        int gap = m - n;
        for(int i=0; i<gap; i++){
            if(a[i]){
                return false;
            }
        }
        return true;
    }
    
    /**
     * 將10/01換位之后數組左邊的全部1都搬移到數組的最左邊。
     * 
     * @param a 待操作的組合數組
     * @param end 指明搬移操作的范圍，在end數組下標左邊的進行搬移, 這個end的值小於數組的長度
     */
    private void moveFrontOneToLeft(boolean a[], int end){
        int oneCnt = 0;
        for(int i=0; i<end; i++){
            if(a[i]){
                oneCnt++;
                a[i] = false;
            }
        }
        for(int i=0; i<oneCnt; i++){
            a[i] = true;
        }
    }
    
    /**
     * 計算當前數組中的組合元素的值，數組元素為1(true)的對應的下標的全集，即為所需的一個組合元素值
     * 
     * @param a 待操作的組合數組
     * @return 一個組合的值, 去掉了最后的一個逗號分隔符
     */
    private String calcElement(boolean a[]){        
        String elem = "";
        for(int i=0; i<a.length; i++){
            if(a[i]){
                elem += (i+1) + ",";
            }
        }
        return elem.substring(0, elem.length() - 1);
    }
        
    
    /**
     * @param args
     * @throws Exception 
     */
    public static void main(String[] args) throws Exception {
        int m = 5, n = 2;
        Combination combination = new Combination();
        ArrayList<String> coms = combination.getCombinations(m, n);
        for(int i = 0; i<coms.size(); i++){
            System.out.println(coms.get(i));
        }
    }
}

 代碼中定義的Exception的類：

/**
 * @author "shihuc"
 * @date   2016年12月1日
 */

/**
 * @author chengsh05
 *
 */
public class IllegalCombinationInputException extends Exception{

    private static final long serialVersionUID = 678024281707796100L;
    
    public IllegalCombinationInputException(){
        super("The combination base number should be not less than the selection number.");  
    }

}

 

此算法思路，在很多場景下還是值得借鑒的！

 

算法是計算機科學的靈魂，堅持算法學習和應用......