javascript实现经典排序

排序是我们生活中经常面对的问题，做操时需要从小到大排序，我们逛电商网站，常常按价格排序。像这样我们把多个序列按照关键词递增（递减）的方式进行排列，使得序列成为一个按关键字有序的序列，这样的操作就称为排序。

1.冒泡排序

冒泡排序是一种交换排序，它的基本思想是：两两比较相邻的关键字，如果反序则交换位置，知道没有反序的记录为止

时间复杂度：最快的情况下是所有的元素已经是正序   冒泡排序的时间复杂度为o(n²），代码如下

function bubleSort (arr) {

      var len = arr.length;

       for(var i = 0;i < len;i++){

                for(var j = 0;j < len-l-i;j++){

                if(arr[i]>arr[i+1]){

                var temp = arr[j+1];

                 arr[j+1] = arr[j];

                 temp = arr[j]

                 }

            }

       }

           return arr

}

2.选择排序

冒泡排序的思想就是不断交换位置，而选择排序的初步思想就是在排序时找到合适的关键字再做交换。分析它的时间复杂度发现，无论最好最差的情况，其比较次数都是一样多，第i趟排序需要进行i-1次关键字的比较，此时需要比较n(n-1)/2,总的时间复杂度依然是o(n²）,代码如下

 function selectSort(arr){

  var len = arr.length;

  var minIndex 

    for(var i = 0 ;i

    minIndex = i;

       for(var j = i+1;j < len;j++){

          if(arr[j]

         minIndex = j;

         }

    }

   var temp = arr[i];

    arr[i] = arr[minIndex];

   arr[minIndex] = temp;

    }

return arr

}

3.插入排序

插入排序的理解就像手里的扑克牌，抓牌的时候把牌按顺序在手牌中插入，插入排序的时间复杂度为o(n²）

function insertsort(){

var len = arr.length;

var pre ,current;

for(var i = 0; i

pre= i -1 ;

current = arr[i];

while(pre>0&&arr[pre]>current){

 arr[pre+1]= arr[pre];

pre--

}

arr[pre] = current;

}

return arr

}

4.归并排序

归并排序的宗旨是递归，总的时间复杂度为o(nlogn)

 

  function mergeSort(arr){

         var len = arr.length;

          if(len<2){

          return arr 

           }

       var middle = Math.floor(len/2);

         var left = arr.slice(0,middle);

         var right = arr.slice(middle);

        return merge(mergeSort(left),mergeSort(right))

  };

    function merge(left,right)(){

     var result = {};

    while(left.length>0&&right.length>0){

    if(left[0]<=right[0]){

       result.push(left.shift())

     }

     else{

       result.push(right.shift)

       }

    while(left.length){

    result.push(left.shift())

    }

  while(right.length){

    result.push(right.shift())

    }

return result

    }

   }

5.快速排序

通过一趟排序将待排记录分割成独立的两部分，其中一部分关键字均比另一部分关键字小，则可分别对这两部分记录继续进行排序，快速排序的时间复杂度虽然达到了o(n²）,但是比大多数平均时间复杂度为o(nlogn)的排序算法表现更好

var quickSort = function(arr) {

　　if (arr.length <= 1) {//如果数组长度小于等于1无需判断直接返回即可 

        return arr;

    }

　　var pivotIndex = Math.floor(arr.length / 2);//取基准点 

　　var pivot = arr.splice(pivotIndex, 1)[0];//取基准点的值,splice(index,1)函数可以返回数组中被删除的那个数

　　var left = [];//存放比基准点小的数组

　　var right = [];//存放比基准点大的数组 

　　for (var i = 0; i < arr.length; i++){ //遍历数组，进行判断分配 

　　　　if (arr[i] < pivot) {

　　　　　　left.push(arr[i]);//比基准点小的放在左边数组 

　　　　} else {

　　　　　　right.push(arr[i]);//比基准点大的放在右边数组 

　　　　}

　　}

         //递归执行以上操作,对左右两个数组进行操作，直到数组长度为<=1； 

　　return quickSort(left).concat([pivot], quickSort(right));

}

}