javascript数据结构与算法 --- 高级排序算法

高级排序算法总结

1. 希尔排序

       function shellsort(array, gaps) {
         for (var g = 0; g < gaps.length; g++) {
           for (var i = gaps[g]; i < array.length; i++) {
             var temp = array[i];
             for (var j = i; (j >= gaps[g]) && (temp < array[j-gaps[g]]);j -= gaps[g]) {
               array[j] = array[j - gaps[g]];
             }
             array[j] = temp;
           }
           console.log(array);
         }
       }

   间隔序列 gaps可以动态定义，不过对于大部分的实际应用场景，算法要用到的间隔序列可以提前定义好,有一些公开定义的间隔序列，使用它们会得到不同的结果。例如Marcin Ciura 在2001 的论文“Best Increments for theAverage Case of Shell Sort”中的间隔序列[701, 301, 132, 57, 23, 10, 4, 1],下一节将介绍具有动态间隔序列的希尔排序.

2. 动态间隔序列希尔排序

       function dynOrdShellsort(array) {
         var N = array.length;
         var h = 1;
         while (h < N/3) {h = 3 * h + 1;
         }
         while (h >= 1) {
           for (var i = h; i < N; i++) {
             for (var j = i; j >= h && array[j] < array[j-h]; j -= h) {
               // swap(array, j, j-h);
               [array[j], array[j-h]] = [array[j-h], array[j]];
             }
           }h = (h-1)/3;
         }
       }

   在《算法（第 4 版）》（人邮版）的合著者 Robert Sedgewick 定义了一个   shellsort() 函数，在这个函数中可以通过一个公式来对希尔排序用到的间隔序列进行动态计算。Sedgewick 的算法是通过上面的代码片段来决定初始间隔值的,并添加到外层 for 循环.

3. 归并排序

       let mergeSort = (function () {
         function mergeSort(arr) {
           if (arr.length < 2) {
             return;
           }
           var step = 1;
           var left, right;
           while (step < arr.length) {
             left = 0;
             right = step;
             while (right + step <= arr.length) {
               mergeArrays(arr, left, left+step, right, right+step);
               left = right + step;
               right = left + step;
             }
             if (right < arr.length) {
               mergeArrays(arr, left, left+step, right, arr.length);
             }
             step *= 2;
           }
         }
         function mergeArrays(arr, startLeft, stopLeft, startRight, stopRight) {
           var rightArr = new Array(stopRight - startRight + 1);
           var leftArr = new Array(stopLeft - startLeft + 1);
           k = startRight;
           for (var i = 0; i < (rightArr.length-1); ++i) {
             rightArr[i] = arr[k];
             ++k;
           }
           k = startLeft;
           for (var i = 0; i < (leftArr.length-1); ++i) {
             leftArr[i] = arr[k];
             ++k;
           }
           rightArr[rightArr.length-1] = Infinity; // 哨兵值
           leftArr[leftArr.length-1] = Infinity; // 哨兵值
           var m = 0;
           var n = 0;
           for (var k = startLeft; k < stopRight; ++k) {
             if (leftArr[m] <= rightArr[n]) {
               arr[k] = leftArr[m];
               m++;
             }
             else {
               arr[k] = rightArr[n];
               n++;
             }
           }
           // console.log("left array - ", leftArr);
           // console.log("right array - ", rightArr);
         }
         return mergeSort;
       })()

4. 快速排序

       function qSort(arr){
         if (arr.length == 0) {
           return [];
         }
         var left = [];
         var right = [];
         var pivot = arr[0];
         for (var i = 1; i < arr.length; i++) {
           if (arr[i] < pivot) {
             left.push(arr[i]);
           } else {
             right.push(arr[i]);
           }
         }
         return qSort(left).concat(pivot, qSort(right));
       }