Javascript中，实现十大排序方法之一（冒泡排序及其优化设想）

冒泡排序的Javascript实现

首先定义一个取值范围在（0~100000）之间的随机值的长度为10万的数组，

 function bubbleSort(arr) {
         console.time('冒泡排序耗时');
         var len = arr.length,temp;
         for(var i=0;i<len;i++){
             for(j=0;j<len-i-1;j++){
                     if(arr[j]>arr[j+1]){
                            temp = arr[j+1];
                            arr[j+1] = arr[j];
                            arr[j] = temp;
                     }
             }
         }
         console.timeEnd('冒泡排序耗时');
         return arr;
 }

 var array = [];

 for(var i=0;i<100000;i++){
      var x = Math.random()*100000;
      var y = Math.floor(x);
      array.push(y);
 }

 console.log(bubbleSort(array));
 //冒泡排序十次平均耗时: 37019.239013671875ms    

下面我们来看一下在javascript中的array原型链上的sort()方法的特点

 function Sort(arr) {
       console.time('排序耗时');
       var arr1= arr.sort(function(a,b){return a-b});
       console.timeEnd('排序耗时');
       return arr1;

 }

 Sort(array);                //排序十次平均耗时: 79.05419921875ms       

由上面的代码可以知道，javasrcipt中array原型链上的sort方法的效率是很高的

//冒泡排序的改良方法（一）

function bubbleSort1(arr) {
　　console.time('改进后冒泡排序耗时一');
　　var i = arr.length-1,tmp; //初始时,最后位置保持不变　　
　　while ( i> 0) {
　　　　var pos= 0; //每趟开始时,无记录交换
　　　　for (var j= 0; j< i; j++){
　　　　　　if (arr[j]> arr[j+1]) {
　　　　　　　　 pos= j; //记录交换的位置
　　　　　　　　 tmp = arr[j];
                           arr[j]=arr[j+1];
                           arr[j+1]=tmp;
　　　　　　}
　　　　}
　　　　i= pos; //为下一趟排序作准备
　　}
　　console.timeEnd('改进后冒泡排序耗时一');
　　return arr;
}

console.log(bubbleSort1(array));
    //           改进后冒泡排序十次平均耗时: 30493.7470703125ms      

//冒泡排序的改良方法（二）

 function bubbleSort2(arr) {
 　　var low = 0;
 　　var high= arr.length-1; //设置变量的初始值
 　　var tmp,j;
 　　console.time('改进后冒泡排序耗时二');
 　　while (low < high) {
 　　　　for (j= low; j< high; ++j) {         //正向冒泡,找到最大者
 　　　　　　if (arr[j]> arr[j+1]) {
 　　　　　　　　tmp = arr[j]; arr[j]=arr[j+1];arr[j+1]=tmp;
 　　　　　　}
 　　　　}
 　　　　--high;  //修改high值, 前移一位
 　　　　for (j=high; j>low; --j) {          //反向冒泡,找到最小者
 　　　　　　if (arr[j]<arr[j-1]) {
 　　　　　　　　tmp = arr[j]; arr[j]=arr[j-1];arr[j-1]=tmp;
 　　　　　　}
 　　　　}　
 　　　　++low;  //修改low值,后移一位
 　　}
 　　console.timeEnd('改进后冒泡排序耗时二');
 　　return arr;
 }

 console.log(bubbleSort2(array));
// 改进后冒泡排序十次平均耗时:   23629.715087890625ms

//冒泡排序的改良方法（三）

 function bubbleSort3(arr) {
 　　var low = 0;
 　　var high= arr.length-1; //设置变量的初始值
 　　var tmp,j;
 　　console.time('改进后冒泡排序耗时三');
 　　while (low < high) {
 　　　　var pos1 = 0,pos2=0;
 　　　　for (let i= low; i< high; ++i) { //正向冒泡,找到最大者
 　　　　　　if (arr[i]> arr[i+1]) {
 　　　　　　　　tmp = arr[i]; arr[i]=arr[i+1];arr[i+1]=tmp;
 　　　　　　　　pos1 = i ;
 　　　　　　}
 　　　　}

 　　　　high = pos1;// 记录上次位置

 　　　　for (let j=high; j>low; --j) { //反向冒泡,找到最小者
 　　　　　　if (arr[j]<arr[j-1]) {
 　　　　　　　　tmp = arr[j]; arr[j]=arr[j-1];arr[j-1]=tmp;　　
 　　　　　　　　pos2 = j;
 　　　　　　}
 　　　　}　　　
 　　　　
 　　　　low = pos2; //修改low值
 　　}
 　　console.timeEnd('改进后冒泡排序耗时三');
 　　return arr;
 }

 console.log(bubbleSort3(array));
 // 改进后冒泡排序十次平均耗时:  20408.427734375ms

由上面的运行结果可知，冒泡排序虽然是比较常用的排序方法，但其实其执行效率是比较低的

冒泡排序的平均时间维度为： O（n*n）    最好的情况 O（n）  最差的情况  ： O(n*n)      空间复杂度 O（1）  排序方式： in-place    稳定性：稳定

图片名词解释：
n: 数据规模
k:“桶”的个数
In-place: 占用常数内存，不占用额外内存
Out-place: 占用额外内存

稳定：即如果两个数相等，那么位置不会交换

不稳定：如果两个数相等，那么也有可能交换位置