C/C++实现堆排序

思想

首先将要排序的数组构建成一个大根堆结构（大根堆（数组实现））
然后交换堆顶和堆的最后一个元素，堆的大小heapSize相应减一，由于堆顶是堆中最大的元素，因此该操作相当于取出最大的元素放到相应位置
继续执行上述操作，直至堆的大小heapSize为零
本文采用了排序对数器进行堆排序正确性验证

相关阅读

堆排序
冒泡排序
选择排序
插入排序
随机快速排序
一维随机数组生成器
归并排序

代码

inputArr()

实现数组输入

void inputArr(int arr[], int size){
    for(int i = 0; i < size; i++)
        cin >> arr[i];
}

outputArr()

实现数组输出

void outputArr(int arr[], int size){
    for(int i = 0; i < size; i++)
        cout << arr[i] << " ";
    cout << endl;
}

swap()

实现交换数组中相应位置的两个数

void swap(int arr[], int i, int j){
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

heapInsert()

实现堆的插入

void heapInsert(int arr[], int index){
    while(arr[index] > arr[(index-1)/2]){
        swap(arr, index, (index-1)/2);
        index = (index-1)/2;
    }
}

heapify()

实现堆的调整

void heapify(int arr[], int index, int heapSize){
    int L = 2*index+1;
    while(L < heapSize){
        int bigLoc = L+1 < heapSize && arr[L+1] > arr[L] ? L+1 : L;
        if(arr[bigLoc] > arr[index]){
            swap(arr, index, bigLoc);
        }else
            break;
        index = bigLoc;
        L = 2*index+1;
    }
}

heapSort()

实现堆排序

void heapSort(int arr[], int size){
    for(int i = 0; i < size; i++){
        heapInsert(arr, i);
    }
    int heapSize = size;
    swap(arr, 0, --heapSize);
    while(heapSize > 0){
        heapify(arr, 0, heapSize);
        swap(arr, 0, --heapSize);
    }
}

完整代码

#include <bits/stdc++.h>
using namespace std;

void inputArr(int arr[], int size){
    for(int i = 0; i < size; i++)
        cin >> arr[i];
}

void outputArr(int arr[], int size){
    for(int i = 0; i < size; i++)
        cout << arr[i] << " ";
    cout << endl;
}

void swap(int arr[], int i, int j){
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

void heapInsert(int arr[], int index){
    while(arr[index] > arr[(index-1)/2]){
        swap(arr, index, (index-1)/2);
        index = (index-1)/2;
    }
}

void heapify(int arr[], int index, int heapSize){
    int L = 2*index+1;
    while(L < heapSize){
        int bigLoc = L+1 < heapSize && arr[L+1] > arr[L] ? L+1 : L;
        if(arr[bigLoc] > arr[index]){
            swap(arr, index, bigLoc);
        }else
            break;
        index = bigLoc;
        L = 2*index+1;
    }
}

void heapSort(int arr[], int size){
    for(int i = 0; i < size; i++){
        heapInsert(arr, i);
    }
    int heapSize = size;
    swap(arr, 0, --heapSize);
    while(heapSize > 0){
        heapify(arr, 0, heapSize);
        swap(arr, 0, --heapSize);
    }
}

int randSize;

//生成随机数组
template <class T>
T* creatArr(int size, int value){
    //srand((unsigned)time(NULL));
    srand(rand());
    randSize = rand()%(size+1)+1;
    T *arr = new T [randSize];
    for(int i = 0; i < randSize; i++){
        arr[i] = rand()%(value+1) - rand()%(value+1);
        cout << arr[i] << " ";
    }
    cout << endl;
    return arr;
}

//输出数组
template<class T>
void outputArr(T arr[], int size){
    for(int i = 0; i < size; i++){
        cout << arr[i] << " ";
    }
    cout << endl;
}

//拷贝数组
template<class T>
T* copyArr(T arr[], int size){
    T* newArr = new T [size];
    for(int i = 0; i < size; i++){
        newArr[i] = arr[i];
    }
    return newArr;
}

//冒泡排序
template <class T>
void bubbleSort(T arr[], int size){
    for(int end = size -1; end > 0; end--){
        for(int i = 0; i < end; i++){
            if(arr[i] > arr[i+1]){
                T temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }
        }
    }
}

//插入排序
template <class T>
void insertSort(T arr[], int size){
    for(int i = 0; i < size; i++){
        for(int j = i-1; j>=0 && arr[j]>arr[j+1]; j--){
            T temp = arr[j+1];
            arr[j+1] = arr[j];
            arr[j] = temp;
        }
    }
}

//数组判等
template <class T>
bool isEqual(T a[], T b[], int size){
    for(int i = 0; i < size; i++){
        if(a[i] != b[i])
            return false;
    }
    return true;
}


template <class T>
 void merge(T arr[], int L, int mid, int R){
    int size = R-L+1;
    T *helpArr = new T [size];
    int p1 = L;
    int p2 = mid+1;
    int i = 0;
    while(p1<=mid && p2<=R){
        helpArr[i++] = arr[p1]<arr[p2] ? arr[p1++]:arr[p2++];
    }
    while(p1<=mid){
        helpArr[i++] = arr[p1++];
    }
    while(p2<=R){
        helpArr[i++] = arr[p2++];
    }
    for(i = 0; i < size; i++){
        arr[L+i] = helpArr[i];
    }
 }

 template <class T>
 void sortProcess(T arr[], int L, int R){
    if(L==R)
        return;
    int mid = (L+R)/2;
    sortProcess(arr, L, mid);
    sortProcess(arr, mid+1, R);
    merge(arr, L, mid, R);
 }

 //归并排序
 template <class T>
 void mergeSort(T arr[], int size){
    sortProcess(arr, 0, size-1);
 }

int main(){
    int testTime = 50000;
    int size = 10, value = 1000;
    while(testTime--){
        int *arr = creatArr<int>(size, value);
        cout << randSize << endl;
        outputArr(arr, randSize);
        int *a = copyArr(arr, randSize);
        int *b = copyArr(arr, randSize);
        bubbleSort(a, randSize);
        heapSort(b, randSize);
        if(!isEqual<int>(a, b, randSize)){
            cout << "Error!" << endl;
            outputArr(a, randSize);
            outputArr(b, randSize);
            break;
        }else{
            outputArr(a, randSize);
            cout << "Nice!" << endl;
        }
    }
}