update index heap

Author: Zu3zz

README.md

@@ -71,3 +71,7 @@
   - 二叉堆
   > 堆 是一个完全二叉树
   > ![完全二叉树](./static/complete-bin-tree.png)
+
+- 排序算法总结
+  > ![排序算法总结](./static/sort-solution.png)
+  

heap-sort/06-Index-Heap/SortTtestHelper.h

@@ -0,0 +1,120 @@
+//
+// Created by 3zz.
+//
+
+#ifndef INC_08_INDEX_HEAP_SORTTESTHELPER_H
+#define INC_08_INDEX_HEAP_SORTTESTHELPER_H
+
+#include <iostream>
+#include <algorithm>
+#include <string>
+#include <ctime>
+#include <cassert>
+#include <string>
+
+using namespace std;
+
+namespace SortTestHelper
+{
+
+// 生成有n个元素的随机数组,每个元素的随机范围为[rangeL, rangeR]
+int *generateRandomArray(int n, int range_l, int range_r)
+{
+
+  int *arr = new int[n];
+
+  srand(time(NULL));
+  for (int i = 0; i < n; i++)
+    arr[i] = rand() % (range_r - range_l + 1) + range_l;
+  return arr;
+}
+
+// 生成一个近乎有序的数组
+// 首先生成一个含有[0...n-1]的完全有序数组, 之后随机交换swapTimes对数据
+// swapTimes定义了数组的无序程度
+int *generateNearlyOrderedArray(int n, int swapTimes)
+{
+
+  int *arr = new int[n];
+  for (int i = 0; i < n; i++)
+    arr[i] = i;
+
+  srand(time(NULL));
+  for (int i = 0; i < swapTimes; i++)
+  {
+    int posx = rand() % n;
+    int posy = rand() % n;
+    swap(arr[posx], arr[posy]);
+  }
+
+  return arr;
+}
+
+// 拷贝整型数组a中的所有元素到一个新的数组, 并返回新的数组
+int *copyIntArray(int a[], int n)
+{
+
+  int *arr = new int[n];
+  //* 在VS中, copy函数被认为是不安全的, 请大家手动写一遍for循环:)
+  copy(a, a + n, arr);
+  return arr;
+}
+
+// 打印arr数组的所有内容
+template <typename T>
+void printArray(T arr[], int n)
+{
+
+  for (int i = 0; i < n; i++)
+    cout << arr[i] << " ";
+  cout << endl;
+
+  return;
+}
+
+// 判断arr数组是否有序
+template <typename T>
+bool isSorted(T arr[], int n)
+{
+
+  for (int i = 0; i < n - 1; i++)
+    if (arr[i] > arr[i + 1])
+      return false;
+
+  return true;
+}
+
+// 测试sort排序算法排序arr数组所得到结果的正确性和算法运行时间
+// 将算法的运行时间打印在控制台上
+template <typename T>
+void testSort(const string &sortName, void (*sort)(T[], int), T arr[], int n)
+{
+
+  clock_t startTime = clock();
+  sort(arr, n);
+  clock_t endTime = clock();
+  cout << sortName << " : " << double(endTime - startTime) / CLOCKS_PER_SEC << " s" << endl;
+
+  assert(isSorted(arr, n));
+
+  return;
+}
+
+// 测试sort排序算法排序arr数组所得到结果的正确性和算法运行时间
+// 将算法的运行时间以double类型返回, 单位为秒(s)
+template <typename T>
+double testSort(void (*sort)(T[], int), T arr[], int n)
+{
+
+  clock_t startTime = clock();
+  sort(arr, n);
+  clock_t endTime = clock();
+
+  assert(isSorted(arr, n));
+
+  return double(endTime - startTime) / CLOCKS_PER_SEC;
+}
+
+}; // namespace SortTestHelper
+
+#endif //INC_08_INDEX_HEAP_SORTTESTHELPER_H

heap-sort/06-Index-Heap/main.cpp

@@ -0,0 +1,216 @@
+#include <iostream>
+#include <cassert>
+#include "SortTestHelper.h"
+
+using namespace std;
+
+// 最大索引堆
+template <typename Item>
+class IndexMaxHeap
+{
+
+private:
+  Item *data;   // 最大索引堆中的数据
+  int *indexes; // 最大索引堆中的索引
+
+  int count;
+  int capacity;
+
+  // 索引堆中, 数据之间的比较根据data的大小进行比较, 但实际操作的是索引
+  void shiftUp(int k)
+  {
+
+    while (k > 1 && data[indexes[k / 2]] < data[indexes[k]])
+    {
+      swap(indexes[k / 2], indexes[k]);
+      k /= 2;
+    }
+  }
+
+  // 索引堆中, 数据之间的比较根据data的大小进行比较, 但实际操作的是索引
+  void shiftDown(int k)
+  {
+
+    while (2 * k <= count)
+    {
+      int j = 2 * k;
+      if (j + 1 <= count && data[indexes[j + 1]] > data[indexes[j]])
+        j += 1;
+
+      if (data[indexes[k]] >= data[indexes[j]])
+        break;
+
+      swap(indexes[k], indexes[j]);
+      k = j;
+    }
+  }
+
+public:
+  // 构造函数, 构造一个空的索引堆, 可容纳capacity个元素
+  IndexMaxHeap(int capacity)
+  {
+
+    data = new Item[capacity + 1];
+    indexes = new int[capacity + 1];
+
+    count = 0;
+    this->capacity = capacity;
+  }
+
+  ~IndexMaxHeap()
+  {
+    delete[] data;
+    delete[] indexes;
+  }
+
+  // 返回索引堆中的元素个数
+  int size()
+  {
+    return count;
+  }
+
+  // 返回一个布尔值, 表示索引堆中是否为空
+  bool isEmpty()
+  {
+    return count == 0;
+  }
+
+  // 向最大索引堆中插入一个新的元素, 新元素的索引为i, 元素为item
+  // 传入的i对用户而言,是从0索引的
+  void insert(int i, Item item)
+  {
+    assert(count + 1 <= capacity);
+    assert(i + 1 >= 1 && i + 1 <= capacity);
+
+    i += 1;
+    data[i] = item;
+    indexes[count + 1] = i;
+    count++;
+
+    shiftUp(count);
+  }
+
+  // 从最大索引堆中取出堆顶元素, 即索引堆中所存储的最大数据
+  Item extractMax()
+  {
+    assert(count > 0);
+
+    Item ret = data[indexes[1]];
+    swap(indexes[1], indexes[count]);
+    count--;
+    shiftDown(1);
+    return ret;
+  }
+
+  // 从最大索引堆中取出堆顶元素的索引
+  int extractMaxIndex()
+  {
+    assert(count > 0);
+
+    int ret = indexes[1] - 1;
+    swap(indexes[1], indexes[count]);
+    count--;
+    shiftDown(1);
+    return ret;
+  }
+
+  // 获取最大索引堆中的堆顶元素
+  Item getMax()
+  {
+    assert(count > 0);
+    return data[indexes[1]];
+  }
+
+  // 获取最大索引堆中的堆顶元素的索引
+  int getMaxIndex()
+  {
+    assert(count > 0);
+    return indexes[1] - 1;
+  }
+
+  // 获取最大索引堆中索引为i的元素
+  Item getItem(int i)
+  {
+    assert(i + 1 >= 1 && i + 1 <= capacity);
+    return data[i + 1];
+  }
+
+  // 将最大索引堆中索引为i的元素修改为newItem
+  void change(int i, Item newItem)
+  {
+
+    i += 1;
+    data[i] = newItem;
+
+    // 找到indexes[j] = i, j表示data[i]在堆中的位置
+    // 之后shiftUp(j), 再shiftDown(j)
+    for (int j = 1; j <= count; j++)
+      if (indexes[j] == i)
+      {
+        shiftUp(j);
+        shiftDown(j);
+        return;
+      }
+  }
+
+  // 测试索引堆中的索引数组index
+  // 注意:这个测试在向堆中插入元素以后, 不进行extract操作有效
+  bool testIndexes()
+  {
+
+    int *copyIndexes = new int[count + 1];
+
+    for (int i = 0; i <= count; i++)
+      copyIndexes[i] = indexes[i];
+
+    copyIndexes[0] = 0;
+    std::sort(copyIndexes, copyIndexes + count + 1);
+
+    // 在对索引堆中的索引进行排序后, 应该正好是1...count这count个索引
+    bool res = true;
+    for (int i = 1; i <= count; i++)
+      if (copyIndexes[i - 1] + 1 != copyIndexes[i])
+      {
+        res = false;
+        break;
+      }
+
+    delete[] copyIndexes;
+
+    if (!res)
+    {
+      cout << "Error!" << endl;
+      return false;
+    }
+
+    return true;
+  }
+};
+
+// 使用最大索引堆进行堆排序, 来验证我们的最大索引堆的正确性
+// 最大索引堆的主要作用不是用于排序, 我们在这里使用排序只是为了验证我们的最大索引堆实现的正确性
+// 在后续的图论中, 无论是最小生成树算法, 还是最短路径算法, 我们都需要使用索引堆进行优化:)
+template <typename T>
+void heapSortUsingIndexMaxHeap(T arr[], int n)
+{
+
+  IndexMaxHeap<T> indexMaxHeap = IndexMaxHeap<T>(n);
+  for (int i = 0; i < n; i++)
+    indexMaxHeap.insert(i, arr[i]);
+  assert(indexMaxHeap.testIndexes());
+
+  for (int i = n - 1; i >= 0; i--)
+    arr[i] = indexMaxHeap.extractMax();
+}
+
+int main()
+{
+
+  int n = 1000000;
+
+  int *arr = SortTestHelper::generateRandomArray(n, 0, n);
+  SortTestHelper::testSort("Heap Sort Using Index-Max-Heap", heapSortUsingIndexMaxHeap, arr, n);
+  delete[] arr;
+
+  return 0;
+}