数据结构—排序算法1（冒泡、选择、插入、希尔）

排序算法

1冒泡排序

• 时间复杂度O(n^2)；空间复杂度O(1)
• 稳定性—稳定

void Swap(int* a, int* b) {
	int tmp = *a;
	*a = *b;
	*b = tmp;
}
void BubbleSort(int* arr, int len) {
	bool flag;
	for (int i = 0; i < len - 1; i++) {
		flag = false;
		for (int j = 0; j < len - 1 - i; j++) {
			if (arr[j] > arr[j + 1]) {            //稳定性---稳定
				Swap(&arr[j], &arr[j + 1]);
				flag = true;
			}
		}
		if (!flag)break;
	}
}

2选择排序

• 思路：从待排序序列选择最小/大值，放待排序序列最前面。
• 6 3 2 1 5
• 第一步：1 3 2 6 5 （1和6交换）
• 第二步：1 2 3 6 5 （3和2交换）
• 第三步：1 2 3 6 5 （不交换）
• 第四步：1 2 3 5 6 （5和6交换）
• 时间复杂度O(n^2)；空间复杂度O(1)

void SelectSort(int* a, int len) {
	int min_index;
	for (int i = 0; i < len; i++) {
		min_index = i;
		for (int j = i+1; j < len; j++) {   //j挑选最小值
			if (a[j] < a[min_index]) {      //a[j] < a[min_index]  稳定的排序算法
				min_index = j;
			}
		}
		Swap(&a[i], &a[min_index]);
	}
}

3插入排序

• 思路：i从1开始，j从i-1开始，令tmp=arr[i]，将tmp插入到前方合适的位置，即arr[j+1]
• 平均时间复杂度O(n^2)，最优时间复杂度O(n)；空间复杂度O(1)
• 6 3 2 1 5
• 第一步：3 6 2 1 5 （3插入到6之前）
• 第二步：2 3 6 1 5 （2插入到3之前）
• 第三步：1 2 3 6 5 （1插入到2之前）
• 第四步：1 2 3 5 6 （5插入到6之前）

void InsertSort(int* a, int len) {
	assert(a != NULL);
	int tmp,j;
	for (int i = 1; i < len; i++) {
		tmp = a[i];
		for (j = i - 1; j >= 0; j--) {
			if (a[j] > tmp) {            //a[j] > tmp 稳定
				a[j + 1] = a[j];
			}
			else {
				break;
			}
		}
		a[j+1] = tmp;
	}
}

4希尔排序

• 分组排序—>逐渐有序—>简单插入排序
• 分组个数：5，3，1。奇数分组，避免数据重复遍历。
• 时间复杂度O(n^1.3~1.5)；空间复杂度O(1)。

void ShellSort(int* a, int len,int gap) {
	assert(a != NULL);
	int tmp, j;
	for (int i = gap; i < len; i++) {
		tmp = a[i];
		for (j = i - gap; j >= 0; j-=gap) {
			if (tmp < a[j]) {            //tmp < a[j]
				a[j + gap] = a[j];
			}
			else {
				break;
			}
		}
		a[j + gap] = tmp;
	}
}
void Shell(int* a, int len) {
	int gap[] = { 5,3,1 };//落脚点在1---简单插入排序
	for (int i = 0; i < 3; i++) {
		ShellSort(a, len, gap[i]);
	}
}