排序算法分析（C++）

一、选择排序

概述：从头到尾遍历序列，找出最小的一个元素，和第一个元素交换，接着在剩下的元素序列中继续这种选择和交换方式，最终得到一个有序序列。

1-1 蛮力法

时间复杂度为 O(n²)。

void selectSort(int a[], int n) {
	int t = 0;
	for (int i = 0; i < n - 1; i++) {
		t = i;
		for (int j = i + 1; j < n; j++) {
			if (a[j] < a[t]) {
				t = j;
			}
		}
		if (t != i) {
			temp(a[i], a[t]);
		}
	}
}

1-2 蛮力法的优化

 每次找出一个最小的元素和一个最大的元素，最小的元素排在前边，最大的元素排在后边，循环的次数减半。

void selectSort_optimiaze(int a[], int n) {
	int left = 0;
	int min;
	int right = n - 1;
	int max;
	while (left < right) {
		min = left;
		max = right;
		for (int i = left; i <= right; i++) {
			if (a[i] < a[min]) {
				min = i;
			}
			if (a[i] > a[max]) {
				max = i;
			}
		}
		if (min != left) {
			swap(a[min], a[left]);
		}
        /*如果最大的元素在最左边，由于最左边的元素已经先和最小的元素交换了位置，
		此时原本最小元素位置的值是最左边的元素，所以最大的元素的位置应该等于最小元素的位置*/
		if (max == left) {  
			max = min;
		}
		if (max != right) {
			swap(a[max], a[right]);
		}
		left++;
		right--;
	}
}

2-1 递归法

每调用一次函数从前往后确定一个位置，下一次需要排序的元素序列规模大小减1。

void selectSort_recurtion(int a[], int i, int n) {
	if (i == n-1) {  
		return;
	}
	else {
		int t = i;
		for (int j = i + 1; j < n; j++) {
			if (a[j] < a[t]) {
				t = j;
			}
		}
		if (t != i) {
			temp(a[t], a[i]);
		}
		selectSort_recurtion(a, i + 1, n);
	}
}

2-2 递归优化

每次找出一个最小的元素和一个最大的元素，下一次需要排序的元素序列规模大小减2。

void selectSort_recurtion_optimize(int a[], int i, int n) {
	if (i == n) {
		return;
	}
	else {
		int min =