堆排序优化，以及最小堆

Author: tianqing.liang

12-Heap/HeapSort.dart

@@ -2,19 +2,53 @@ import 'MaxHeap.dart';
 
 /**
  * 堆排序
+ * 以及堆排序优化
  */
 class HeapSort {
+  HeapSort() {}
 
-  HeapSort() {
-
-  }
   static sort<E extends Comparable<E>>(List data) {
     MaxHeap<E> maxHeap = MaxHeap.withCapacity(10);
-    for (E e in data){
+    for (E e in data) {
       maxHeap.add(e);
-    }
-    for (int i = data.length - 1; i >= 0; i --)
+    };
+
+    for (int i = data.length - 1; i >= 0; i--) {
       data[i] = maxHeap.extractMax();
+    }
+  }
+
+  static sort2<T extends Comparable<T>>(List data) {
+    if (data.length <= 1) return;
+
+    for (int i = (data.length - 2) / 2 as int; i >= 0; i--){
+      _siftDown(data, i, data.length);
+    }
+    for (int i = data.length - 1; i >= 0; i--) {
+      _swap(data, 0, i);
+      _siftDown(data, 0, i);
+    }
   }
 
-}
+  // 对 data[0, n) 所形成的最大堆中，索引 k 的元素，执行 siftDown
+  static _siftDown<T>(List? data, int k, int n) {
+    while (2 * k + 1 < n) {
+      int j = 2 * k + 1; // 在此轮循环中,data[k]和data[j]交换位置
+      if (j + 1 < n && data![j + 1].compareTo(data[j]) > 0) {
+        j++;
+      }
+      // data[j] 是 leftChild 和 rightChild 中的最大值
+      if (data![k].compareTo(data[j]) >= 0) {
+        break;
+      }
+      _swap(data, k, j);
+      k = j;
+    }
+  }
+
+  static _swap<E>(List arr, int i, int j) {
+    E t = arr[i];
+    arr[i] = arr[j];
+    arr[j] = t;
+  }
+}

12-Heap/MinHeap.dart

@@ -0,0 +1,104 @@
+/**
+ * 最小堆
+ */
+class MinHeap<E extends Comparable<E>> {
+  List? data;
+
+  MinHeap.withCapacity(int capacity) {
+    data = List.filled(capacity, E, growable: true);
+  }
+
+  MinHeap.withEmpty() {
+    data = List.empty(growable: true);
+  }
+
+  // 返回堆中的元素个数
+  int? size() {
+    return data!.length;
+  }
+
+  // 返回一个布尔值, 表示堆中是否为空
+  bool isEmpty() {
+    return data!.isEmpty;
+  }
+
+  int _parent(int index) {
+    if (index == 0) {
+      throw Exception("index-0 doesn't have parent.");
+    }
+    return ((index - 1) / 2).toInt();
+  }
+
+  // 返回完全二叉树的数组表示中，一个索引所表示的元素的左孩子节点的索引
+  int _leftChild(int index) {
+    return index * 2 + 1;
+  }
+
+  // 返回完全二叉树的数组表示中，一个索引所表示的元素的右孩子节点的索引
+  int _rightChild(int index) {
+    return index * 2 + 2;
+  }
+
+  // 向堆中添加元素
+  add(E e) {
+    data!.add(e);
+    siftUp(data!.length - 1);
+  }
+
+  siftUp(int k) {
+    while (k > 0 && data![_parent(k)].compareTo(data![k]) > 0) {
+      _swap(k, _parent(k));
+      k = _parent(k);
+    }
+  }
+
+  // 看堆中的最大元素
+  E findMin() {
+    if (data!.length == 0)
+      throw new Exception("Can not findMax when heap is empty.");
+    return data![0];
+  }
+
+  // 取出堆中最大元素
+  E extractMax() {
+    E ret = findMin();
+    _swap(0, data!.length - 1);
+    data!.removeLast();
+    _siftDown(0);
+
+    return ret;
+  }
+
+  _siftDown(int k) {
+    while (_leftChild(k) < data!.length) {
+      int j = _leftChild(k); // 在此轮循环中,data[k]和data[j]交换位置
+      if (j + 1 < data!.length && data![j + 1].compareTo(data![j]) < 0) {
+        j++;
+      }
+      // data[j] 是 leftChild 和 rightChild 中的最大值
+      if (data![k].compareTo(data![j]) <= 0) {
+        break;
+      }
+      _swap(k, j);
+      k = j;
+    }
+  }
+
+  // 取出堆中的最大元素，并且替换成元素e
+  E replace(E e) {
+    E ret = findMin();
+    data![0] = e;
+    ;
+    _siftDown(0);
+    return ret;
+  }
+
+  _swap(int i, int j) {
+    if (i < 0 || i >= data!.length || j < 0 || j >= data!.length)
+      throw new Exception("Index is illegal.");
+
+    E t = data![i];
+    data![i] = data![j];
+    data![j] = t;
+  }
+}

README.md

@@ -13,7 +13,7 @@
 9. 二分搜索,二分搜索优化
 10. 二分搜索树,二分搜索树搜索、移除最大最小值
 11. 集合 和 映射
-12. 堆 
+12. 堆
 
 #### SDK版本
 1. 版本：2.12.3