冒泡法排序

冒泡法排序

排序原理：比较相邻的元素，如果不满足比较规则，就交换，每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对

然后最大元素或者最小元素会逐渐排在最前面，就像冒泡一样，会慢慢升起来.

持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较,排序就完成了.

void BubbleSort(int* arr, int size) {
	int bound = 0;
	for (; bound < size - 1; ++bound) {
		for (int cur = size - 1; cur > bound; --cur) {
			//升序
			if (arr[cur - 1] > arr[cur]){
				swap(arr[cur - 1], arr[cur]);
			}
		}
	}
}

冒泡排序另一种写法

void Bubble(int *arr, int size) {
	for (int i = 0; i < size-1; ++i) {
		for (int j = 1; j < size - i; ++j) {
			// 降序
			if (arr[j] > arr[j - 1]) {
				swap(arr[j], arr[j - 1]);
			}
		}
	}
}

第一层循环 n-1次，第二层循环 n - i 次，n 代表数据元素个数，i 代表第 i 个元素.

如何写出可扩展性的冒泡排序?

利用函数指针或者布尔变量进行降序还是升序操作

typedef int(*Cmp)(int, int);//函数指针
// int(*)(int a ,int b)

void BubbleSort(int* arr, int size, Cmp cmp){
	int bound = 0;
	for (; bound < size; ++bound){
		//cur是每进行一次循环比较的次数
		//第一次循环，它进行五次，第二次循环，cur减一，依次递减下去
		for (int cur = size - 1; cur > bound; --cur){
			if (cmp(arr[cur-1],arr[cur])== 0){
				//等于0的时候，两元素不符合规则，则调换位置
				Swap(&arr[cur - 1], &arr[cur]);				
			}
		}
	}
}

//升序
int less(int x, int y){
	// x 位前一位数字，y 位后一位数字，如果 x<y 则不调换位置
	return x < y ? 1 : 0;	
}

//降序
int Gretter(int x, int y){
	return x < y ? 0 : 1;
}

//绝对值升序排列
int absless(int x, int y){
	return abs(x) < abs(y) ? 1 : 0;
}

int main(){	
	int arr[] = { 2,-3,8,-7,6,5 };
	BubbleSort(arr,6,absless);
	//第三个参数很灵活，可以随意调用用户自定义的函数。
	for (int i = 0; i < 6; ++i){
		printf("%d\n", arr[i]);
	}

	return 0;
}

冒泡排序的优化

void BubbleSort2(int *array, int size){
	for (int i = 0; i < size - 1; ++i){
		int ischange = 0; // 判断参数
		for (int j = 1; j < size - i; ++j){
			if (array[j - 1] > array[j]){
				Swap(&array[j - 1], &array[j]);
				ischange = 1;
			}
		}//  如果 ischange 值为 0，则说明不需要排序了
		if (!ischange){
			return;
		}
	}
}

总结：最佳时间复杂度是O(N),平均时间复杂度为O(N²)，空间复杂度为O(1)，算法是稳定的(在比较的时候，不要加等号)否则是不稳定的.另外如果一组数据快接近有序了，则使用冒泡法比较好.

内部排序算法

排序算法	平均时间复杂度	场景	是否稳定
冒泡排序	O(n2)	接近有序，数据量小	稳定
插入排序	O(n2)	接近有序，数据量小	稳定
选择排序	O(n2)	接近有序，数据量小	不稳定
希尔排序	O(n1.3)	随机数列	不稳定
快速排序	O(N*logN)	随机数列	不稳定
堆排序	O(N*logN)	选取指定数列	不稳定

外部排序算法

排序算法	时间复杂度	场景	是否稳定
归并排序	O(N*logN)	数据量大	稳定
基数排序	O(d(n+r))	数据量大	稳定
计数排序	O(d(n+r))	数据量大	稳定
桶排序	O(d(n+r))	数据分布集中	稳定

算法分类