基础排序算法

冒泡排序

void BubbleSort(int *array, int size) {
	for (int i = 0; i < size; i++) {
		bool isSorted = true;
		for (int j = 0; j < size - 1 - i; j++) {
			if (array[j] > array[j + 1]) {
				swap(array[j], array[j + 1]);
				isSorted = false;
			}
		}
		if (isSorted) break;
	}
}

选择排序

void SelectSort(int *array, int size) {
	for (int i = 0; i < size; i++) {
		int minIdx = i;
		for (int j = i + 1; j < size; j++) {
			if (array[j] < array[minIdx]) minIdx = j;
		}
		swap(array[i], array[minIdx]);
	}
}

插入排序

void InsertSort(int *array, int size) {
	for (int i = 1; i < size; i++) {
		int value = array[i];
		int j = i - 1;
		for (; j >= 0; j--) {
			if (array[j] <= value) break;
			array[j + 1] = array[j];
		}
		array[j + 1] = value;
	}
}

希尔排序

void ShellSort(int *array, int size) {
	int gap = size / 2;
	while (gap > 0) {
		for (int i = gap; i < size; i++) {
			int value = array[i];
			int j = i - gap;
			for (; j >= 0; j -= gap) {
				if (array[j] <= value) break;
				array[j + gap] = array[j];
			}
			array[j + gap] = value;
		}
		gap /= 2;
	}
}

归并排序

void Merge(int *array, int low, int mid, int high) {
	int *tmpArray = new int[high - low + 1];

	int i = low, j = mid + 1, k = 0;
	while (i <= mid && j <= high) {
		tmpArray [k++] = (array[i] <= array[j]) ? array[i++] : array[j++];
	}
	while (i <= mid) tmpArray [k++] = array[i++];
	while (j <= high) tmpArray [k++] = array[j++];

	for (int i = low; i <= high; i++) {
		array[i] = tmpArray [i - low];
	}

	delete[] tmpArray ;
}
void MergeSort(int *array, int low, int high) {
	if (low >= high) return;
	int mid = low + ((high - low) >> 1);
	MergeSort(array, low, mid);
	MergeSort(array, mid + 1, high);
	Merge(array, low, mid, high);
}

快速排序

int Partition(int *array, int low, int high) {
	int i = low;
	for (int j = low; j < high; j++) {
		if (array[j] < array[high]) {
			swap(array[i++], array[j]);
		}
	}
	swap(array[i], array[high]);
	return i;
}
void QuickSort(int *array, int low, int high) {
	if (low >= high) return;
	int privot = Partition(array, low, high);
	QuickSort(array, low, privot - 1);
	QuickSort(array, privot + 1, high);
}

堆排序

void Heapify(int *array, int size, int i) {
	int maxPos = i;
	while (1) {
		if (2 * i + 1 < size && array[maxPos] < array[2 * i + 1]) maxPos = 2 * i + 1;
		if (2 * i + 2 < size && array[maxPos] < array[2 * i + 2]) maxPos = 2 * i + 2;
		if (maxPos == i) break;
		swap(array[i], array[maxPos]);
		i = maxPos;
	}
}
void BuildHead(int *array, int size) {
	for (int i = size / 2 - 1; i >= 0; i--) {
		Heapify(array, size, i);
	}
}
void HeapSort(int *array, int size) {
	BuildHead(array, size);
	while (size > 0) {
		swap(array[0], array[size - 1]);
		Heapify(array, --size, 0);
	}
}