冒泡排序

冒泡排序

1.基本思想

• 首先从第一个记录开始，依次比较相邻两个记录，若为逆序，则将这两个记录交换之，直到第n-1个记录和第n 个记录比较为止，这是一趟冒泡排序。

• 一般地，第i趟排序是从第1个记录到第n-i+1个记录依次比较相邻两个记录，若为逆序则交换记录，结果是这n-i+1个记录中最大的记录被交换到第n-i+1的位置上。

•  冒泡排序结束条件：在一趟排序中没有进行交换操作，至多n-1趟。

2.排序示例

   

      在冒泡排序过程中，值小的记录好比水中的气泡逐趟往上冒，而值大的记录好比石头往下沉，每一趟有一块“最大”的石头沉到水底。

3.算法实现

// 自小到大的有序整数序列
	public static void bubbleSort(int a[],int len) {
		
		int temp = 0;
		// 至多n-1趟排序
		for (int i = len - 1; i > 0; i--) {
			boolean change = false;
			// 单趟排序
			for (int j = 0; j < i; j++) {
				if (a[j] > a[j + 1]) {
					//1次交换3次移动
					temp = a[j];
					a[j] = a[j + 1];
					a[j + 1] = temp;
					change = true;
				}
			}
			// 冒泡排序算法结束条件：在一趟排序过程中没有进行过交换操作
			if (!change) {
				break;
			}
		}
	}

4.效率分析

• 最好的情况（正序）：1趟排序，比较次数: n-1  移动次数:  0

• 最坏的情况（逆序）：n-1趟排序

                                          比较次数：C_max=n(n-1)/2

                                          移动次数：M_max=3n(n-1)/2                            

• 时间复杂度：O(n²)

5.算法的稳定性

     相同算法的前后顺序并未改变，因此冒泡排序是一种稳定的排序算法

6.冒泡排序的应用

    冒泡排序思想比较好理解，但效率低下，可以在数据规模很小时使用。若数据规模比较大，最好采用其他的排序算法。

7.冒泡算法的优化

7.1有序区优化

假设有100个数的数组，仅前面10个元素是无序的，后面90个是有序的且都大于前面10个数字，那在第一次遍历之后，发生交换的位置肯定小于10，记录下这个位置，下一次遍历的时候，只要从数组的头部遍历到这个位置就可以了。

优化实现：

public static int bubbleSort02(int a[]) {
		int sum = 0;
		// 设置标记位置
		int flag = a.length;
		int k, temp;

		while (flag > 0) {
			k = flag;
			// 跳出循环条件
			flag = 0;
			for (int i = 1; i < k; i++) {
				// 若出现逆序，则交换元素位置
				if (a[i - 1] > a[i]) {
					temp = a[i - 1];
					a[i - 1] = a[i];
					a[i] = temp;
					// 修改标记位置
					flag = i; // 记录发生交换的最后一个元素的角标
				}
				sum++;
			}
		}
		return sum;
	}

7.2基于交替扫描的改进冒泡排序算法

(1)冒泡算法的不对称性：

当只有最重的气泡位于顶部，其余的气泡均已排序好，那只需一趟扫描就可完成排序。例如：9，1，2，3，4，5，6只需一趟扫描

当只有最轻的气泡位于底部，其余的气泡均已排序好，则需要n-1趟扫描才可完成排序。例如：2，3，4，5，6，7，8，1需要7趟扫描

 

(2)造成不对称性的原因

每趟扫描仅能使最轻的气泡上升一个位置，因此位于底部的最轻气泡上升到顶部时，需做n-1趟扫描。

(3)改进不对称性的方法

在排序过程中交替改变扫描方向，可改进不对称性

(4) 采用交替扫描改进的冒泡算法实现：

 

// 交替冒泡排序，改进不对称性
	public static int bubbleSort03(int a[]) {
		int sum = 0;
		int len = a.length;
		boolean change;
		int i, j, temp;
		// 至多n-1趟排序
		for (i = 0; i < len - 1; i++) {
			change = false;
			// 自上而下的扫描
			for (j = i; j < len - i - 1; j++) {
				if (a[j] > a[j + 1]) {
					temp = a[j];
					a[j] = a[j + 1];
					a[j + 1] = temp;
					change = true;
				}
				sum++;
			}
			//排序结束条件：出现一趟排序没有进行过交换操作
			if (!change) {
				return sum;
			}

			change = false;
			// 自下而上的扫描
			for (j = len - i - 2; j > i; j--) {
				if (a[j - 1] > a[j]) {
					temp = a[j - 1];
					a[j - 1] = a[j];
					a[j] = temp;
					change = true;
				}
				sum++;
			}
			if (!change) {
				return sum;
			}

		}
		return sum;
	}

7.3结合上述两种思想的改进的冒泡排序算法

  结合上述记录有序区位置和交替扫描两种思想，对冒泡算法进行优化

算法实现：

// 交替冒泡排序+针对有序区的优化
	public static int bubbleSort04(int a[]) {
		//统计循环次数
		int sum = 0;
		//标记首尾的有序区
		int end = a.length - 1;
		int start = 0;
		
		int temp, front, rear;
		//设置循环标记
		boolean flag = true;
		
		//初始化扫描区域
		front = start;
		rear = end;

		while (flag) {
			flag = false;
			//设置向下扫描的起始位置
			front = start;
			//向下扫描
			for (int j = front; j < rear; j++) {
				if (a[j] > a[j + 1]) {
					temp = a[j];
					a[j] = a[j + 1];
					a[j + 1] = temp;
					
					//记录底部有序区的起始位置
					end = j;

					flag = true;
				}
				sum++;
			}
			//排序结束条件：出现一趟排序没有进行过交换操作
			if (!flag) {
				break;
			}

			flag = false;
			//设置向上扫描的起始位置
			rear = end;
			//向上扫描
			for (int j = rear; j > front; j--) {
				if (a[j - 1] > a[j]) {
					temp = a[j - 1];
					a[j - 1] = a[j];
					a[j] = temp;
					
					//记录顶部有序区的结束位置
					start = j;
					flag = true;
				}

				sum++;
			}
		}
		return sum;
	}

7.4改进中存在的问题

      上述几种改进算法并没降低冒泡算法在最坏情况下（逆序）的执行效率:比较次数均为n(n-1)/2。只是改进了冒泡排序在部分情况下的效率，例如乱序数量较少等。

参考文献：http://blog.csdn.net/wdzxl198/article/details/8896447

                 http://blog.csdn.net/morewindows/article/details/6657829