排序算法之交换排序——冒泡排序

假设：待排序记录S={r1,r2,r3,......,rn}，待排序记录的长度为n。(在下述中我们以递增冒泡排序进行举例)

一、冒泡排序的思想

将相邻记录的关键字进行比较，若满足条件（递增或递减），则记录的关键值不交换；若不满足条件，则交换记录的关键值，直到所有的记录都已经排好序了。

二、冒泡排序的步骤

1.第一步：将r1.key与r2.key进行比较，若r1.key>r2.key,则将记录r1和记录r2的关键值进行交换，反之，不交换。紧接着依次对r2与r3，r3与r4，......，r（n-1）与rn的关键值进行比较，若不满足条件的再进行交换。至此，完成冒泡排序的第一趟排序。此时我们会发现：记录关键值较小的逐渐向前移动，记录关键值最大的已经被移至最后。

2.第二步：完成上一步我们会发现，现在我们只需要对前n-1个记录进行排序（最后的记录是最大值，满足条件，不需要再比较），按照第一步的步骤进行排序，完成第二趟的排序。此时我们会发现：记录关键值较小的逐渐向前移动，记录关键值次大的被移至第n-1的位置。然后，对前n-2个记录进行排序，完成第三趟排序；对前n-3个记录进行排序，完成第四趟排序；.......；对前2个记录进行排序，完成最后一趟排序。排序全部完成。

注：n个记录递增冒泡排序总共需要（n-1）趟排序，比较n（n-1）/2次。

三、冒泡排序的例子

eg:有一组待排序的记录，它们的关键值分别为：35，64，12，53，45，74，68，72，按照递增的顺序进行排序。

代码示例：最下面。

四、冒泡排序的优化

1.简单的优化：

A.正常的情况下，要对一组有n个记录的待排序序列进行冒泡排序，我们需要进行（n-1）趟排序。但是在一些特殊的情况下，可以减少排序的趟数。例如我们上述的列子，在该例子中第二趟以后完全没有必要再进行排序了，因为他们的顺序已经排好了。此时，我们可以对排序优化，避免不必要的排序继续进行，提高代码执行效率。

B.优化方法：定义一个标志变量flag，在每趟排序前设置flag=false，在每趟排序过程中如果发生数据交换则将flag赋值为true，如果一趟排序后，flag的值仍为false，则代表记录的顺序已经排好了，可以结束算法了。这样就可以避免不必要的排序进行下去，对算法进行了简单的优化。

C.代码示例：最下面。

2.进一步的优化：

A.适用范围：在另一种极端的情况下，在n个待排序记录中只有少数几个记录是无序的，不满足要求，其他的记录都是有序的，如果只是采取简单的优化算法，我们依然需要遍历2*n次。其实我们的内层循环长度的设定有一定的根据的：第i趟排序后i-1个记录是排好序的，但是实际上第i趟排序是根据第i趟排序的内层循环长度是取决于最后一次记录的交换位置index（简单的优化就是没有考虑这一点），很明显，index后面的记录是有序满足要求的。

B.优化方法：内层循环的条件应该取决于上一趟排序后最后一次记录的交换位置。

C.代码示例：最下面。

代码示例：

public class BubbleSort
{
	public static void main(String[] args)
	{
		/*int[] intArr = new int[]{9,8,7,6,5,4,3,2,1};
		int variate;
		//冒泡排序
		for(int i = 0; i < (intArr.length - 1); ++i)
		{
			System.out.println("现在是第"+(i+1)+"趟排序");
			System.out.println();
			for(int j = 0; j < (intArr.length - i - 1); ++j)
			{
				System.out.println("第"+(j+1)+"次比较的结果：");
				if(intArr[j] > intArr[j + 1])
				{
					variate = intArr[j];
					intArr[j] = intArr[j + 1];
					intArr[j + 1] = variate;
				}
				for(int k = 0; k < intArr.length; ++k)
				{
					System.out.print(intArr[k]+" ");
				}
				System.out.println();
			}
			System.out.println();
		}
		System.out.println("最终排序结果：");
		for(int i = 0 ; i < intArr.length; ++i)
		{
			System.out.print(intArr[i]+" ");
		}
		System.out.println();*/


		/*//冒泡排序的简单优化
		int[] intArr = new int[]{35,64,12,53,45,74,68,72};
		int variate;
		int flag;//用来判断是否需要继续执行排序
		for(int i = 0; i < (intArr.length - 1); ++i)
		{
			flag = 0;
			System.out.println("现在是第"+(i+1)+"趟排序");
			System.out.println();
			for(int j = 0; j < (intArr.length - i - 1); ++j)
			{
				System.out.println("第"+(j+1)+"次比较的结果：");
				if(intArr[j] > intArr[j + 1])
				{
					flag = 1;
					variate = intArr[j];
					intArr[j] = intArr[j + 1];
					intArr[j + 1] = variate;
				}
				for(int k = 0; k < intArr.length; ++k)
				{
					System.out.print(intArr[k]+" ");
				}
				System.out.println();
			}
			System.out.println();
			if(flag == 0)
			{
				break;
			}
		}
		System.out.println("最终排序结果：");
		for(int i = 0 ; i < intArr.length; ++i)
		{
			System.out.print(intArr[i]+" ");
		}
		System.out.println();*/


		//冒泡排序的进一步优化
		int[] intArr = new int[]{6,5,4,3,2,1};
		boolean flag;
		int mark = intArr.length - 1;
		int index = 0;
		for(int i = 0; i < intArr.length - 1; ++i)
		{
			flag = false;
			System.out.println("第"+(i + 1)+"趟排序");
			System.out.println();
			for(int j = 0;  j < mark; ++j)
			{
				System.out.println("第"+(j + 1)+"次交换结果：");
				if(intArr[j] > intArr[j + 1])
				{
					int temp = intArr[j];
					intArr[j] = intArr[j + 1];
					intArr[j + 1] = temp;

					flag = true;
					index = j + 1;
				}
				for(int m = 0; m < intArr.length; ++m)
				{
					System.out.print(intArr[m]+" ");
				}
				System.out.println();
			}
			if(!flag)
			{
				break;
			}
			mark = index;
			System.out.println();
		}
		System.out.println();
		System.out.println("排序结果：");
		for(int k = 0; k < intArr.length; ++k)
		{
			System.out.print(intArr[k]+" ");
		}
		System.out.println();
	}
}