您的位置:首页 > 编程语言 > C语言/C++

常用排序算法C++实现(堆排序,快速排序,归并排序,基数排序)

2015-11-30 12:40 836 查看
#include <iostream>
#include <cstdlib>
#include <ctime>
#include <algorithm>

using namespace std;

const int ARR_COUNT = 5;
const int SIZE = 18;
const int RANGE = 1000;
int arr[6][SIZE];

/*
* heapSort, quickSort, mergeSort, radixSort
*/

/*
* common
*/
void mySwap(int& a, int&b) {
int temp = a;
a = b;
b = temp;
}

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

/*
* heap sort
*/
void balanceMaxHeap(int arr[], const int i, const int size) {
if (i * 2 < size) { //has child
int maxValIndex = i;
if (arr[i * 2] > arr[maxValIndex]) maxValIndex = i * 2;
if (i * 2 + 1 < size && arr[i * 2 + 1] > arr[maxValIndex]) maxValIndex = i * 2 + 1;
if (maxValIndex != i) {
mySwap(arr[i], arr[maxValIndex]);
balanceMaxHeap(arr, maxValIndex, size);
}
}
}

void buildMaxHeap(int arr[], const int size) {
for (int i = size - 1; i >= 0; --i) { //build heap
balanceMaxHeap(arr, i, size);
}
}

void heapSort(int arr[], const int size) {
buildMaxHeap(arr, size);
for (int i = 0; i < size; ++i) { //pop
mySwap(arr[0], arr[size - 1 - i]);
balanceMaxHeap(arr, 0, size - 1 - i);
}
}

/*
* quick sort
*/
int partition(int arr[], const int start, const int end) {
int i = start + rand() * (end - start) / (RAND_MAX + 1);
mySwap(arr[i], arr[end - 1]); //swap with last element
int pos = start;
for (int i = start; i < end - 1; ++i) {
if (arr[i] < arr[end - 1]) mySwap(arr[pos++], arr[i]);
}
mySwap(arr[pos], arr[end - 1]);
return pos;
}

void quickSortCore(int arr[], const int start, const int end) { //[start, end)
if (start + 1 < end) { //at least two elements
int mid = partition(arr, start, end);
quickSortCore(arr, start, mid);
quickSortCore(arr, mid + 1, end);
}
}

void quickSort(int arr[], const int size) {
quickSortCore(arr, 0, size);
}

/*
* merge sort
*/
void mergeSortCore(int arr[], const int start, const int end) { //[start, end)
if (start + 1 < end) { //at least two elements
int mid = start + (end - start) / 2;
mergeSortCore(arr, start, mid);
mergeSortCore(arr, mid, end);

//merge
int start1 = start, start2 = mid;
int* mergeArr = new int[end - start];
int mergeArrStart = 0;
while (start1 < mid && start2 < end) {
if (arr[start1] <= arr[start2]) mergeArr[mergeArrStart++] = arr[start1++];
else mergeArr[mergeArrStart++] = arr[start2++];
}
while (start1 < mid) mergeArr[mergeArrStart++] = arr[start1++];
while (start2 < end) mergeArr[mergeArrStart++] = arr[start2++];
memcpy(arr + start, mergeArr, sizeof(int) * (end - start));
delete[] mergeArr;
}
}

void mergeSort(int arr[], const int size) {
mergeSortCore(arr, 0, size);
}

/*
* radix sort, only effective for uint32_t
*/
void radixSortCore(int arr[], int temp[], const int size, const int offset) {
const int mask = 0xFF;
int cnt[256] = { 0 };
for (int i = 0; i < size; ++i) cnt[(arr[i] >> offset) & mask]++;
for (int i = 1; i < 256; ++i) cnt[i] += cnt[i - 1];
for (int i = size - 1; i >= 0; --i) temp[--cnt[(arr[i] >> offset) & mask]] = arr[i];
}

void radixSort(int arr[], const int size) {
int* temp = new int[size];
radixSortCore(arr, temp, size, 0);
radixSortCore(temp, arr, size, 8);
radixSortCore(arr, temp, size, 16);
radixSortCore(temp, arr, size, 24);

delete[] temp;
}

int main()
{
srand((unsigned int)time(NULL));
for (int i = 0; i < SIZE; ++i) arr[0][i] = rand() * RANGE / (RAND_MAX + 1);
for (int i = 1; i < ARR_COUNT; ++i) memcpy(arr[i], arr[0], sizeof(arr[0]));
cout << "Original array:" << endl;
for (int i = 0; i < ARR_COUNT; ++i) printArr(arr[i], SIZE);

sort(arr[0], arr[0] + SIZE);
heapSort(arr[1], SIZE);
quickSort(arr[2], SIZE);
mergeSort(arr[3], SIZE);
radixSort(arr[4], SIZE);

cout << "After sorting:" << endl;
for (int i = 0; i < ARR_COUNT; ++i) printArr(arr[i], SIZE);

return 0;
}
内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
标签:  排序算法 c语言