排序学习

冒泡排序

1. 正序

从尾部开始比较，小的则往上冒泡

function bubble(arr){                             
    for(i=0;i<arr.length-1;i++){
          for(j=arr.length-1;j>i;j--){    
                if(arr[j]<arr[j-1]){
                 [arr[j],arr[j-1]]=[arr[j-1],arr[j]]
                }
          }
    }
}

测试：

 var arr=[4,41,21,15,32,27,9,18]
     bubble(arr)
     console.log(arr)

输出结果如下：

2. 逆序

与正序相反，将大的上浮即可

function rebubble(arr){                            
   for(i=0;i<arr.length-1;i++){
       for(j=arr.length-1;j>i;j--){
           if(arr[j]>arr[j-1]){
             [arr[j],arr[j-1]]=[arr[j-1],arr[j]]
           }
       }
   }
}

测试

var arr=[4,41,21,15,32,27,9,18]
    rebubble(arr)
    console.log(arr)

输出结果如下

思考：若数组相对有序，是否可以减少循环次数。

在第二层for循环外加入判断，出现后一项小于前一项时再进行内循环

var count=0
 function bubble(arr){                                
     for(i=0;i<arr.length-1;i++){
         if(arr[i]>arr[i+1]){
              for(j=arr.length-1;j>i;j--){
                 count++
                   if(arr[j]<arr[j-1]){
                    [arr[j],arr[j-1]]=[arr[j-1],arr[j]]
                   }
              }
         }
      }
 }
 
      var arr=[4,5,12,15,24,33,42]
       bubble(arr)
       console.log(count)
       console.log(arr)

当数组完全正序时，通过计数可知只循环arr.length次。

但数组完全正序的情况仅为特例。可以考虑插入排序

插入排序

• 当数组规模小，且前段较有序时，效率较高。

个人理解：首先开始遍历第一层循环。从出现第一个无序排列的arr [ i ]开始，将arr [i]到arr [0]第二层循环，通过比较找到arr [ i ]的合适位置排好序再跳到第二层循环。（需保证j有项可比）

代码实现：

function insertSort(arr){
   for(i=1;i<arr.length;i++){
       if(arr[i]<arr[i-1]){
          var temp=arr[i]
            for(j=i;j>=0;j--){
                 if(temp<arr[j-1]&&j>0){
                      arr[j]=arr[j-1]
                 }else{
                     break
                 }
             }
        arr[j]=temp
        }
   }
}

测试：

var arr=[5,12,45,7,8,15]  
 insertSort(arr)
 console.log(arr)

输出结果：

但数组相对大且混乱时，使用插入排序效果便不尽人意。

快速排序

当数组较大且乱时，使用快速排序效率高
实现思想：

1. 取一个基准数
2. 将数组按基准数分为左半边和右半边，左边<基准数，右边>基准数
3. 对左半边和右半边再次进行1，2步操作
4. 直到排序完成

function quickSort(arr){
   function $quicksort(left,right){
             if(left<0||right>arr.length-1||left>=right){
                 return;                                 //确保可以分为两部分
             }
     var key=arr[right]                                //取一个基准数，常取最后一位数
     var low=left ,high=right                     //“low指”找左半边，“high指”找右半边，保证left与right定值           
        while(low<high){
                while(arr[low]<key&&low<high){
                    low++
                }                               //跳出该循环时即为low位上的值大于key值，将其赋予high，high再向左移
        arr[high]=arr[low]
                while(arr[high]>key&&low<high){
                    high--
                } 
         arr[low]=arr[high]                     //跳出该循环时即为high位值大于key值，将其赋予low，low再开始右移
         }

             arr[low]=key                                 //当low和high重合时，此位即为 key位
             $quicksort(left,high-1);                       //对左半边再次分类
             $quicksort(high+1,right);                     //对右半边再次分类
        }
 $quicksort(0,arr.length-1);                        //第一步使用此法
} 

测试：

var arr=[8,45,12,2,49,135,4,6,15]
quickSort(arr)
console.log(arr)

输出结果：