排序——冒泡排序（C++）

1、算法描述：

        设存在序列array[0. . n-1]；

1. 选择 array[0] 元素作为基准元素，和array[1]元素作比较，当array[0] > array[1]成立时，则把array[0]和array[1]交换；不成立时，不交换；
2. 再把array[1] 和 array[2]进行比较，当array[1] > array[2]成立时，则把array[1]和array[2]交换，依次类推；
3. 当第一轮比较结束后，数组中最大的元素被交换到array[n-1]位置；
4. 重复（1）和（2），当第二轮结束时候，数组中第二大元素被交换到array[-1-1]位置处；
5. 当第n-2轮结束后，即排序完成。

   总结一下：

        在第 i 趟排序时(i = 1， 2， 3， . . . n-1)，将array[0]和array[1比较大小，如果 array[0] > array[1]， 则交换 array[0] 和array[1]，否则不交换；然后再将array[1]和array[2]比较大小，如果array[1] > array[2]成立，则交换array[1]和array[2]， 否则不交换；如此类推。
每一次比较array[n-i-1] 和 array[n-i]，这样每一趟排序结束后都会有前面的未排序序列中最大的元素排在下标为 n-i 的array序列中，直到某一趟排序过程中不出现元素的交换动作，排序结束。
        为了进一步改进算法，提升效率，可以设置一个标志位flag，用于判断每次比较后有没有进行交换，若没有进行交换，则表示排序已经完成：假设：

• flag = 0：表示该趟排序过程中有交换数据；
• flag = 1：表示该趟排序过程中没有交换数据

说明：

        排序开始时，先设置flag=1；每趟排序过程中，若出现交换数据，则把flag置为0，如果在排序过程中没有交换动作，则flag不做处理；每趟比较、交换结束后，判断flag是否为1，若为1表示没有交换数据，数组是已经排好序的；如果flag为0，则表示数据有交换，则需要进行下一次循环。前边可以看出插入排序和选择排序都需要执行n-1趟排序，而对于设置了flag标志的冒泡排序而言，最多才需要执行n-1趟排序。

2、时间复杂度

1. 最好情况（初始序列已经按升序）：则只需要进行一趟n-1次元素之间的比较，并且不移动元素，算法时间复杂度为O(n)；
2. 最坏情况（初始序列逆序有序或者最小元素在序列的最后）：需要进行n-1趟排序，总共进行 1 + 2 + 3 + 4 + . . . + n-1 = n(n-1) /2，时间复杂度为O(n^2)；

         可见，冒泡排序是稳定的排序方法。冒泡排序比较适合参加排序序列的数据量较小的情况，尤其是当序列的初始状态为基本有序的情况。

代码示例：

#include <iostream>  
using namespace std;

int bubbleSort(int array[], int n)
{
	int i, j, temp;
	int flag = 1;
	for (i = 0; i < n; i++)
	{
		
		for (j = 0; j < n - 1 - i; j++)
		{
			if (array[j]>array[j+1])
			{
				temp = array[j+1];
				array[j+1] = array[j];
				array[j] = temp;
				flag = 0;
			}
		}
		if (flag == 1)
			return 0;
	}
	return 0;
}

int main()
{
	int array[] = {3, 54, 31, 11, 78, 1,34,32,76,7 };
	int size = sizeof(array) / sizeof(int);
	cout << "原始的数组：";
	for (int i = 0; i < size; ++i)
		cout << array[i] << "  ";
	cout << "\n";
	bubbleSort(array, size);
	cout << "排序后数组：";
	for (int i = 0; i < size; ++i)
		cout<<array[i]<<"  ";
	cout << "\n";
	system("pause");
	return 0;
}

运行结果：