js:数据结构笔记12--排序算法（2）

高级排序算法：（处理大数据：百万以上）

• 希尔排序：是插入排序的优化版；
  • 首先设置间隔数组，然后按照每个间隔，分别进行排序；
  • 如第一个间隔为5，首先a[5]与a[0]进行插入排序;然后a[6]和a[0],a[1]进行插入排序，直到最后一个；
  • 然后换下一个间隔值，直到所有间隔值排序完（当间隔值为1时，就是一般的插入排序）；
  • 效果：

首先在类中添加间隔数组：

this.gaps = [5,3,1];

然后添加函数：

function shellsort() {

  for(var g = 0; g < this.gaps.length; ++g) {

    for(var i = this.gaps[g]; i < this.dataStore.length; ++i) {

      var temp = this.dataStore[i];

      for(var j = i; j >= this.gaps[g] && this.dataStore[j - this.gaps[g]] > temp; j -= this.gaps[g]) {

        this.dataStore[j] = this.dataStore[j - this.gaps[g]];

      }

      this.dataStore[j] = temp;

    }

  }

 }

demo:　

• 动态计算的希尔排序：

 function shellsort1() {

    var N = this.dataStore.length,h = 1;

    while(h < N/3) {

      h = 3 * h + 1;

    }

    while(h > 0) {

      for(var i = h; i < N; ++i) {

        for(var j = i; j >= h && this.dataStore[j] < this.dataStore[j-h]; j -= h) {

          swap(this.dataStore, j ,j-h);

        }

      }

      h = (h-1)/3;

    }

 }

demo:

 两个希尔排序的效率是一样的；

• 归并排序：把一系列排好序的子序列合并成一个大的完整有序的序列；在实际中实现时有个问题，就是在处理大数据的时候需要有足够的空间暂存；归并排序一般用递归实现，但这个方法在JS不太可行，所以采用一种非递归的方法实现；
  • 首先将数据分成一组只有一个数据的数组；
  • 然后通过创建一组左右字数组将他们合并；
  • 每次合并都保存一部分排好序的数据，直到最后剩下的数组都是已经排好序的；

function mergeSort() {

    var arr = this.dataStore,

        length = arr.length;

    if(length < 2) {

      return;

    }

    var step = 1;

    var left = step;

    while(step < length) {

      left = 0;

      right = step;

      while(right + step <= length) {

        mergeArray(arr,left,left + step,right,right + step); 

        left = right + step;

        right = left + step;

      }

      if(right < length) {

        this.mergeArray(arr,left,left + step,right,length);

      }

     step *= 2;

    }

  }

  function mergeArray(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, 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;

      }

     }

  }

 

demo;

•  快速排序：处理大数据最快的排序算法之一；它是一种分而治之的算法；
  • 选择一个基准元素，将数列分隔成两个子序列；
  • 对数组重新排序，将所有小于基准的元素放在基准前面，大于的放在后面，这个称为分区操作；
  • 对两个分区重复上述步骤，直到无法继续；
  • 效果：

function qSort(arr) {  //注意这里并没有将方法写进类当中

    var length = arr.length;

    if(arr.length === 0) {

      return [];

    }

    var left = [], right = [], pivot = arr[0];

    for(var i = 1; i < length; ++i) {

      if(arr[i] < pivot) {

        left.push(arr[i]);

      } else {

        right.push(arr[i]);

      }

    }

    return qSort(left).concat(pivot,qSort(right));

  }

demo