交换排序（冒泡、快速）

冒泡排序

排序策略

相邻的两个元素的关键字进行比较，小的元素向上冒，大的元素向下沉

排序过程

以集合{49, 38, 65, 97, 76, 13, 27, 49}中数据为例，执行一趟冒泡排序

①比较49、38（执行交换）

②比较49、65

③比较65、97

④比较97、76（执行交换）

⑤比较97、13（执行交换）

⑥比较97、27（执行交换）

⑦比较97、49（执行交换）

可以发现，已经将集合中最大的数97排到了尾部、所以对于含有n个数据的列表只需执行n-1次，就能完成排序

实现代码

/*** 冒泡排序* @param list 需要排序的行列* @return 排序结果*/public static int[] bubSort(int[] list) {//交换值int temp = 0;//循环处理（第一层循环为执行的趟数，第二层循环为比较数据、交换）for(int i = 0; i < list.length-1; i++) {for(int j = 0; j <list.length-1-i; j++) {if(list[j] > list[j+1]) {temp = list[j+1];list[j+1] = list[j];list[j] = temp;}}} return list;}

测试结果

时间及空间复杂度

①时间
最好，原先序列为正序：比较次数n-1(1趟）、移动次数0
最坏，原先序列为倒序：比较次数即(n*(n-1))/2、移动次数即(3*n*(n-1))/2（每次执行三次交换操作）

即平均时间复杂度为：T(n)=O(n²)
②空间
S(n)=O(1)
③稳定性
由于是两个相邻的数据比较、交换，所以是稳定的

适用范围

① n较小
②局部有序
③在n个待排序的数据中选择前k(k<<n时)个最大值（只需执行n趟）

快速排序

排序策略

任选一个元素的关键字（一般为key[0]）作为标准，将序列分成两部分。其中左半部分的结点的关键字小于等于该元素的关键字，右半部分的结点的关键字大于等于该元素的关键字。然后, 对左右两部分分别进行类似的处理，直至排好序为止

排序过程

以集合{49, 38, 65, 97, 76, 13, 27, 49}中数据为例，执行一趟快速排序

①取出索引为0的数据（49），设置i、j指针指向头和尾

②从j开始，判断**(list[j] = 49) = 49**，则移动j指针（j- -）

③从j开始，判断**(list[j] = 27) < 49**，则将27放置于i处

④从i开始，判断**(list[j] = 38) < 49**，则移动i指针（i++）
⑤从i开始，判断**(list[j] = 65) > 49**，则将65放置于j处
⑥从j开始，判断**(list[j] = 13) < 49**，则将13放置于i处

⑦从i开始，判断**(list[j] = 97) > 49**，则将97放置于j处

⑧从j开始，判断**(list[j] = 49) = 49**，则移动j指针（j- -）

⑨此时i=j,将49插入其中

然后可对49两边的数据分别进行排序，类似于二叉树向下扩展，每一个点都会扩展出两个子点，借助于二分查找的思想，一层接一层，直至排序结束

实现代码

一次排序执行代码：

/*** 一次快速排序* @param list 需要排序的行列* @param i 头指针* @param j 尾指针* @return  拍寻结束中间指针*/public static int onceQuiSort(int[] list, int i, int j) {//取出第一位元素作为界点int point = list[i];while(i != j) {//由于表头元素为界点，界点已经被取出，此时表头可存储数据，则先从表尾开始//此处使用>=和<=判断，以免出现重复数据导致死循环while(i != j && list[j] >= point) {//表尾数据大于界点，移动指针j--;}//否则，将较小值放在界点前list[i] = list[j];//再从表头开始while(i != j && list[i] <= point) {//表头数据小于界点，移动指针i++;}//否则，将较小值放在界点之后list[j] = list[i];}//将界点放于表中list[i] = point; return i;}

类似于二叉树的遍历，使用递归来进行整体排序：

/*** 快速排序* @param list 需要排序的行列* @param i 数据开始索引* @param j 数据结束索引* @return 排序的结果*/public static int[] quiSort(int[] list, int i, int j) {//长度大于一时，使用递归进行排序（相当于一个二叉树）if(i < j) {int mid = onceQuiSort(list, i, j);System.out.println(Arrays.toString(list));//左边排序,需使得mid-1，不然会死循环quiSort(list, i, mid-1);//右边排序quiSort(list, mid+1, j);}return list;}

测试结果

时间及空间复杂度

①时间
对于第一次排序（将所有数据都排序），i与j从两边移动到中间，若只考虑判断，为O(n)
而主排序方法由于使二分法，类似于二叉树

最好，每次选中的界点排序后都位于中心位置，即二叉树为完全二叉树，这时树有log₂n层
最坏，每次选中的界点排序后都位于边缘位置，即二叉树为最坏的二叉树，每个结点只有一个孩子，这时树有n-1层

对于每一层虽然分为了很多个部分，但结合起来相当于将所有数据都排序
则，最优：T(n) = O(n*log₂n)
最差：T(n) = O(n²)

即平均时间复杂度为：T(n) = O(n*log₂n)

②空间
由于使用了一个递归，对于中间值mid的存储需要一个栈
最优：S(n) = O(log₂n)
最差：S(n) = O(n)

即平均空间复杂度为：T(n) = O(log₂n)

③稳定性
该方法是与界点进行比较，并将左端大于界点的记录移至右端，将右端小于的记录移至左端，所以在移动过中，原两个相同大小的记录的位置会有变化。即该排序方法是一种不稳定的排序方法。

适用范围

①n较大且表无序时
②选取第k(1<=k<=n)个元素时（只需让k成为界点，执行一次快速排序）