递归

//阶乘算法
function jiecheng(num){
	if (num == 1){
		return 1;
				
	}
	return num*jiecheng(num-1);
}
console.log(jiecheng(5))


		
//斐波拉契题 1， 1， 2， 3， 5， 8， 13， 21 。。。
        
 function fei(num) {
        	
        if(num==0||num==1){
        	return 1;
        }
        	return fei(num-1)+fei(num-2);
  }
        console.log(fei(5))

数组去重

function qc(arr1){
//创建一个新的数组
	let arr = [];
//遍历数组arr1
	for( let i = 0; i < arr1.length; i++) {
//如果arr1不在arr中 会返回-1 那么将和这个元素存在新建的arr中
		if( arr.indexOf(arr1[i]) == -1) {
				arr.push(arr1[i])
		}
	}
//返回arr
	return arr;
}
arr1 = ["1","1","3","5","2","24","4","4","a","a","b"];
		
console.log(qc(arr1));
//输出结果["1", "3", "5", "2", "24", "4", "a", "b"]

冒泡算法

思路：依次比较相邻的两个数，将比较小的数放在前面，比较大的数放在后面。

(1)第一次比较：首先比较第一和第二个数，将小数放在前面，将大数放在后面。

(2)比较第2和第3个数，将小数 放在前面，大数放在后面。

......

(3)如此继续，知道比较到最后的两个数，将小数放在前面，大数放在后面，重复步骤，直至全部排序完成

(4)在上面一趟比较完成后，最后一个数一定是数组中最大的一个数，所以在比较第二趟的时候，最后一个数是不参加比较的。

(5)在第二趟比较完成后，倒数第二个数也一定是数组中倒数第二大数，所以在第三趟的比较中，最后两个数是不参与比较的。

(6)依次类推，每一趟比较次数减少依次

function sort(elements) {
	for(var i=0;i<elements.length - 1;i++){
		for (var j=0;j<elements.length-i-1;j++){
           //两个for循环 依次比较 把较大的数记录下来给后面 依次类推 达到排序的结果
			if(elements[j]>elements[j+1]){
				var swap = elements[j];
				elements[j]=elements[j+1];
				elements[j+1]=swap;
			}
		}
				
	}
	return elements;
}
var elements = [3,1,5,9,6];
console.log(sort(elements));
//输出结果[1, 3, 5, 6, 9]

快速排序

let testArray = [3, 3, 1, 2, 5, 6, 4];
let quickSort = (array) => {
    if (array.length < 2) return array;
    let leftArray = [];
    let rightArray = [];
    let baseDigit = array[0];
    let baseArr = [baseDigit]
    array.forEach(element => {
        if (element < baseDigit) {
            leftArray.push(element);
        } else if (element > baseDigit) {
            rightArray.push(element);
        } else {
            baseArr.push(element)
        }
    });
    console.log(baseDigit, baseArr, leftArray, rightArray)
    return quickSort(leftArray).concat(baseArr, quickSort(rightArray))
};
quickSort(testArray);

缺点：用来临时数组，空间复杂度比较高

来个优化版本吧

var quickSort_New = function(ary, left, right) {
        if(left >= right) {
            return ary;
        }

        var i = left,
             j = right;
             base = ary[left];

        while (i < j) {
            // 从右边起，寻找比基数小的数
            while (i<j && ary[j] >= base) {
                j--;
            }

            // 从左边起，寻找比基数大的数
            while (i<j && ary[i] <= base) {
                i++
            } 

            if (i<j) {
                var temp = ary[i];
                ary[i] = ary[j];
                ary[j] = temp;
            }
        }

        ary[left] = ary[i];
        ary[i] = base;

        quickSort_New(ary, left, i-1);
        quickSort_New(ary, i+1, right);

        return ary;
    }