C++ 实现冒泡排序法

 冒泡排序法

这里使用C++来实现冒泡排序法

冒泡排序法采用不停地交换彼此位置来实现，故而形象地称之为冒泡

大致一个气泡从水底一直冒到水面

一小段排序程序如下

        1、外层循环：主要是用来轮询

        2、内层循环：主要用来交换位置（前提是满足if条件）

        3、外层循环的停止条件 i < len 这应该能理解，内层循环的停止条件 j < len -i -1 来说明一下： 首先 len - 1 这个为什么要减掉 1， 因为下面 if 中有使用 buf [j+1]， 所以这里要减掉1，不然 buf [j+1] 就会发生越界行为（超出了数组最大数组下标），接着看 len-i，为什么又要减掉 i 呢？因为内层循环每完成一次，最大那个值（或最小那个值），就已经交换到了最后的位置，所以下次交换的时候我们就要减少一次交换已经排序好的元素，依次类推，所以就有 len - i 这样的条件，最后合起来就是 j < len - i - 1 了

void sort(int *buf, int len)
{
	for (int i = 0; i < len; ++i) { // 外层循环
		for (int j = 0; j < len - i - 1; ++j) { // 内层循环
			if (buf[j] > buf[j + 1]) { // 如果满足条件就交换位置
				int temp = buf[j];
				buf[j] = buf[j + 1];
				buf[j + 1] = temp;
			}
		}
	}
}

接着我们可以看看，这个冒泡排序一共要执行多少次才完成了，对程序进行修改一下，添加了 cnt 变量

void sort1(int *buf, int len)
{
	int cnt = 0; // 用来计数，看看执行了多少次

	for (int i = 0; i < len; ++i) {
		for (int j = 0; j < len - i - 1; ++j) {
			if (buf[j] > buf[j + 1]) { 
				int temp = buf[j];
				buf[j] = buf[j + 1];
				buf[j + 1] = temp;
			}
		}

		++cnt; // 在这里记录外层循环的次数
	}

	cout << "一共执行了：" << cnt << endl;
}

int main(int argc, char* argv[])
{
	int buf1[] = { 5,0,1,2,3,4 };
	sort1(buf1, sizeof(buf1) / sizeof(int));
	return 0;
}

运行结果可以看到，外层循环是全部执行完才能完成排序

 但上面主函数的 buf1 数组中，只有 5 是需要排序的，其他的都不用排序，好像就是直接把 5 放在最后面即可完成排序了，也就是进行排序 1 次就行了，现在在小优化一下

void sort2(int* buf, int len)
{
	int cnt = 0;
	bool finish = true; // 添加了停止条件

	for (int i = 0; i < len; ++i) {
		finish = true;
		for (int j = 0; j < len - i - 1; ++j) {
			if (buf[j] > buf[j + 1]) {
				int temp = buf[j];
				buf[j] = buf[j + 1];
				buf[j + 1] = temp;
				finish = false;	// 发生交换了，不停止循环
			}
			
		}

		if (finish) // 如果没有发生交换位置，就结束循环
			break;

		++cnt;
	}

	cout << "一共执行了：" << cnt << endl;
}

int main(int argc, char* argv[])
{
	int buf1[] = { 5,0,1,2,3,4 };
	sort2(buf1, sizeof(buf2) / sizeof(int));

	return 0;
}

 运行结果，符合我们的预想

完整代码如下

#include <iostream>
using namespace std;

/* 冒泡排序法2 */
void sort1(int *buf, int len)
{
	int cnt = 0; // 用来计数，看看执行了多少次

	for (int i = 0; i < len; ++i) {
		for (int j = 0; j < len - i - 1; ++j) {
			if (buf[j] > buf[j + 1]) { 
				int temp = buf[j];
				buf[j] = buf[j + 1];
				buf[j + 1] = temp;
			}
		}

		++cnt; // 在这里记录外层循环的次数
	}

	cout << "一共执行了：" << cnt << endl;
}

/* 冒泡排序法2 */
void sort2(int* buf, int len)
{
	int cnt = 0;
	bool finish = true; // 添加了停止条件

	for (int i = 0; i < len; ++i) {
		finish = true;
		for (int j = 0; j < len - i - 1; ++j) {
			if (buf[j] > buf[j + 1]) {
				int temp = buf[j];
				buf[j] = buf[j + 1];
				buf[j + 1] = temp;
				finish = false;	// 发生交换了，不停止循环
			}
			
		}

		if (finish) // 如果没有发生交换位置，就结束循环
			break;

		++cnt;
	}

	cout << "一共执行了：" << cnt << endl;
}

int main(int argc, char* argv[])
{
	// 2 个元素相同的数组
	int buf1[] = { 5,0,1,2,3,4 };
	int buf2[] = { 5,0,1,2,3,4 };

	sort1(buf1, sizeof(buf1) / sizeof(int)); /* 冒泡排序法1 */
	sort2(buf2, sizeof(buf2) / sizeof(int)); /* 冒泡排序法2 */

	return 0;
}

当然，这不是万能的哈，比如这样，它就不适用了，把 buf1 和把 buf2 的元素是完全倒序

#include <iostream>
using namespace std;

/* 冒泡排序法2 */
void sort1(int *buf, int len)
{
	int cnt = 0; // 用来计数，看看执行了多少次

	for (int i = 0; i < len; ++i) {
		for (int j = 0; j < len - i - 1; ++j) {
			if (buf[j] > buf[j + 1]) { 
				int temp = buf[j];
				buf[j] = buf[j + 1];
				buf[j + 1] = temp;
			}
		}

		++cnt; // 在这里记录外层循环的次数
	}

	cout << "一共执行了：" << cnt << endl;
}

/* 冒泡排序法2 */
void sort2(int* buf, int len)
{
	int cnt = 0;
	bool finish = true; // 添加了停止条件

	for (int i = 0; i < len; ++i) {
		finish = true;
		for (int j = 0; j < len - i - 1; ++j) {
			if (buf[j] > buf[j + 1]) {
				int temp = buf[j];
				buf[j] = buf[j + 1];
				buf[j + 1] = temp;
				finish = false;	// 发生交换了，不停止循环
			}
			
		}

		if (finish) // 如果没有发生交换位置，就结束循环
			break;

		++cnt;
	}

	cout << "一共执行了：" << cnt << endl;
}

int main(int argc, char* argv[])
{
	// 2 个元素相同的数组
	int buf1[] = { 5,4,3,2,1,0 };
	int buf2[] = { 5,4,3,2,1,0 };

	sort1(buf1, sizeof(buf1) / sizeof(int)); /* 冒泡排序法1 */
	sort2(buf2, sizeof(buf2) / sizeof(int)); /* 冒泡排序法2 */

	return 0;
}

 基本上，sort1 和 sort2 的执行次是一样的同样的 6 次，那上面结果为什么是 sort1 是 6 而 sort2 是 5，原因是在 if 那里退出了，cnt 少加了 1 次，不过这个影响不大。

结果说明，某种的优化只能说针对某一个方面，最后还是得见招拆招。