update heap sort

Author: Zu3zz

heap-sort/03-MaxHeap-Shift-Down/main

@@ -0,0 +1,114 @@
+//
+// Created by 3zz.
+//
+
+#ifndef INC_06_HEAP_SORT_HEAP_H
+#define INC_06_HEAP_SORT_HEAP_H
+
+#include <algorithm>
+#include <cassert>
+
+using namespace std;
+
+template <typename Item>
+class MaxHeap
+{
+
+private:
+  Item *data;
+  int count;
+  int capacity;
+
+  void shiftUp(int k)
+  {
+    while (k > 1 && data[k / 2] < data[k])
+    {
+      swap(data[k / 2], data[k]);
+      k /= 2;
+    }
+  }
+
+  void shiftDown(int k)
+  {
+    while (2 * k <= count)
+    {
+      int j = 2 * k;
+      if (j + 1 <= count && data[j + 1] > data[j])
+        j++;
+      if (data[k] >= data[j])
+        break;
+      swap(data[k], data[j]);
+      k = j;
+    }
+  }
+
+public:
+  // 构造函数, 构造一个空堆, 可容纳capacity个元素
+  MaxHeap(int capacity)
+  {
+    data = new Item[capacity + 1];
+    count = 0;
+    this->capacity = capacity;
+  }
+
+  // 构造函数, 通过一个给定数组创建一个最大堆
+  // 该构造堆的过程, 时间复杂度为O(n)
+  MaxHeap(Item arr[], int n)
+  {
+    data = new Item[n + 1];
+    capacity = n;
+
+    for (int i = 0; i < n; i++)
+      data[i + 1] = arr[i];
+    count = n;
+
+    for (int i = count / 2; i >= 1; i--)
+      shiftDown(i);
+  }
+
+  ~MaxHeap()
+  {
+    delete[] data;
+  }
+
+  // 返回堆中的元素个数
+  int size()
+  {
+    return count;
+  }
+
+  // 返回一个布尔值, 表示堆中是否为空
+  bool isEmpty()
+  {
+    return count == 0;
+  }
+
+  // 像最大堆中插入一个新的元素 item
+  void insert(Item item)
+  {
+    assert(count + 1 <= capacity);
+    data[count + 1] = item;
+    shiftUp(count + 1);
+    count++;
+  }
+
+  // 从最大堆中取出堆顶元素, 即堆中所存储的最大数据
+  Item extractMax()
+  {
+    assert(count > 0);
+    Item ret = data[1];
+    swap(data[1], data[count]);
+    count--;
+    shiftDown(1);
+    return ret;
+  }
+
+  // 获取最大堆中的堆顶元素
+  Item getMax()
+  {
+    assert(count > 0);
+    return data[1];
+  }
+};
+
+#endif //INC_06_HEAP_SORT_HEAP_H

heap-sort/05-Heap-Sort/Heap.h

@@ -0,0 +1,39 @@
+//
+// Created by liuyubobobo on 8/16/16.
+//
+
+#ifndef INC_06_HEAP_SORT_HEAPSORT_H
+#define INC_06_HEAP_SORT_HEAPSORT_H
+
+#include "Heap.h"
+
+using namespace std;
+
+// heapSort1, 将所有的元素依次添加到堆中, 在将所有元素从堆中依次取出来, 即完成了排序
+// 无论是创建堆的过程, 还是从堆中依次取出元素的过程, 时间复杂度均为O(nlogn)
+// 整个堆排序的整体时间复杂度为O(nlogn)
+template <typename T>
+void heapSort1(T arr[], int n)
+{
+
+  MaxHeap<T> maxheap = MaxHeap<T>(n);
+  for (int i = 0; i < n; i++)
+    maxheap.insert(arr[i]);
+
+  for (int i = n - 1; i >= 0; i--)
+    arr[i] = maxheap.extractMax();
+}
+
+// heapSort2, 借助我们的heapify过程创建堆
+// 此时, 创建堆的过程时间复杂度为O(n), 将所有元素依次从堆中取出来, 实践复杂度为O(nlogn)
+// 堆排序的总体时间复杂度依然是O(nlogn), 但是比上述heapSort1性能更优, 因为创建堆的性能更优
+template <typename T>
+void heapSort2(T arr[], int n)
+{
+
+  MaxHeap<T> maxheap = MaxHeap<T>(arr, n);
+  for (int i = n - 1; i >= 0; i--)
+    arr[i] = maxheap.extractMax();
+}
+
+#endif //INC_06_HEAP_SORT_HEAPSORT_H

heap-sort/05-Heap-Sort/HeapSort.h

@@ -0,0 +1,48 @@
+//
+// Created by 3zz.
+//
+
+#ifndef INC_06_HEAP_SORT_INSERTIONSORT_H
+#define INC_06_HEAP_SORT_INSERTIONSORT_H
+
+#include <iostream>
+#include <algorithm>
+
+using namespace std;
+
+template <typename T>
+void insertionSort(T arr[], int n)
+{
+
+  for (int i = 1; i < n; i++)
+  {
+
+    T e = arr[i];
+    int j;
+    for (j = i; j > 0 && arr[j - 1] > e; j--)
+      arr[j] = arr[j - 1];
+    arr[j] = e;
+  }
+
+  return;
+}
+
+// 对arr[l...r]范围的数组进行插入排序
+template <typename T>
+void insertionSort(T arr[], int l, int r)
+{
+
+  for (int i = l + 1; i <= r; i++)
+  {
+
+    T e = arr[i];
+    int j;
+    for (j = i; j > l && arr[j - 1] > e; j--)
+      arr[j] = arr[j - 1];
+    arr[j] = e;
+  }
+
+  return;
+}
+
+#endif //INC_06_HEAP_SORT_INSERTIONSORT_H

heap-sort/05-Heap-Sort/InsertionSort.h

@@ -0,0 +1,84 @@
+//
+// Created by liuyubobobo on 8/11/16.
+//
+
+#ifndef INC_06_HEAP_SORT_MERGESORT_H
+#define INC_06_HEAP_SORT_MERGESORT_H
+
+#include <iostream>
+#include <algorithm>
+#include "InsertionSort.h"
+
+using namespace std;
+
+// 将arr[l...mid]和arr[mid+1...r]两部分进行归并
+// 其中aux为完成merge过程所需要的辅助空间
+template <typename T>
+void __merge(T arr[], T aux[], int l, int mid, int r)
+{
+
+  // 由于aux的大小和arr一样, 所以我们也不需要处理aux索引的偏移量
+  // 进一步节省了计算量:)
+  for (int i = l; i <= r; i++)
+    aux[i] = arr[i];
+
+  // 初始化，i指向左半部分的起始索引位置l；j指向右半部分起始索引位置mid+1
+  int i = l, j = mid + 1;
+  for (int k = l; k <= r; k++)
+  {
+    if (i > mid)
+    { // 如果左半部分元素已经全部处理完毕
+      arr[k] = aux[j];
+      j++;
+    }
+    else if (j > r)
+    { // 如果右半部分元素已经全部处理完毕
+      arr[k] = aux[i];
+      i++;
+    }
+    else if (aux[i] < aux[j])
+    { // 左半部分所指元素 < 右半部分所指元素
+      arr[k] = aux[i];
+      i++;
+    }
+    else
+    { // 左半部分所指元素 >= 右半部分所指元素
+      arr[k] = aux[j];
+      j++;
+    }
+  }
+}
+
+// 使用优化的归并排序算法, 对arr[l...r]的范围进行排序
+// 其中aux为完成merge过程所需要的辅助空间
+template <typename T>
+void __mergeSort(T arr[], T aux[], int l, int r)
+{
+  // 对于小规模数组, 使用插入排序
+  if (r - l <= 15)
+  {
+    insertionSort(arr, l, r);
+    return;
+  }
+  int mid = (l + r) / 2;
+  __mergeSort(arr, aux, l, mid);
+  __mergeSort(arr, aux, mid + 1, r);
+
+  // 对于arr[mid] <= arr[mid+1]的情况,不进行merge
+  // 对于近乎有序的数组非常有效,但是对于一般情况,有一定的性能损失
+  if (arr[mid] > arr[mid + 1])
+    __merge(arr, aux, l, mid, r);
+}
+
+template <typename T>
+void mergeSort(T arr[], int n)
+{
+
+  // 在 mergeSort中, 我们一次性申请aux空间,
+  // 并将这个辅助空间以参数形式传递给完成归并排序的各个子函数
+  T *aux = new T[n];
+  __mergeSort(arr, aux, 0, n - 1);
+  delete[] aux; // 使用C++, new出来的空间不要忘记释放掉:)
+}
+
+#endif //INC_06_HEAP_SORT_MERGESORT_H

heap-sort/05-Heap-Sort/MergeSort.h

@@ -0,0 +1,56 @@
+//
+// Created by liuyubobobo on 8/11/16.
+//
+
+#ifndef INC_06_HEAP_SORT_QUICKSORT_H
+#define INC_06_HEAP_SORT_QUICKSORT_H
+
+#include <iostream>
+#include <ctime>
+#include <algorithm>
+#include "InsertionSort.h"
+
+using namespace std;
+
+// 对arr[l...r]部分进行partition操作
+// 返回p, 使得arr[l...p-1] < arr[p] ; arr[p+1...r] > arr[p]
+template <typename T>
+int _partition(T arr[], int l, int r)
+{
+  // 随机在arr[l...r]的范围中, 选择一个数值作为标定点pivot
+  swap(arr[l], arr[rand() % (r - l + 1) + l]);
+  T v = arr[l];
+  int j = l;
+  for (int i = l + 1; i <= r; i++)
+    if (arr[i] < v)
+    {
+      j++;
+      swap(arr[j], arr[i]);
+    }
+  swap(arr[l], arr[j]);
+  return j;
+}
+
+// 对arr[l...r]部分进行快速排序
+template <typename T>
+void _quickSort(T arr[], int l, int r)
+{
+  // 对于小规模数组, 使用插入排序进行优化
+  if (r - l <= 15)
+  {
+    insertionSort(arr, l, r);
+    return;
+  }
+  int p = _partition(arr, l, r);
+  _quickSort(arr, l, p - 1);
+  _quickSort(arr, p + 1, r);
+}
+
+template <typename T>
+void quickSort(T arr[], int n)
+{
+  srand(time(NULL));
+  _quickSort(arr, 0, n - 1);
+}
+
+#endif //INC_06_HEAP_SORT_QUICKSORT_H