排序 - 快速排序（3）

分类

冒泡排序和快速排序

冒泡排序

概念

冒泡排序的基本思想：两两比较待排序记录的键值，并交换不满足顺序要求的那些偶对，直到全部满足顺序要求为止。

将待排序的记录的键值顺次两两比较，若为“逆序”则将两个记录交换。将序列照此方法从头到尾处理一遍称为一趟冒泡排序，这一趟冒泡排序的效果是将键值最大的记录交换到该记录排序的最终位置。若某一趟过程没有任何记录交换发生，则排序过程结束。对含n个记录的文件进行排序最多需要n-1趟冒泡排序。

算法原理

冒泡排序算法的原理如下：

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

排序演示

设待排序文件的键值为{15,20,11,10,23,13}，执行冒泡排序的过程如图所示，从图中可见，在冒泡排序的过程，键值较小的记录好比水中气泡逐趟上浮，而键值较大的记录好比石块往下沉，每趟有一块“最大”的石块沉到水底。

代码

    public static void bubbleSort2(int[] array) {
		//趟数：array.lenth-1趟
		for(int i=1;i<array.length;i++) {
			//每趟的比较的次数
			for(int j=1;j<array.length+1-i;j++) {
				//比较,并交换
				if(array[j]<array[j-1]) {
					int tmp=array[j];
					array[j]=array[j-1];
					array[j-1]=tmp;
				}
			}
		}
	}

算法分析

1. 时间复杂度

   若文件的初始状态是正序的，一趟扫描即可完成排序。所需的关键字比较次数和记录移动次数 均达到最小值：n-1，0

   所以，冒泡排序最好的时间复杂度为 O(n) 。
   若初始文件是反序的，需要进行  趟排序。每趟排序要进行  次关键字的比较(1≤i≤n-1)。在这种情况下，比较和移动次数均达到最大值：
   C max= n-1 + n-2 + … + 2 + 1 = n * (n-1) / 2 

   冒泡排序的最坏时间复杂度为 O(n2) 。

   综上，因此冒泡排序总的平均时间复杂度为 O(n2)。

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

快速排序

概念

快速排序又称为分区交换排序，是对冒泡排序的一种改进。

基本思想：在待排序的n个数据中任意选取一个数据（通常选用数组的第一个数）作为关键数据，然后将所有比它小的数都放到它左边，所有比它大的数都放到它右边，这个过程称为一趟快速排序。然后分别对所划分的两部分重复上述过程，一直重复到每部分内只有一个数据为止，排序完成。

算法原理

1. 设置两个变量i、j，排序开始的时候：i=0，j=N-1；
2. 以第一个数组元素作为关键数据，赋值给key，即key=A[0]；
3. 从j开始向前搜索，即由后开始向前搜索(j--)，找到第一个小于key的值A[j]，将A[j]和A[i]的值交换；
4. 从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于key的A[i]，将A[i]和A[j]的值交换；
5. 重复第3、4步，直到i=j； (3,4步中，没找到符合条件的值，即3中A[j]不小于key,4中A[i]不大于key的时候改变j、i的值，使得j=j-1，i=i+1，直至找到为止。找到符合条件的值，进行交换的时候i， j指针位置不变。另外，i==j这一过程一定正好是i+或j-完成的时候，此时循环结束）。

排序演示

实现代码（递归实现）

	public static void quickSort1(int[] array) {
		quickSort2(array,0,array.length-1);
	}
	private static void  quickSort2(int[] array,int left,int right) {
		if(left<right) {
			int point=partition(array,left,right);
			quickSort2(array,left,point-1);
			quickSort2(array,point+1,right);
		}
	}
	private static int partition(int[] array, int left, int right) {
		int point=array[left];
		while(left<right) {
			while(left<right&&array[right]>=point) {
				right--;
			}
			if(array[right]<point) {
				array[left]=array[right];
				left++;
			}
			
			while(left<right&&array[left]<=point) {
				left++;
			}
			if(array[left]>point) {
				array[right]=array[left];
				right--;
			}
		}
		array[left]=point;
		return left;
	}

算法分析

1. 时间复杂度

   可以看出，每一次调用partition()方法都需要扫描一遍数组长度（注意，在递归的时候这个长度并不是原数组的长度n，而是被分隔出来的小数组，即n*(2^(-i))），其中i为调用深度。而在这一层同样长度的数组有2^i个。那么，每层排序大约需要O(n)复杂度。而一个长度为n的数组，调用深度最多为log(n)层。二者相乘，得到快速排序的平均复杂度为O(n ㏒n)。

   通常，快速排序被认为是在所有同数量级的排序方法中，平均性能最好。

2. 空间复杂度
   从代码中可以很容易地看出，快速排序单个栈的空间复杂度不高，每次调用partition方法时，其额外开销只有O(1)。所以，最好情形下快速排序空间复杂度大约为O(㏒n)，最坏情况下，需要空间为O（n）。
3. 算法稳定性
   快速排序不是一种稳定的排序算法，也就是说，多个相同的值的相对位置也许会在算法结束时产生变动。
   如：100,1，2,3,100,4,，第一个100就放到最后了

使用场景

快速排序在大多数情况下都是适用的，尤其在数据量大的时候性能优越性更加明显。但是在必要的时候，需要考虑下优化以提高其在最坏情况下的性能。