【从头学数据结构和算法】冒泡排序及其优化（c++实现）

c++实现的冒泡排序及其优化

---

• 普通冒泡排序
• 优化1：增加是否交换的标记
• 优化2：增加最后一次交换的位置
• 优化3：双向冒泡
• 测试
• 完整代码

---

普通冒泡排序

原理

每次从头开始，两两比较，把大的数据往后挪，每次就能把未排序数据中的最大值找出来并移到最后。

基本性质

• 时间复杂度（主要是看交换次数）
  ——最好情况：O（n）
  ——最坏情况和平均：O（n^2）
• 空间复杂度
  ——O（1）：原地排序
• 稳定性
  ——在等于时不交换即可做到稳定
• 缺点
  ——在交换时需要3次赋值操作，影响效率
  ——两层循环都要走完，最后才出结果

代码

template<typename T> 
void bubble_sort0(T *a, int len) {
	// 首先检查数据的合法性（TODO 不完善）.
	if (a == NULL || len <= 1) {
		return;
	}
	 
	T temp = 0;	// 临时变量，用于进行数据交换，赋初值仅是习惯问题?防止随机初值？ 
	 
	// 两重循环，最普通的冒泡排序 
	// 确定排序趟数 
	for (int i = 0; i < len; ++i) {	// ++i不会多定义变量，相比i++省空间  
		// 确定单趟的比较次数 
		for (int j = 0; j < len - i - 1; ++j) {	 
			// 当前比后面的值大，则冒泡到后面去 
			if (a[j] > a[j+1]) {
				// 进行数据交换
				temp = a[j];
				a[j] = a[j+1];
				a[j+1] = temp; 
			} 
		} 
	} 
} 

---

优化1：增加是否交换的标记

原理

当一趟冒泡没有元素交换时，说明此时已经有序，可以提前结束。
增加一个标记记录一趟冒泡中是否有元素交换操作。

基本性质

• 适用场景
  仅适用于连片有序而整体无序的数据，但是对于前面大部分是无序而后边小半部分有序的数据(1，2，5，7，4，3，6，8，9，10)排序效率也不可观

代码

template<typename T> 
void bubble_sort1(T *a, int len) {
	// 首先检查输入数据的合法性（TODO 不完善）
	if (a == NULL || len <= 1) {
		return;
	}
	 
	T temp = 0;		// 临时变量，用于进行数据交换 
	int flag = 0;	// 标记变量，记录单趟排序是否有交换 
	 
	// 两重循环，最普通的冒泡排序 
	// 确定排序趟数 
	for (int i = 0; i < len; ++i) {	// ++i不会多定义变量，相比i++省空间  
		// 每趟排序之前置0
		flag = 0; 
		// 确定单趟的比较次数 
		for (int j = 0; j < len - i - 1; ++j) {	 
			// 当前比后面的值大，则冒泡到后面去 
			if (a[j] > a[j+1]) {
				// 进行数据交换
				temp = a[j];
				a[j] = a[j+1];
				a[j+1] = temp; 
				flag = 1;	// 记录交换 
			} 
		}
		// 如果标记为1，说明这趟排序未交换，已经排好序，可提前结束 
		if (flag == 0) {
			break; 
		} 
	} 
}

---

优化2：增加最后一次交换的位置

原理

最后一次交换之后的位置都拍好了序，不用再进行比较了。

代码

template<typename T> 
void bubble_sort2(T *a, int len) {
	// 首先检查输入数据的合法性（TODO 不完善）
	if (a == NULL || len <= 1) {
		return;
	}
	
	T temp = 0;		// 临时变量，用于进行数据交换 
	int flag = 0;	// 标记变量，记录单趟排序是否有交换 
	int pos_temp = 0;		// 记录最后一次交换的位置 
	int pos_cur = len-1;	// 当前需要冒泡的截止位置 
	
	// 两重循环，最普通的冒泡排序 
	// 确定排序趟数 
	for (int i = 0; i < len; ++i) {	// ++i不会多定义变量，相比i++省空间  
		// 每趟排序之前置0
		flag = 0; 
		// 确定单趟的比较次数 
		for (int j = 0; j < pos_cur; ++j) {	 
			// 当前比后面的值大，则冒泡到后面去 
			if (a[j] > a[j+1]) {
				// 进行数据交换
				temp = a[j];
				a[j] = a[j+1];
				a[j+1] = temp; 
				pos_temp = j;	// 记录最后一次交换的位置 
				flag = 1;		// 记录交换 
			} 
		}
		// 如果标记为1，说明这趟排序未交换，已经排好序，可提前结束 
		if (flag == 0) {
			break; 
		}
		pos_cur = pos_temp;
	} 
}

---

优化3：双向冒泡

原理

对于例如2，2，2，2，0这样的数据，正向冒泡只是把大的往后移，小的数往前的移动其实非常缓慢，严重增加了工作量。
可以一轮正向一轮反向交替冒泡，减少工作量。（同样，可以记录位置和交换与否来达到提前结束循环的目标）

代码

template<typename T> 
void bubble_sort3(T *a, int len) {
	// 首先检查输入数据的合法性（TODO 不完善）
	if (a == NULL || len <= 1) {
		return;
	}
	 
	T temp = 0;		// 临时变量，用于进行数据交换
	int flag = 0;	// 标记变量，记录单趟排序是否有交换
	int forward_pos_temp = 0;		// 记录前向最后一次交换的位置
	int forward_pos_cur = len-1;	// 当前需要冒泡的前向截止位置
	int reverse_pos_temp = 0;		// 记录前向最后一次交换的位置
	int reverse_pos_cur = 0;		// 当前需要冒泡的后向截止位置 
	int j = 0;		// 内层循环计数变量 
	
	// 确定排序趟数 
	for (int i = 0; i < len; ++i) {	// ++i不会多定义变量，相比i++省空间  
		// 每趟排序之前置0
		flag = 0; 
		
		// 正向冒泡寻找最大值
		for (j = 0; j < forward_pos_cur; ++j) {
			// 当前比后面的值大，则冒泡到后面去 
			if (a[j] > a[j+1]) {
				// 进行数据交换
				temp = a[j];
				a[j] = a[j+1];
				a[j+1] = temp; 
				forward_pos_temp = j;	// 记录最后一次交换的位置 
				flag = 1;		// 记录交换 
			} 
		} 
		// 如果标记为1，说明这趟排序未交换，已经排好序，可提前结束 
		if (flag == 0) {
			break; 
		}
		forward_pos_cur = forward_pos_temp;
		
		// 反向冒泡寻找最小值 
		for (j = forward_pos_cur; j > reverse_pos_cur; --j) {	 
			// 当前比前面的值小，则冒泡到前面去 
			if (a[j] < a[j-1]) {
				// 进行数据交换
				temp = a[j];
				a[j] = a[j-1];
				a[j-1] = temp; 
				reverse_pos_temp = j;	// 记录最后一次交换的位置 
				flag = 1;		// 记录交换 
			} 
		}
		// 如果标记为1，说明这趟排序未交换，已经排好序，可提前结束 
		if (flag == 0) {
			break; 
		}
		reverse_pos_cur = reverse_pos_temp;
	} 
}

---

测试

以20000个整数进行测试，记录时间，同时assert是否与algorithm中sort结果相同。测试代码略，可见完整代码中。
测试结果时间（同时，assert未报错）如下图所示：

可见，优化1和2其实不见得多好，他们有其各自适用范围，基本无序的使用这两种方式反而可能因为增加了赋值操作、判断操作而使得效率降低。双向冒泡效率提升还是非常明显的。

---

完整代码

https://github.com/zhangdanzhu/basic_data-structure_algorithm/blob/master/sort/cpp/bubble_sort.cpp