--------------------siwuxie095
原地堆排序
程序 1：原地堆排序的实现
SortTestHelper.h：
#ifndef SORTTESTHELPER_H #define SORTTESTHELPER_H
#include <iostream> #include <string> #include <ctime> #include <cassert> #include <algorithm> using namespace std;
//辅助排序测试 namespace SortTestHelper {
//生成测试数据（测试用例）,返回一个随机生成的数组： //生成有n个元素的随机数组，每个元素的随机范围为[rangeL,rangeR] int *generateRandomArray(int n, int rangeL, int rangeR) { //默认rangeL要小于等于rangeR assert(rangeL <= rangeR);
int *arr = new int[n];
//对于数组中的每一个元素，将之随机成为rangeL和rangeR之间的随机数 //先设置随机种子：这里将当前的时间作为种子来进行随机数的设置 srand(time(NULL));
for (int i = 0; i < n; i++) { //rand()函数+百分号+数的范围，即 取中间的一个随机整数，再加上rangeL即可 arr[i] = rand() % (rangeR - rangeL + 1) + rangeL; } return arr; }
//生成一个近乎有序的数组 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; }
template<typename T> void printArray(T arr[], int n) { for (int i = 0; i < n; i++) { cout << arr[i] << " "; } cout << endl; }
//经过排序算法排序后，再次确认是否已经完全排序 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; }
//衡量一个算法的性能如何，最简单的方式就是看这个算法在特定数据集上的执行时间 //（1）传入排序算法的名字，方便打印输出 //（2）传入排序算法本身，即函数指针 //（3）传入测试用例：数组和元素个数 template<typename T> void testSort(string sortName, void(*sort)(T[], int), T arr[], int n) { //在排序前后分别调用clock()函数 //时间差就是该排序算法执行的时钟周期的个数 clock_t startTime = clock(); sort(arr, n); clock_t endTime = clock();
assert(isSorted(arr, n));
//endTime 减去 startTime 转为double类型，除以 CLOCKS_PER_SEC，其中： // //CLOCKS_PER_SEC 是标准库中定义的一个宏，表示每一秒钟所运行的时钟周期 //的个数，而(endTime-startTime)返回的是运行了几个时钟周期 // //这样，最终的结果就是在这段时间中程序执行了多少秒 cout << sortName << "：" << double(endTime - startTime) / CLOCKS_PER_SEC << "s" << endl; }
//复制数组 int *copyIntArray(int a[], int n) { int *arr = new int[n]; //copy()函数在std中： //第一个参数是原数组的头指针， //第二个参数是原数组的尾指针， //第三个参数是目的数组的头指针 // //注意：copy()函数运行时会报错，需要在： //项目->属性->配置属性->C/C++->预处理器->预处理器定义 //在其中添加：_SCL_SECURE_NO_WARNINGS copy(a, a + n, arr); return arr; }
//判断两个数组是否相同 bool areSameIntArrs(int* arr, int* arr2, int n) { //sort()函数需要include<algorithm> sort(arr, arr + n); sort(arr2, arr2 + n); for (int i = 0; i < n; i++) { if (arr[i] != arr2[i]) { return false; } }
return true; } }
#endif |
HeapSort.h：
#ifndef HEAPSORT_H #define HEAPSORT_H
template<typename T> void __shiftDown(T arr[], int n, int k) {
while (2 * k + 1 < n) { int j = 2 * k + 1;
if (j + 1 < n && arr[j + 1] > arr[j]) { j += 1; }
if (arr[k] >= arr[j]) { break; }
swap(arr[k], arr[j]); k = j; } }
//原地堆排序：从小到大进行排序（最大堆） template<typename T> void heapSort(T arr[], int n) { //Heapify操作：将数组构建成堆（堆化） for (int i = (n - 2) / 2; i >= 0; i--) { __shiftDown(arr, n, i); }
//倒序的从最后一个元素开始，进行swap操作 //和Shift Down操作，完成堆排序 for (int i = n - 1; i > 0; i--) { swap(arr[0], arr[i]); __shiftDown(arr, i, 0); } }
//原地堆排序主要使用了 Heapify 算法和 Shift Down 算法 // //关于索引（从0开始）： //（1）parent(i) = (i-1) / 2 //（2）left child(i) = 2 * i + 1 //（3）right child(i) = 2 * i + 2 // //另： //最后一个非叶子节点的索引=(count - 2) / 2 或 count/2 - 1 // //注意： //（1）若要从小到大进行原地排序，只能使用最大堆 //（2）若要从大到小进行原地排序，只能使用最小堆
#endif |
main.cpp：
#include "SortTestHelper.h" #include "HeapSort.h"
int main() { int n = 1000000;
int *arr = SortTestHelper::generateRandomArray(n, 0, n);
SortTestHelper::testSort("Heap Sort", heapSort, arr, n);
delete []arr;
system("pause"); return 0; } |
运行一览：
程序 2：原地堆排序的优化（在程序 1 的基础上，修改 HeapSort.h 即可）
HeapSort.h：
#ifndef HEAPSORT_H #define HEAPSORT_H
//使用插入排序的优化方式进行优化 template<typename T> void __shiftDown(T arr[], int n, int k){
T e = arr[k]; while (2 * k + 1 < n) { int j = 2 * k + 1;
if (j + 1 < n && arr[j + 1] > arr[j]) { j += 1; }
if (e >= arr[j]) { break; }
arr[k] = arr[j]; k = j; }
arr[k] = e; }
//原地堆排序：从小到大进行排序（最大堆） template<typename T> void heapSort(T arr[], int n) { //Heapify操作：将数组构建成堆（堆化） for (int i = (n - 1) / 2; i >= 0; i--) { __shiftDown(arr, n, i); }
//倒序的从最后一个元素开始，进行swap操作 //和Shift Down操作，完成堆排序 for (int i = n - 1; i > 0; i--) { swap(arr[0], arr[i]); __shiftDown(arr, i, 0); } }
//原地堆排序主要使用了 Heapify 算法和 Shift Down 算法 // //关于索引（从0开始）： //（1）parent(i) = (i-1) / 2 //（2）left child(i) = 2 * i + 1 //（3）right child(i) = 2 * i + 2 // //另： //最后一个非叶子节点的索引=(count - 2) / 2 或 count/2 - 1 // //注意： //（1）若要从小到大进行原地排序，只能使用最大堆 //（2）若要从大到小进行原地排序，只能使用最小堆
#endif |
运行一览：
【made by siwuxie095】