常用排序算法C++实现（堆排序，快速排序，归并排序，基数排序）

#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;
}