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;
        }

  

  

原文地址:https://www.cnblogs.com/diasa-fly/p/7066099.html