js实现排列组合算法N选M_js计算数组内任意n个数的组合-CSDN博客

JavaScript 从一个数组中拿出N个数（可放回）,问共有多少种

今天在写一道leetcode的时候遇到了无重复放回的遍历问题，用递归解决如下：

function p(arr, N, ans){
  if(N === 0) return ans;
  if(ans.length === 0) return(p(arr, N-1, arr.slice(0)))
  
  let res = []
  for(let c = 0; c < arr.length; c++){
    let item = arr[c];
    ans.forEach(element => {
      let el = element + item;
      res.push(el)
    });
  }
      
  return p(arr, N-1, res)
 }

console.log(p(['1', '2'], 4, []))  // 输出为

[
  '1111', '2111', '1211',
  '2211', '1121', '2121',
  '1221', '2221', '1112',
  '2112', '1212', '2212',
  '1122', '2122', '1222',
  '2222'
]

javascript实现排列组合算法

命题：从成员数为N的集合S中，选出M个元素，分别求其排列与组合结果集，即 A(N, M)与C(N, M)

js解法：

    function queue(arr, size) {
        if (size > arr.length) { return; }
        var allResult = [];
 
        (function (arr, size, result) {
            if (result.length == size) {
                allResult.push(result);
            } else {
                for (var i = 0, len = arr.length; i < len; i++) {
                    var newArr = [].concat(arr),
                        curItem = newArr.splice(i, 1);
                    arguments.callee(newArr, size, [].concat(result, curItem));
                }
            }
        })(arr, size, []);
 
        return allResult;
    }
 
 
    function choose(arr, size) {
        var allResult = [];
 
        (function (arr, size, result) {
            var arrLen = arr.length;
            if (size > arrLen) {
                return;
 
            }
            if (size == arrLen) {
                allResult.push([].concat(result, arr))
 
            } else {
                for (var i = 0; i < arrLen; i++) {
                    var newResult = [].concat(result);
                    newResult.push(arr[i]);
 
                    if (size == 1) {
                        allResult.push(newResult);
 
                    } else {
                        var newArr = [].concat(arr);
                        newArr.splice(0, i + 1);
                        arguments.callee(newArr, size - 1, newResult);
 
                    }
 
                }
 
            }
 
        })(arr, size, []);
 
        return allResult;
 
    }
 
    function showResult(result) {
        console.log('The number of result sets: ' + result.length);
        for (var i = 0, len = result.length; i < len; i++) {
            console.log(result[i]);
 
        }
 
    }
 
    var arr = [1,2,3,4,5];
    
    showResult(choose(arr, 4));
    showResult(queue(arr, 4));

原文链接：http://www.cnblogs.com/kaiye/p/3606373.html

一个数组中找出n个元素组成新的数组，有多少种组合(用递归实现)

给定一个数组如：nums=[1, 2, 3, 4, 5, 6,7,8,9,10]，取出其中任意N个元素，组成新的数组，求有多少种组合。

#1.思路

如果N确定，如N=4，此时，可以直接用四个for循环嵌套实现，但是当任意取出的个数N不固定时，此时不知道要用多少个for循环来实现,可考虑用递归来实现多个循环。

递归的思路：(假设输入N=4)
先找出第一个数的循环起止地址，在数组nums索引号为0~6，然后找出第二个是1到7，第三个是2到8，第三个是3到9，第四个数是4到10。

#2.JavaScript实现的代码

<script type="text/javascript">
		var nums=[1, 2, 3, 4, 5, 6,7,8,9,10];
		let N=4;
		function combine(arr,N){
			//存放索引号
			let res=[]
			//存放最后的结果
			var stack=[]
			arrayN(arr,0,N,N,res,stack)
			for(let i=0;i<stack.length;i++){
				console.log(stack[i])
			}
		}
		//start：为每个数的起始索引号。
		//count初始值为任意取出的元素的个数N，每一次递归count会减一，用于计算每个数的最后一位索引号和判断递归是否继续。
		//Num为常数，值是任意取出的元素的个数N,用于最后结果的输出。
		function arrayN(arr,start,count,Num,res,stack){
			//用递归实现，把N个循环用同一个循环实现
			for(let i=start;i<arr.length-count+1;i++){
				//记录索引号
				res[count-1]=i;
				if(count-1==0){
					let oneResult=[]
					for(let j=Num-1;j>=0;j--){
						oneResult.push(arr[res[j]])
					}
					stack.push(oneResult)
				}else{
					arrayN(arr,i+1,count-1,Num,res,stack)
				}
			}
		}
		combine(nums,N)
</script>