排序算法总结之交换类排序

快速排序（不稳定的排序）：从待排序记录序列中选取一个记录（通常选取第一个记录）为枢轴，其关键字设为K1，然后将其余关键字小于K1的记录移到前面，而将关键字大于K1的记录移到后面，结果将待排序记录序列分成两个子表，最后将关键字为K1的记录插入到其分界线的位置。一趟快速排序后，原序列一分为二，关键字K1前面的序列均小于K1，后面的序列均大于K1。之后对两个子表继续执行上述分割，直至子表表长不超过1为止。

• 最好情况：每趟排序之后将序列分成两个长度相等的子序列，时间复杂度T(n) = Cn+2T(n/2)≈
• 最坏情况：已经排好序，比较次数为（n-1）+（n-2）+…+1 = n(n-1)/2

import java.util.Iterator;

public class QuickSort {

	public static void main(String[] args) {
		int[] arr = {45,23,34,78,4,0,74,90,901};
		int low = 0;
		int high = arr.length-1;
		quick(arr, low, high);
		for (int i : arr) {
			System.out.println(i);
		}
		
	}

	private static void quick(int[] arr, int low, int high) {
		if (low < high) {
			int pos = quickFun(arr, low, high);
			quick(arr, low, pos - 1);
			quick(arr, pos+1, high);
		}
		
	}

	private static int quickFun(int[] arr,int low, int high) {
		if (high-low > 1) {//长度大于1才需要进行快排
			int key = arr[low];//枢轴元素
			while (low < high) {
				while (low < high && key <= arr[high]) {//关键字小于arr[high]的值，arr[high]不移动
					high--;
				}
				if (low < high) {
					arr[low] = arr[high];
					low++;
				}
				while (low < high && key > arr[low]) {//关键字小于arr[high]的值，arr[high]不移动
					low++;	
				}
				if (low < high) {
					arr[high] = arr[low];
					high--;
				}
			}
			arr[low] = key;
		}	
		return low;
	}

}

冒泡排序（稳定的排序）：对相邻的数据元素进行交换，逐步将带排序序列编程有序序列。每趟将一个记录排好位，最多需进行n-1趟排序

• 最好情况：已经排好序，只进行一趟排序，比较n-1次，不需要移动元素
• 最坏情况：逆序排列，进行n-1趟排序，比较（n-1）+（n-2）+…+1 = n(n-1)/2次，移动3n(n-1)/2次（每次比较移动三个元素）

private static void bubble(int[] arr) {
	int tmp;
	boolean flag = false;//flag标志，为true表示已经排好序，若一趟冒泡排序中没有发现一个逆序，则表明排序完成，可以直接结束排序过程
	for (int i = 0; i < arr.length-1; i++) {//控制排序的躺数
		flag = true;
		for (int j = 0; j < arr.length - i-1; j++) {//-1是为了防止arr[j+1]越界
			if (arr[j] > arr[j+1]) {
				tmp = arr[j];
				arr[j] = arr[j+1];
				arr[j+1] = tmp;
				flag = false;
			}
		}
		if (flag) {
			return;
		}
	}
	
}