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