java實現排列組合

原文鏈接:JAVA實現組合、排列、重復排列（多層循環）###

package com.champion.singleadmin;

import java.util.ArrayList;
import java.util.List;
public class CombineAndArrangement {

    private static ArrayList<Integer> tmpArr = new ArrayList<>();
    public static void main(String[] args) {
        int [] com = {1,2,3,4};
        int k = 3;
        if(k > com.length || com.length <= 0){
            return ;
        }
        System.out.println("組合結果：");
        combine(0 ,k ,com);
        System.out.println("\n排列結果：");
        arrangement(k,com);
        System.out.println("\n可重復排列結果：");
        repeatableArrangement(k, com);
    }

    /**
     * 組合
     * 按一定的順序取出元素，就是組合,元素個數[C arr.len 3]
     * @param index 元素位置
     * @param k 選取的元素個數
     * @param arr 數組
     */
    public static void combine(int index,int k,int []arr) {
        if(k == 1){
            for (int i = index; i < arr.length; i++) {
                tmpArr.add(arr[i]);
                System.out.print(tmpArr.toString() + ",");
                tmpArr.remove((Object)arr[i]);
            }
        }else if(k > 1){
            for (int i = index; i <= arr.length - k; i++) {
                tmpArr.add(arr[i]); //tmpArr都是臨時性存儲一下
                combine(i + 1,k - 1, arr); //索引右移，內部循環，自然排除已經選擇的元素
                tmpArr.remove((Object)arr[i]); //tmpArr因為是臨時存儲的，上一個組合找出后就該釋放空間，存儲下一個元素繼續拼接組合了
            }
        }else{
            return ;
        }
    }

    /**
     * 排列
     * 按照無序（隨機）的方式取出元素，就是排列,元素個數[A arr.len 3]
     * @param k 選取的元素個數
     * @param arr 數組
     */
    public static void arrangement(int k,int []arr){
        if(k == 1){
            for (int i = 0; i < arr.length; i++) {
                tmpArr.add(arr[i]);
                System.out.print(tmpArr.toString() + ",");
                tmpArr.remove((Object)arr[i]);
            }
        }else if(k > 1){
            for (int i = 0; i < arr.length; i++) { //按順序挑選一個元素
                tmpArr.add(arr[i]); //添加選到的元素
                arrangement(k - 1, removeArrayElements(arr, tmpArr.toArray(new Integer[1]))); //沒有取過的元素，繼續挑選
                tmpArr.remove((Object)arr[i]);
            }
        }else{
            return ;
        }
    }

    /**
     * 可重復排列
     * 類似自己和自己笛卡爾積，類似k層循環拼接的結果,元素個數[arr.len^3]
     * @param k 選取的元素個數（k層循環）
     * @param arr 數組
     */
    public static void repeatableArrangement(int k,int []arr){
        if(k==1){
            for(int i=0;i<arr.length;i++){
                tmpArr.add(arr[i]);
                System.out.print(tmpArr.toString() + ",");
                tmpArr.remove(tmpArr.size()-1); //移除尾部元素
            }
        }else if(k >1){
            for(int i=0;i<arr.length;i++){
                tmpArr.add(arr[i]);
                repeatableArrangement(k - 1, arr); //不去重
                tmpArr.remove(tmpArr.size()-1); //移除尾部元素,不能用remove(Object),因為它會移除頭部出現的元素，我們這里需要移除的是尾部元素
            }
        }else{
            return;
        }
    }

    /**
     * 移除數組某些元素（不影響原數組）
     * @param arr 數組
     * @param elements 待移除的元素
     * @return 剩余元素組成的新數組
     */
    public static int[] removeArrayElements(int[] arr, Integer... elements){
        List<Integer> remainList = new ArrayList<>(arr.length);
        for(int i=0;i<arr.length;i++){
            boolean find = false;
            for(int j=0;j<elements.length;j++){
                if(arr[i] == elements[j]){
                    find = true;
                    break;
                }
            }
            if(!find){ //沒有找到的元素保留下來
                remainList.add(arr[i]);
            }
        }
        int[] remainArray = new int[remainList.size()];
        for(int i=0;i<remainList.size();i++){
            remainArray[i] = remainList.get(i);
        }
        return remainArray;
    }
}

新的方法嘗試如下：

	int[] ccc = {2,3,4};
            public void selectArray(){

		List<Object> listList = new ArrayList<>();
		Set<Object[]> set = new HashSet<>();

		combineMatch(ccc,0,2,listList,set);

		for(Object[] sss: set){
			System.out.println(Arrays.toString(sss));
		}
	}

	public void combineMatch(int[] ccc,int begin,int num,List<Object> listList,Set<Object[]> set){
		if(num == 0){
			set.add(listList.toArray());
			return;
		}

		if(begin == ccc.length){
			return;
		}

		listList.add(ccc[begin]);
		combineMatch(ccc,begin+1,num-1,listList,set);

		listList.remove((Object)ccc[begin]);

		combineMatch(ccc,begin+1,num,listList,set);
	}