Javascript中的冒泡排序，插入排序，选择排序，快速排序，归并排序，堆排序 算法性能分析

阿里面试中有一道题是这样的：

　　　　　　　　　　　　　　　　请用JavaScript语言实现 sort 排序函数，要求：sort([5, 100, 6, 3, -12]) // 返回 [-12, 3, 5, 6, 100]，如果你有多种解法，请阐述各种解法的思路及优缺点。（仅需用代码实现一种解法，其它解法用文字阐述思路即可）

那我们就来看一下各种解法的思路以及优缺点~

简单排序

1冒泡法：

原理：对存放原始数据的数组，按从前往后的方向进行多次扫描，每次扫描称为一趟。当发现相邻两个数据的次序与要求的不同时，即将两个数据进行互换，第一次扫描结束后，进行第二次扫描，直到所有数据符合要求。

优点：

平均时间复杂度O（n*n），是比较容易实现的算法，相对稳定。

缺点：

慢，每次只能移动相邻两个数据

 var sortArray=new Array();
     var temp;
     sortArray=id_list.split(":");
     for(var i=;i<sortArray.length;i++)
     {
         for(var j=;j<i;j++)
         {

             if(parseInt(sortArray[j])>parseInt(sortArray[i]))
             {
                 temp=sortArray[j];
                 sortArray[j]=sortArray[i];
                 sortArray[i]=temp;
             }
         }
     }

2插入排序：
原理：首先新建一个空列表用于保存已经排序的有序数列A，从原序列B中取出一个数，逐个与有序列表中的数比较，如果b[0]大于a[0]则跳过，继续比较b[0]与a[1],如果前者仍大于后者，则继续跳过，直到b[0]小于a[x],则将b[0]插入到a[x]的位置，a[x]及其后面的往后移动一位。使其仍旧保持有序状态。然后再取出一个数按相同方法插入，直至原数列为空。它借助了“逐步扩大成果”的思想，使有序列表的长度逐渐增长，直至等于元列表的长度即排序完成。

优点：

容易实现，稳定，快，适合少量数据比较。时间复杂度为O（n*n）。

缺点：

效率不高，比较次数不一定，比较次数越少，插入点后的数据移动越多，如果数据量庞大的话，可以使用链表来解决这个问题~

 function insertSort(){
 var A=[,,,,,];

 document.write("原数组:")
     for (var n = ; n < A.length; n++) {
         document.write(A[n] + " ");
     }
 document.write("原数组长度:"+A.length+"<br/>");
     var key;
     var i;
     for(var j=;j<A.length;j++){
         key=A[j];
         i=j-;
         while(i>-&&A[i]>key){
             A[i+]=A[i];
             i=i-;
         }
         A[i+]=key;

     //输出结果
     document.write("第" + j + "遍排序的结果是:")
     for (var n = ; n < A.length; n++) {
         document.write(A[n] + " ");
     }
     document.write("<br />")
     }
 }

3选择排序

原理：每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好的数列的最后，直到全部待排序的数据元素排完。

优点：进行（n-1）趟排序即可排序完成，时间复杂度为n的平方O（n*n）

缺点：比较次数比较多，每一趟从数据中选出的目标数据都是和剩下所有数据比较的结果。

*注意和冒泡排序的区别 选择排序是从一个序列到另一个序列，冒泡排序是在本身序列的排序，选择排序性能稍稍好于冒泡排序。

    function selectSort(array) {
             var min, temp; ;
             for (var i = 0; i < array.length; i++) {
                 min = i;
                 for (var j = i + 1; j < array.length; j++) {
                     if (array[min] > array[j])
                         min = j;
                 }
                 if (min != i) {
                     temp = array[i];
                     array[i] = array[min];
                     array[min] = temp;
                 }
                 /* 输出结果 */
                 document.write("第 + i + "遍排序的结果是:")
                 for (var n = 0; n < array.length; n++) {
                     document.write(array[n] + ",");
                 }

                 document.write("<br />")
                 /* 输出结果结束 */

             }
         }

高效排序

快速排序

原理：快速排序是目前已知速度最快的排序方法，，排序方法所运用的思想和我们众所周知的二分法一脉相承，专业一点的话称为“分治策略”。保证列表的前半部分都小于后半部分，然后分别对两部分进行排序，这样比较前半部分时就不需要和后半部分比较了，这种方法大大减少了数据间的不必要排序，因而高效~具体步骤：假设要对一组数据进行升序排列，先任取数据a[x]作为基准，，比较a[x]与其他数据并排序，使a[x]排在数据的第k位，并且使a[1]~a[k-1]中的每一个数据都小于a[x],a[k+1]~a[n]中的每一个数据都大于a[k]，然后按同样的方法对两组数据进行快速排序。

优点：速度极快，数据移动较少 平均时间复杂度为(n*log n)

缺点：不稳定

   var count = 0;
         function quickSort(array, low, high) {
             var temp;

             if (low < high) {

                 var keypoint = QuickSortHelp(array, low, high);
                 count++;
                 document.write("<br />第台? + count + "遍括?排?序ò的?结á果?是?:")
                 for (var l = 0; l < array.length; l++) {
                     document.write(array[l] + ",");
                 }
                 quickSort(array, low, keypoint - 1);
                 quickSort(array, keypoint + 1, high);

                 }
         }
         function QuickSortHelp(array, low, high) {
             while (low < high) {

                 while (low < high && array[low] <= array[high]) {
                     high--;
                 }
                 temp = array[low];
                 array[low] = array[high];
                 array[high] = temp;
                 while (low < high && array[low] <= array[high]) {
                     low++
                 }
                 temp = array[low];
                 array[low] = array[high];
                 array[high] = temp;

             }
             return low;
         }
         

归并排序：

原理：归并排序是多次将两个或两个以上的有序表合并成一个新的有序表。特点是相等的元素的顺序不会改变，这对要排序数据包含多个信息按其中的某一个信息排序，要求其他信息尽量按输入的顺序排列时很重要，这也是比快速排序优势的地方。归并排序对数据的有序性不敏感，其时间复杂度在任何情况下都是O(nlog 2n)，所以如果数据节点数据量大的话不是很合适。但是如果改造成索引操作的话效果还是很棒的~

优缺点在原理中说明~

//source源数组
//dest目标数组
//s起始下标
//t目标下标
 function mSort(source, dest, s, t) {
 6 var m; //取中间值
 var dest2 = new Array();
 if (s == t) {
 dest[s] = source[s];

             }
             else {
                 m = Math.floor((s + t) / 2);
                 mSort(source, dest2, s, m);
                 mSort(source, dest2, m+1 , t);
                 merge(dest2, dest, s, m, t);
                 /* 输出结果 */
                 document.write("<br />第 + ++count + "遍排序的结果是:")
                 for (var n = 0; n < dest.length; n++) {
                     document.write(array[n] + ",");
                 }
                
             }

         }

27
//source原数组
//dest排序后的数组
//s第一个下标
//m第二个数组下标
         function merge(source, dest, s, m, n) {
             for (var j = m+1, k = s; j <= n && s <= m; k++) {
                 if (source[s] < source[j]) {
                     dest[k] = source[s++];
                 }
                 else {
                     dest[k] = source[j++];
                 }
             }

                 //将剩余排不完的有序数组加入到dest的末端
                 if (s <= m) {
                     for (var l = 0; l <= m - s; l++) {
                         dest[k + l] = source[s+l];
                     }
                 }
                 if (j <= n) {
                     for (var l = 0; l <= n - j; l++) {
                         dest[k + l] = source[j+l];
                     }

             }
         }    

堆排序：

原理：首先新建一个空列表，在带排序数列中找到最大的数字，将其加在空列表的末尾，并将其从原数列中删除，重复以上步骤，直至原数列为空。

*请注意与插入排序的区别，堆排序时间复杂度为O（nlog n），插入排序为O（n*n）,堆排序新建的空列表作用与插入排序新建的有序列表作用相同，但仅仅是作用相同。

优点：效率高，如果只是要找到最大数的话时间复杂度仅仅为O(1)

缺点：实现相对复杂

 function heapSort(array) {
             var temp;
             var i;
             for (i = Math.floor(array.length / 2); i >= 0; i--) {
                 heapAdjust(array, i, array.length - 1); //将数组array构建成一个大顶堆
             }
             for (i = array.length - 1; i >= 0; i--) {
                 /*把根节点交换出去*/
                 temp = array[i];
                 array[i] = array[0];
                 array[0] = temp;

                 /*余下的数组继续构建成大顶堆*/
                 heapAdjust(array, 0, i - 1);
                 /* 输出结果 */
                 document.write("<br />第 + (array.length - i).toString() + "遍排序的结果是:")
                 for (var n = 0; n < array.length; n++) {
                     document.write(array[n] + ",");
                 }
                 /* 输出结果结束 */
             }
         }
         //要调整的子树
         //start为数组开始下标
         //max是数组结束下标
         function heapAdjust(array, start, max) {
             var temp, j;
             temp = array[start];//temp是根节点的值
             for (j = 2 * start; j < max; j *= 2) {
                 if (j < max && array[j] < array[j + 1]) {  //取得较大孩子的下标
                     ++j;

                 }
                 if (temp >= array[j])
                     break;
                 array[start] = array[j];
                 start = j;
             }
             array[start] = temp;

         }

*该代码部分借鉴CareySon