java、js组合排列算法

 java 组合排列算法:

public class PailieZuhe {
	public static void main(String[] args) {
		String str[] = { "A", "B", "C", "D", "E" };
		plzh(str);
	}
public static void plzh(String[] str) {
		int nCnt = str.length;
		int nBit = 1 << nCnt;
		for (int i = 1; i <= nBit; i++) {
			for (int j = 0; j < nCnt; j++) {
				if ((1 << j & i) != 0) {
					System.out.print(str[j]);
				}
			}
			System.out.println("");
		}
	}

public class CaseTest {
    public static void main(String[] args) {
        int[] ia = { 1, 2, 3, 4, 5 };
        int n = 4;
        System.out.println("排列结果 : ");
        permutation(ia, n);
        System.out.println("组合结果 : ");
        combination(ia, n);
    }

    public static void permutation(String s, int[] ia, int n) {
        if (n == 1) {
            for (int i = 0; i < ia.length; i++) {
                System.out.println(s + ia[i]);
            }
        } else {
            for (int i = 0; i < ia.length; i++) {
                String ss = "";
                ss = s + ia[i] + "";
                // 建立没有第i个元素的子数组
                int[] ii = new int[ia.length - 1];
                int index = 0;
                for (int j = 0; j < ia.length; j++) {
                    if (j != i) {
                        ii[index++] = ia[j];
                    }
                }
                permutation(ss, ii, n - 1);
            }
        }
    }

    public static void permutation(int[] ia, int n) {
        permutation("", ia, n);
    }

    public static void combination(int[] ia, int n) {
        combination("", ia, n);
    }

    public static void combination(String s, int[] ia, int n) {
        if (n == 1) {
            for (int i = 0; i < ia.length; i++) {
                System.out.println(s + ia[i]);
            }
        } else {
            for (int i = 0; i < ia.length - (n - 1); i++) {
                String ss = "";
                ss = s + ia[i] + ", ";
                // 建立从i开始的子数组
                int[] ii = new int[ia.length - i - 1];
                for (int j = 0; j < ia.length - i - 1; j++) {
                    ii[j] = ia[i + j + 1];
                }
                combination(ss, ii, n - 1);
            }
        }
    }

PHP数组内容不重复组合排列算法

function getArrSet($arrs,$_current_index=-1)
10 {
11     //总数组
12     static $_total_arr;
13     //总数组下标计数
14     static $_total_arr_index;
15     //输入的数组长度
16     static $_total_count;
17     //临时拼凑数组
18     static $_temp_arr;
19     
20     //进入输入数组的第一层，清空静态数组，并初始化输入数组长度
21     if($_current_index<0)
22     {
23         $_total_arr=array();
24         $_total_arr_index=0;
25         $_temp_arr=array();
26         $_total_count=count($arrs)-1;
27         getArrSet($arrs,0);
28     }
29     else
30     {
31         //循环第$_current_index层数组
32         foreach($arrs[$_current_index] as $v)
33         {
34             //如果当前的循环的数组少于输入数组长度
35             if($_current_index<$_total_count)
36             {
37                 //将当前数组循环出的值放入临时数组
38                 $_temp_arr[$_current_index]=$v;
39                 //继续循环下一个数组
40                 getArrSet($arrs,$_current_index+1);
41                 
42             }
43             //如果当前的循环的数组等于输入数组长度(这个数组就是最后的数组)
44             else if($_current_index==$_total_count)
45             {
46                 //将当前数组循环出的值放入临时数组
47                 $_temp_arr[$_current_index]=$v;
48                 //将临时数组加入总数组
49                 $_total_arr[$_total_arr_index]=$_temp_arr;
50                 //总数组下标计数+1
51                 $_total_arr_index++;
52             }
53 
54         }
55     }
56     
57     return $_total_arr;
58 }

js实现全排列组合算法
全排列组合算法，例如a,b,c,d进行全排列组合，则组合结果为：a,b,ab,c,ac,bc,abc,d,ad,bd,abd,cd,acd,bcd,abcd。实现思路：从数据源拿出一个元素，依次与已存在的组合数据进行组合，循环上面操作直到数据源没有数据为止。
例子：
数据源a,b,c
1.拿出a，组合数据group为空，插入数据源a元素到组合数据group，此时group=[a]
2.拿出b，组合数据group拿出a，a和b组合，得到ab，把数据源b元素、ab插入组合数据group，此时group=[a,b,ab]
3.拿出c，组合数据group拿出a、b、ab，分别与c组合，分别得到ac、bc、abc，把数据源c元素、ac、bc、abc插入组合数据group，此时group=[a,b,ab,c,ac,bc,abc]

var data = ['a','b','c','d'];
 
function getGroup(data, index = 0, group = []) {
	var need_apply = new Array();
	need_apply.push(data[index]);
	for(var i = 0; i < group.length; i++) {
		need_apply.push(group[i] + data[index]);
	}
	group.push.apply(group, need_apply);
 
	if(index + 1 >= data.length) return group;
	else return getGroup(data, index + 1, group);
}
 
console.log(getGroup(data));