前端算法防虐题汇总

1. 数组全排列

var arr = ['foo','bar','hello','world'];
    var count = 1;
    function getStr(a){
    	for (var i = 0; i < arr.length; i++) {
    		// indexOf 是es6数组的方法,如果不存在返回-1，存在返回下标
    		if(a.indexOf(arr[i])<0){
    			
    			//数组 a 中不存在 arr[i],将arr[i]添加到数组末尾
    			a.push(arr[i]);
    			
    			if(a.length==arr.length){
    				console.log(count++ + ': ' +a.join(""));	
    			}else{
    				//结束一次for循环  进行了4次递归 getStr(['foo']) getStr(['bar']) getStr(['hello']) getStr(['world']) 
    				getStr(a);
    				
    			}
    			//一定从数组 a 中删除arr[i],进行下次循环，如果不删除就只能获得一种结果了
    			a.pop();  			
    		}	
    	}
    }
    getStr([])		

除去注释只用了15行代码，通过上面的方法 我们实现了单个数组全排
更多方法阅读

思考问题：

如何实现多个数组全排呢？

2. 最大连续子序列和

思路： 比较若干个连续

		var arr = [1, 6, -1, 5, 4, -7, 2, 3];
    		var maxSum = arr[0],
				sum = arr[0];
			for(var i=1;i<arr.length;i++) {
				if(sum< 0) {
					sum = arr[i];
				} else {
					sum += arr[i];
				}
				if (sum > maxSum) {
					maxSum = sum;
				}
			 	console.log(sum, maxSum);

			}
	console.log(maxSum);

3. DOM 遍历深度优先和广度优先算法

1. 深度优先
   

// 递归
let arr = []
function deepTraversal(node) {
  if(!node) return;
  arr.push(node)
  for (var i = 0; i< node.children.length; i++) {
    deepTraversal(node.children[i])
  }
  
}
// 非递归
let arr =[]
function deepTraversal(node) {
  if(!node) return;
  var stack = [node];
  while (stack.length) {
    var item = stack.shift();
    arr.push(item);
    var children = item.children;
    for (var i = children.length - 1; i >= 0 ; i--) {
      stack.unshift(children[i]);
    }
  } 
}

2. 广度优先
   

	// 递归
	let nodes = []; //nodes可放函数中
	let i = 0;
	function wideTraversal(node) {
	  if (node) {
	    nodes.push(node);
	    wideTraversal(node.nextElementSibling);
	    node = nodes[i++];
	    wideTraversal(node.firstElementChild);
	  }
	}
	wideTraversal(rootElement);
	console.log(nodes);

	let nodes = [rootElement]; //nodes可放函数中
	let stack = []
	function wideTraversal(node) {
	  if (node) {
	    for(var i =0; i< node.children.length; i++) {
	      nodes.push(node.children[i]);
	      stack.push(node.children[i])
	    }
	    wideTraversal(stack.shift())
	  }
	}
	wideTraversal(rootElement);
	
	// 非递归  先进先出
	let arr = []; 
	let stack = [rootElement]
	function wideTraversal(node) {
	  while(stack.length) {
	    let item = stack.shift()
	    arr.push(item)
	    for (var i = 0; i < item.children.length;i++) {
	      stack.push(item.children[i]);
	    }
	  }
	}
	wideTraversal(rootElement);
	console.log(arr);