常见排序算法

#include <iostream>
using namespace std;

// 打印数组
void printArray(int A[], int N)
{
	for (int i = 0; i < N; i++) {
		cout << A[i] << " ";
	}
}

// 冒泡排序
void bubleSort(int A[], int N)
{
	bool swapped;
	for (int i = 0; i < N - 1; i++) {
		swapped = false;
		for (int j = 0; j < N - i - 1; j++) {
			if (A[j] > A[j + 1]) {
				swap(A[j], A[j + 1]);
				swapped = true;
			}
		}
		if (!swapped) {
			break;
		}
	}
}

// 插入排序
void insertSort(int A[], int N)
{
	for (int i = 1; i < N; i++) {
		int val = A[i];
		int j = i - 1;
		for (; j >= 0 && A[j] > val; j--) {
			A[j + 1] = A[j];
		}
		A[j + 1] = val;
	}
}

// 选择排序
void selectionSort(int A[], int N)
{
	for (int i = 0; i < N - 1; i++) {
		int min = i;
		for (int j = i + 1; j < N; j++) {
			if (A[j] < A[min]) {
				min = j;
			}
		}
		swap(A[i], A[min]);
	}
}

// 希尔排序
void shellSort(int A[], int N)
{
	for (int increment = N / 2; increment > 0; increment /= 2) {
		// 对每个子数组执行插入排序
		for (int i = increment; i < N; i++) {
			int tmp = A[i];
			int j;
			for (j = i; j >= increment && A[j - increment] > tmp; j -= increment) {
				A[j] = A[j - increment];
			}
			A[j] = tmp;
		}
	}
}

// 下沉操作，用于维护堆的性质
void heapify(int arr[], int n, int i)
{
	int largest = i; // 根节点
	int left = 2 * i + 1;
	int right = 2 * i + 2;

	if (left < n && arr[left] > arr[largest]) {
		largest = left;
	}

	if (right < n && arr[right] > arr[largest]) {
		largest = right;
	}

	if (largest != i) {
		swap(arr[i], arr[largest]);
		heapify(arr, n, largest);
	}
}

// 堆排序
void heapSort(int A[], int N)
{
	// 构建堆，大顶堆
	for (int i = N / 2 - 1; i >= 0; i--) {
		heapify(A, N, i);
	}

	// 逐一从堆中取出最大值，将其放入已排序部分，再调整堆
	for (int i = N - 1; i > 0; i--) {
		swap(A[0], A[i]);
		heapify(A, i, 0); // 调整堆
	}
}

// 将数组分为小于基准和大于基准的两部分，返回基准的索引位置
int partion(int arr[], int left, int right)
{
	int pivot = arr[right]; // 选择最后一个元素作为基准
	int i = left;
	int j = right - 1;

	for (;; i++, j--) {
		while (i <= right && arr[i] < pivot) { i++; }
		while (j >= left && arr[j] > pivot) { j--; }
		if (i < j) {
			swap(arr[i], arr[j]);
		} else {
			break;
		}
	}

	swap(arr[i], arr[right]);

	return i;
}

// 快速排序
void quickSort(int A[], int left, int right)
{
	if (left < right) {
		// 找到基准索引的位置
		int pivot = partion(A, left, right);

		// 递归地对左右子数组执行快速排序
		quickSort(A, left, pivot - 1);
		quickSort(A, pivot + 1, right);
	}
}

// 合并两个子数组
void merge(int arr[], int tmpArr[], int left, int right, int rightEnd)
{
	int leftEnd = right - 1;
	int tmp = left;
	int num = rightEnd - left + 1;

	while (left <= leftEnd && right <= rightEnd) {
		if (arr[left] < arr[right]) {
			tmpArr[tmp++] = arr[left++];
		} else {
			tmpArr[tmp++] = arr[right++];
		}
	}

	while (left <= leftEnd) {
		tmpArr[tmp++] = arr[left++];
	}
	while (right <= rightEnd) {
		tmpArr[tmp++] = arr[right++];
	}

	for (int i = 0; i < num; i++, rightEnd--) {
		arr[rightEnd] = tmpArr[rightEnd];
	}
}

void msort(int A[], int tmpArr[], int left, int right)
{
	if (left < right) {
		int middle = left + (right - left) / 2;

		// 递归地对左右两部分进行排序
		msort(A, tmpArr, left, middle);
		msort(A, tmpArr, middle + 1, right);

		// 合并已排序地两部分
		merge(A, tmpArr, left, middle + 1, right);
	}
}

// 归并排序
void mergeSort(int A[], int N)
{
	int* tmpArr = new int[N];
	msort(A, tmpArr, 0, N - 1);
	delete[] tmpArr;
}

int main()
{
	int A[10]{ 22,1,4,18,6,51,9,7,10,3 };

	printArray(A, 10);
	cout << endl;

	//insertSort(A, 10);
	//bubleSort(A, 10);
	//selectionSort(A, 10);
	//shellSort(A, 10);
	//heapSort(A, 10);
	//quickSort(A, 0, 9);
	mergeSort(A, 10);

	printArray(A, 10);
	cout << endl;

	return 0;
}