C++实现基本排序算法5：堆排序

今天我们开始实现堆排序, 仍然我们使用对数器来测试我们代码的正确性。

1. 基本原理

参考文章:

1. 图解排序算法(三)之堆排序
2. 算法基础–堆排序

2. 代码

#include <assert.h>
#include <iostream>
#include <vector>
#include <cstdlib>
#include <ctime>
#include <algorithm>
#include <functional>

template<typename T>
void swapNumers(std::vector<T>& vec, int i, int j) {
    T temp = vec[i];
    vec[i] = vec[j];
    vec[j] = temp;
}

template<typename T>
bool compare(T a, T b) {
    return a < b;
}

template<typename T>
void rightMethod(std::vector<T>& vec) {
    sort(vec.begin(), vec.end(), compare<T>);
}

template<typename T>
void heapInsert(std::vector<T>& vec, int index) {
    while (vec[index] > vec[(index - 1) / 2]) {    // 当前的新添加的节点比它的父节点数要大,所以的话我们需要进行交换
        swapNumers(vec, index, (index - 1) / 2);
        index = (index - 1) / 2;
    }
}
template<typename T>
void heapFify(std::vector<T>& vec, int index, int heapSize) {
    int left = 2 * index + 1;
    while (left < heapSize) {
        int largest = left + 1 < heapSize && vec[left + 1] > vec[left] ? left + 1 : left; // 求出当前节点叶子节点较大值
        largest = vec[largest] > vec[index] ? largest : index;  // 当前节点和叶子节点较大值比较
        if (largest == index) {
            break;  // 表示我们当前是不需要进行交换的
        }
        swapNumers(vec, index, largest);    // 否则我们是需要进行交换操作的
        index = largest;
        left = index * 2 + 1;
    }
}
template<typename T>
void heapSort(std::vector<T>& vec) {
    int length = vec.size();
    if (length < 2) {
        return;
    }
    for (int i = 0; i < length; ++i) {  // 建立大根堆的过程
        heapInsert(vec, i);
    }
    swapNumers(vec, 0, --length);     // 将大根堆的头节点和当前节点交换,最大值放到最后
    while (length > 0) {
        heapFify(vec, 0, length);   // 进行大根堆的调整
        swapNumers(vec, 0, --length);   // 进行下一个元素的调整
    }

}

template<typename T>
void generateRandomVector(std::vector<T>& vec, int maxSize, int minValue, int maxValue) {
    assert(maxValue > minValue);
    srand((unsigned int)time(nullptr));
    int size = rand() % maxSize + 1;
    vec = std::vector<T> (size, -1);
    for (int i = 0; i < size; ++i) {
        vec[i] = (rand() % (maxValue - minValue)) + minValue + 1;
    }
    return;
}
template<typename T>
bool isEqual(std::vector<T>& vec1, std::vector<T>& vec2) {
    int size1 = vec1.size();
    int size2 = vec2.size();
    if (size1 != size2) {
        return false;
    } else {
        return equal(vec1.begin(), vec1.end(), vec2.begin());
    }
    return true;
}
template<typename T>
void copyVector(std::vector<T>& vec1, std::vector<T>& vec2) {
    if (vec2.size() < 1) {
        return;
    }
    vec1 = std::vector<T> (vec2.size(), -1);    // this is very imporpant!
    for (int i = 0; i < vec2.size(); ++i) {
        vec1[i] = vec2[i];  // attention initial
    }
    // also we can use vec1 = vec2;
}
template<typename T>
void inputVector(std::vector<T>& vec) {
    T data;
    std::cin >> data;
    vec.push_back(data);
    while (std::cin.get() != '\n') {
        std::cin >> data;
        vec.push_back(data);
    }
}
template<typename T>
void display(std::vector<T>& vec) {
    for (auto it: vec) {
        std::cout << it << ',';
    }
    std::cout << "\n";
}
template<typename T>
void testAlgorithm(void (*pTestAlgorithm) (std::vector<T>&)) {
    int testEpoch(100000);
    int maxSize(100);
    int minValue(-100);
    int maxValue(100);
    bool successFlag(true);
    std::clock_t  startTime, endTime;
    startTime = std::clock();
    for (int i = 0; i < testEpoch; ++i) {
        std::vector<T> v1, v2, v3;
        generateRandomVector(v1, maxSize, minValue, maxValue);
        copyVector(v2, v1);
        copyVector(v3, v1);
        rightMethod(v1);
        pTestAlgorithm(v2);
        if (!isEqual(v1, v2)) {
            successFlag = false;
            display(v3);
            break;
        }
        std::vector<T> ().swap(v1);
        std::vector<T> ().swap(v2);
        std::vector<T> ().swap(v3);
    }
    if (successFlag) {
        std::cout << "nice!" << std::endl;
    } else {
        std::cout << "something wrong" << std::endl;
    }
    endTime = std::clock();
    std::cout << "Total usage time is: " << (endTime - startTime) / double(CLOCKS_PER_SEC) << 's' << std::endl;
}
int main() {
    testAlgorithm(heapSort<int>);
//    std::vector<int> vec;
//    inputVector(vec);
//    display(vec);
//    std::cout << "random heap sort:" << std::endl;
//    heapSort(vec);
//    display(vec);
    return 0;
}

OVER