js学习总结----常见的算法

一、递归 : 当前函数自己调用自己执行

　　实现1-100之间，把所有不能被三整除的数相加（这种类型的问题首先想到的是递归）　

function sum(){
   if(n===0){
      return 0    
    }
    if(n % 3 ===0){
      return sum(n-1)
    }
    return n+sum(n-1)
}

　　从1-10把所有能被二整除的进行相乘　　

function fn(n){
   if(n===1){
     return 1
}
   if(n%2!==0){
    return fn(n-1)   
}
   return n*fn(n-1);  
    
}

　　使用setTimeout实现一个和setInterval一模一样的功能

二、冒泡排序

　　冒泡排序的思想:让当前项和后一项进行比较，如果当前项大于后一项，两者交换位置

　　例如：

　　var ary = [4,3,5,2,1]

　　第一轮:

　　　　拿出数组第一项4和后一项3比较 4>3 交换位置  [3,4,5,2,1]

　　　　 4<5 不需要交换位置  [3,4,5,2,1]

　　　    5>2 交换位置 [3,4,2,5,1]

　　　　5>1 交换位置 [3,4,2,1,5] //虽然没有实现最终的目标 但是已经把数组的最大值放在了末尾位置了

　　　　第一轮比较四次 一共五个数 不用和自己比 最多比较四次

　　第二轮

　　　　3<4 不交换  [3,4,2,1,5]

　　　　4>2 交换 [3,2,4,1,5]

　　　　4>1 交换 [3,2,1,4,5] //也没有实现最后的目标 但是把剩余项中的最大的4放在了倒数第二位

　　　　第二轮比较三次 

　　第三轮

　　　　3>2 交换 [2,3,1,4,5]

　　　　3>1 交换 [2,1,3,4,5]

　　　　第三轮比较二次

　　第四轮

　　　　2>1 交换 [1,2,3,4,5]

　　　　每一轮当前项和后一项两两比较的话，虽然不一定达到最后的结果 但是已经把当前最大的那个值放在了后面，数组一共有五项，只需要比较四轮，把四个最大值分别放在末尾 就实现了排序  一共最多需要比较轮:ary.length-1

　　　　i轮数 i = 0 i<ary.length-1

　　　　j每一轮比较的次数

　　　　　　i = 0 第一轮 4

　　　　　　i = 1 第二轮 3

　　　　　　i = 2 第三轮 2

　　　　　　i = 3 第四轮 1(ary.length-1-i)

　　　　两者交换位置

　　　　　　var a = 12;

　　　　　　var b = 13;

　　　　　　var c = null;

　　　　　　c = a;

　　　　　　a = b;

 　　　　　   b = c

　　　　如果不能使用第三个瓶子如何处理

　　　　var a = 12;

　　　　var b = 13;

    　　     a = a+b;

　　　　 b = a-b;

　　　　 a = a-b;

　　　　冒泡函数　　　　　

function bubbleSort(ary){
　　　　　　　　var flag = false;
　　　　　　　　for(var i = 0;i<ary.length-1;i++){//轮数

　　　　　　　　     for(var j = 0;j<ary.length-1-i;j++){//每一轮比较的次数

　　　　　　　　　　　　if(ary[j]>ary[j+1]){
　　　　　　　　　　　　　　flag = true;//只要本轮有交换 就让flag = true
　　　　　　　　　　　　　　temp = ary[j];

　　　　　　　　　　　　　　ary[j] = ary[j+1];

　　　　　　　　　　　　　　ary[j+1] = temp;

　　　　　　　　　　　　}

　　　　　　　　　　}
　　　　　　　　　　if(flag){ //上一轮有交换 继续执行下一轮
　　　　　　　　　　　　flag = false;
　　　　　　　　　　
　　　　　　　　　　}else{
　　　　　　　　　　　　break;//上一轮没有交换的  已经排好序了  直接结束循环即可
　　　　　　　　　　}

　　　　　　　　}

　　　　　　　　return ary;

　　　　　　}

 三、快速排序

 　　var ary = [12,13,23,14,20,26,34,13,16]

 　　快速排序的思想:

　　　　1、我们首先在数组中找一个“基准点”(一般把基准点选择为数组中间的这一项)

　　　　　　Math.floor(ary.length/2)

　　　　2、拿基准点和数组中的其他项进行比较，比基准点小的放在左边，比基准点大的放在右边

 　　　   3、以后的每一遍都重复上述的两个操作，直到当前这一边只有一项的时候停止处理..

 　　　快排函数:　

function quickSort(ary){
            //如果传递过来的数组只有一项，不需要在按照快速的思想拆了，直接把这一项的数组返回即可
            if(ary.length<=1){
                return ary;
            }
            var pointIndex = Math.floor(ary.length / 2);//找到基准点的索引
            //通过基准点的索引在原来的数组中删除这一项，并把基准点这一项的值获取到
            var pointValue = ary.splice(pointIndex,1)[0];
            //拿基准点的值和原来的数组中每一项进行比较，把小于基准点的放在左边，大于基准点的放在右边
            var left = [];
            var right = [];
            for(var i = 0;i<ary.length;i++){
                var cur = ary[i];
                cur<pointValue?left.push(cur):right.push(cur)
            }
            return quickSort(left).concat([pointValue],quickSort(right))

        }

四、数组插入排序

　　var ary = [6,3,5,7,2,4]

　　把第一张牌放在左手，以后拿到每一张牌的时候，和左手中的牌进行依次比较(一般来说我们的习惯是从后往前比较),如果当前的牌比倒数第一张小，在继续往左比。。。一直遇到当前的牌已经比手里的某张牌大了，则把这张牌插入到某张牌的后面(某张牌下一张的前面)

　　插入函数：　

function insertSort(ary){
            //newAry存储的是我左手中已经抓取的牌
            var newAry = [];
            newAry.push(ary[0])
            //依次把桌面上第二张及以后的牌抓到
            for(var i = 1;i<ary.length;i++){
                var cur = ary[i]
                //抓到当前牌之后，分别的从后往前和左手中的牌进行比较
                for(var j = newAry.length-1;j>=0;){
                    if(cur<newAry[j]){//当前的牌比左手中的这张小，继续和其前面的牌比
                        j--;
                        if(j===-1){//说明当前拿的牌比左手边的所有牌都小，把这张牌放在开头即可
                            newAry.unshift(cur);
                        }
                    }else{//当前新抓的牌比左手边的大，放在这张牌的后面
                        newAry.splice(j+1,0,cur)
                        j = -1;
                    }
                }
            }
            return newAry;
        }