数据结构2 冒泡排序

【数据结构--冒泡排序】

冒泡排序是数据结构的第一个算法，，也是最简单的一个排序算法。

冒泡排序就是把小的元素往前调或者把大的元素往后调。相邻的两个元素比较，交换也发生在这两个元素之间。所以，如果两个元素相等，是不会再交换的；如果两个相等的元素没有相邻，那么即使通过前面的两两交换把两个相邻起来，这时候也不会交换，所以相同元素的前后顺序并没有改变，所以冒泡排序是一种稳定排序算法。

【基本的冒泡排序，如果有n个数据元素，会进行n-1次扫描，每次扫描会选择出最大的一个元素】

#include<iostream>
using namespace std;
//  冒泡排序

void BubbleSort(int a[], int n) {
	for (int i = 0; i < n - 1; i++) {
		for (int j = 0; j < n - i - 1; j++) {
			if (a[j] > a[j + 1]) {
				std::swap(a[j], a[j + 1]); //交换两个相邻元素使用c++中模版函数
			}
		}
	}
	//遍历排序后的数组
	for (int i = 0; i < n; i++) {
		cout << a[i] << "  ";
	}
}

int main() {
	int n;
	int a[] = { 3,4,2,1,8,3,9,5 };
	n = 8;// 定义数组的长度
	BubbleSort(a,n);
	system("pause");
}

【冒泡算法优化】

算法优化是研究算法的问题。冒泡算法虽然简单，但也是可以进行优化的。

通过分析可知，最传统的冒泡算法当数据个数为n时，算法会比较n-1次。通过上面的动画可知，当数组中数据比较到19时，此时整个数组的顺序已经不需要调整，而传统冒泡算法仍然需要继续比较。所以改进冒泡算法的一种思想是当遇到上述情况时，提前停止，虽然这种改进与数据提前的顺序有关，极端情况可能与传统冒泡排序一致，但是仍然是一种可提高冒泡排序的改进。

下面是上述思想的测试，针对我随机设置的数据，

#include<iostream>
using namespace std;
//  冒泡排序

void BubbleSort(int a[], int n) {
	int Symbol = 0;// 设置迭代的标志量

	for (int i = 0; i < n - 1; i++) {
		bool isSorted = true;
		for (int j = 0; j < n - i - 1; j++) {
			if (a[j] > a[j + 1]) {
				std::swap(a[j], a[j + 1]); //交换两个相邻元素使用c++中模版函数
			//	isSorted = false;
			}
		}
		Symbol = Symbol + 1;
		//if (isSorted == true) {
		//	break;
		//}
	}
	//遍历排序后的数组
	for (int i = 0; i < n; i++) {
		cout << a[i] << "  ";
	}
	cout << endl;
	cout <<"冒泡排序的迭代次数是: " <<Symbol << endl;
}

int main() {
	int n;
	int a[] = { 3,4,2,1,8,3,9,5 };
	n = 8;// 定义数组的长度
	BubbleSort(a,n);
	system("pause");
}

改进前，排序算法的迭代次数是7， 这是由于设置了数据个数为8，所以数据要扫描7次。

当改进后， 将上述注释释放掉，冒泡排序的迭代次数为4。

 结论:   基于上述改进的思想的冒泡排序算法能够提前停止，减小不必要的比较排序。

-------------------------------------------------------------------------------------------------------------------------------------------------------

冒泡排序算法中， 数字顺序不是从小到大，就是从大到小。所以如果我们在排序过程中同时寻找两端元素，而不是单一每次寻找一端的元素，势必迭代次数会大量减小。这种方法被称为双向冒泡法。

算法思想是： 分别从数组的两端出发，在每次迭代时分别寻找最大值与最小值，直到最大值与最小值相等后，完成算法。

//#include "stdafx.h"
//#include <stdio.h>
//#include <stdlib.h>
#include<iostream>
using namespace std;
//一般的冒泡排序
void bubbleSort(int a[], int n)
{
	int i, j, k;
	int temp;

	for (i = 0; i < n; i++) {    //最多做n-1趟排序
		for (j = 0; j < n - i - 1; j++) {
			if (a[j] > a[j + 1]) {    //把大的值交换到后面
				temp = a[j];
				a[j] = a[j + 1];
				a[j + 1] = temp;
			}
		}
		printf("第%d次排序结果：", i + 1);
		for (k = 0; k < n; k++) {
			//printf("%d\n", a[k]);
			cout << a[k] << " ";
		}
		cout << endl;
		//printf("\n");
	}
	printf("最终排序结果： ");
	for (k = 0; k < n; k++) {
	//	printf("%d\n", a[k]);
		cout << a[k] << "  ";
	}
	cout << endl;
}

//改进版的冒泡排序(双向冒泡)
void bidBubbleSort(int a[], int n)
{
	int left, right, t, l, r, j, i = 0;

	left = 0;
	right = n - 1;

	//双向冒泡算法，极大的减少了循环排序的次数
	while (left < right)
	{
		//必须要给l和r赋值，否则若数组一开始就有序，则right=r中的r未赋值，即报错
		l = left + 1;
		r = right - 1;

		//第一次循环将最大的值放到末尾
		for (j = left; j < right; j++)
		{
			if (a[j] > a[j + 1])
			{
				t = a[j];
				a[j] = a[j + 1];
				a[j + 1] = t;
				r = j;
			}
		}
		right = r;

		//第二次循环将最小的值放到了开头
		for (j = right; j > left; j--)
		{
			if (a[j] < a[j - 1])
			{
				t = a[j];
				a[j] = a[j - 1];
				a[j - 1] = t;
				l = j;
			}
		}
		left = l;

		printf("第%d次排序结果：", i + 1);
		i++;
		for (j = 0; j < n; j++) {
			//printf("%d\n", a[j]);
			cout << a[j] << " ";
		}
		cout << endl;
	}
	printf("最终排序结果： ");
	for (j = 0; j < n; j++) {
		//printf("%d\n", a[j]);
		cout << a[j] << " ";
	}
	cout << endl;
}

int main()
{
	int score1[] = { 98, 69, 75, 47, 89, 90, 100, 70 };
	bubbleSort(score1, 8);
	printf("\n");
	int score2[] = { 98, 69, 75, 47, 89, 90, 100, 70 };
	bidBubbleSort(score2, 8);

	system("pause");
	return 0;
}

结果显示，传统冒泡排序需要完成排序需要8次迭代， 而双端冒泡算法只需要2次迭代就可以完成最后的排序。虽然可能理论上时间复杂度仍然是平方级别，但是在实际使用时会大量减小算法的迭代次数。