add heap sort

Author: qieguo2016

README.md

@@ -42,13 +42,21 @@ js中可以通过对象的哈希结构来实现树结构，两种数据结构结
 
 ### sort [sort.js](/js/sort.js)
 
-#### bubble：冒泡排序
+#### [bubbleSort：冒泡排序](/js/sort.js#L20)
 
-#### select：选择排序
+#### [selectSort：选择排序](/js/sort.js#L36)
 
-#### quick：快速排序
+#### [straightInsertionSort: 直接插入排序](/js/sort.js#L52)
 
-#### merge：归并排序
+#### [shellSort：希尔排序](/js/sort.js#L72)
+
+#### [quickSort：快速排序](/js/sort.js#L101)
+
+#### [inPlaceQuickSort：原地快速排序](/js/sort.js#L127)
+
+#### [mergeSort：归并排序](/js/sort.js#L159)
+
+#### [heapSort：堆排序](/js/sort.js#L192)
 
 
 

js/sort.js

@@ -7,19 +7,26 @@
 
 'use strict';
 
+/**
+ * 交换数组中两元素位置
+ * @param       : i, j: 待交换的两元素下标
+ */
+Array.prototype.swap = function(i, j) {
+  const temp = this[i];
+  this[i] = this[j];
+  this[j] = temp;
+}
+
 /**
  * 冒泡排序
  * @param       : <Array> target数组
  * @description : 冒泡排序，更贴切的形容应该是沉底排序，每一轮内循环就是最大数沉底了。
  */
 module.exports.bubbleSort = function bubbleSort(target) {
-  var temp;
   for(var j = target.length; j > 0; j--) {
     for(var i = 0; i < j - 1; i++) {
       if(target[i] > target[i + 1]) {
-        temp = target[i];
-        target[i] = target[i + 1];
-        target[i + 1] = temp;
+        target.swap(i, i + 1);
       }
     }
   }
@@ -37,9 +44,7 @@ module.exports.selectSort = function selectSort(target) {
     for(var i = 1; i < j; i++) {
       maxIndex = target[maxIndex] > target[i] ? maxIndex : i;
     }
-    var temp = target[j - 1];
-    target[j - 1] = target[maxIndex];
-    target[maxIndex] = temp;
+    target.swap(maxIndex, j - 1);
   }
   return target;
 };
@@ -124,31 +129,30 @@ module.exports.quickSort = function quickSort(target) {
  * @param       : <Array> target
  * @description : 上面的快排每次都开辟一个数组，浪费空间。常规做法是两边查找到中间，两两交换位置
  */
-module.exports.inPlaceQuickSort = function inPlaceQuickSort(target) {
-  function _inPlaceQuickSort(target, left, right) {
-    // 先定义递归终止条件
-    if(left >= right) { return target; }
-
-    var base = target[left];
-    var i = left;
-    var j = right;
-    while(i < j) {
-      while(i < j && target[j] >= base) {
-        j--;
-      }
-      target[i] = target[j];
-      while(i < j && target[i] <= base) {
-        i++;
-      }
-      target[j] = target[i];
+function _inPlaceQuickSort(target, left, right) {
+  // 先定义递归终止条件
+  if(left >= right) { return target; }
+
+  var base = target[left];
+  var i = left;
+  var j = right;
+  while(i < j) {
+    while(i < j && target[j] >= base) {
+      j--;
     }
-    target[i] = base;
-    // 也可以利用函数副作用改变传入数组，但是用显式返回更清晰
-    target = _inPlaceQuickSort(target, left, i - 1);
-    target = _inPlaceQuickSort(target, i + 1, right);
-    return target;
+    target[i] = target[j];
+    while(i < j && target[i] <= base) {
+      i++;
+    }
+    target[j] = target[i];
   }
-
+  target[i] = base;
+  // 函数副作用已经改变了传入数组，但是用显式返回看起来更清晰
+  target = _inPlaceQuickSort(target, left, i - 1);
+  target = _inPlaceQuickSort(target, i + 1, right);
+  return target;
+}
+module.exports.inPlaceQuickSort = function inPlaceQuickSort(target) {
   return _inPlaceQuickSort(target, 0, target.length - 1)
 };
 
@@ -185,4 +189,68 @@ module.exports.mergeSort = function mergeSort(target) {
   return mergeSortedArray(mergeSort(left), mergeSort(right));
 };
 
+/**
+ * 堆排序
+ * @param       : <Array> target
+ * @description : 通过构建大(小)根堆的方式进行排序，PS：使用函数副作用来进行原地排序
+ */
+// 递归调整 i~j 层的大根堆
+function adjustMaxHeap(target, i, j) {
+  let parent = i;
+  let left = 2 * i + 1;
+  let right = 2 * i + 2;
 
+  // 比较父节点与左右叶子节点，取最大值的下标设为父节点下标
+  if(left < j && target[parent] < target[left]) {
+    parent = left;
+  }
+  if(right < j && target[parent] < target[right]) {
+    parent = right;
+  }
+  // 只有父节点发生改变才会破坏大根堆结构，此时才需要继续调整下级大根堆
+  if(parent != i) {
+    target.swap(i, parent);
+    adjustMaxHeap(target, parent, j);
+  }
+}
+// 构建大根堆就是不断调整最大堆的过程，只要从最后一个父节点往上调整到第一个父节点，就能构建出大根堆
+// 从0开始的n层堆的结构：len = 2^n - 1，第n层全是叶子，所以第n-1层的最后一个父节点就是floor(len/2)-1
+function buildMaxHeap(target) {
+  const len = target.length;
+  for(let i = Math.floor(len / 2) - 1; i >= 0; i--) {
+    adjustMaxHeap(target, i, len);
+  }
+}
+
+function sortMaxHeap(target) {
+  for(let i = target.length - 1; i > 0; i--) {
+    target.swap(0, i);
+    adjustMaxHeap(target, 0, i);
+  }
+}
+// 先构建一个大根堆，然后从最后一个元素开始交换堆顶元素，每次交换都调整根堆，直到数组头则完成排序
+module.exports.heapSort = function heapSort(target) {
+  buildMaxHeap(target);
+  sortMaxHeap(target);
+  return target;
+};
+
+/**
+ * 堆排序提取部分记录
+ * 从大数据中提取最大(小)的n条记录，也可以用小(大)根堆来实现
+ * 先用数据集中前n条数据构造一个小根堆，然后将后面的数据依次通过这个小根堆：
+ * 比堆顶小的数据直接丢弃，比堆顶大则替换堆顶，然后调整根堆。最后输出小根堆的排序
+ */
+module.exports.topSortViaHeap = function topSortViaHeap(target) {
+  const len = 10;
+  let ret = target.slice(0, len);
+  buildMaxHeap(ret);
+  for(var i = len; i < target.length; i++) {
+    if(target[i] < ret[0]) {
+      ret[0] = target[i];
+      adjustMaxHeap(ret, 0, ret.length);
+    }
+  }
+  sortMaxHeap(ret);
+  return ret;
+}

js/sort.test.js

@@ -40,19 +40,24 @@ function compareArray(a, b) {
   return true;
 }
 
+// 以冒泡排序为基准测试
 function main() {
-  const origin = makeRandomArray(20);
+  const origin = makeRandomArray(30);
   let sorted;
-
   for(let name in sorts) {
     logger.info(`======== ${name} ========`);
     if(!sorted) {
       sorted = sorts[name](origin.slice(0));
       isArraySort(sorted);
     } else {
       const s = sorts[name](origin.slice(0));
-      compareArray(sorted, s)
-        ? logger.ok('success: ' + JSON.stringify(s))
+      let isOk;
+      if(name === 'topSortViaHeap') {
+        isOk = compareArray(sorted.slice(0, 10), s);
+      } else {
+        isOk = compareArray(sorted, s);
+      }
+      isOk ? logger.ok('success: ' + JSON.stringify(s))
         : logger.error('fail: ' + JSON.stringify(s))
     }
   }