1、初识快速排序
同冒泡排序一样,快速排序也属于交换排序,通过元素之间的比较和交换位置来达到排序的目的。
不同的是:
- 冒泡排序在每一轮中只把1个元素冒泡到数列的一端
- 快速排序则在每一轮挑选一个基准元素,并让其他比它大的元素移动到数列一边,比它小的元素移动到数列的另一边,从而把数列拆解成两个部分;这种思路就叫作分治法,如下图所示:
使用分治法的优势
假如给出一个8个元素的数列,一般情况下,使用冒泡排序需要比较7轮,每一 轮把1个元素移动到数列的一端,时间复杂度是O(n²);快速排序的流程如下:
【原数列在每一轮都被拆分成两部分,每一部分在下一轮又分别被拆分成两部分,直到不可再分为止】
每一轮的比较和交换,需要把数组全部元素都遍历一遍,时间复杂度是O(n);
假如元素个数是n,那么平均情况下需要遍历logn轮,因此快速排序算法总体的平均时间复杂度是O(nlogn)
2、基准元素的选择
在分治过程中,以基准元素为中心,把其他元素移动到它的左右两边;
选择基准元素最简单的方式是选择数列的第1个元素,如下图:
例外:假如有一个原本逆序的数列,期望排序成顺序数列,如下图:
【整个数列并没有被分成两半,每一轮都只确定了基准元素的位置,在这种情况下,数列的第1个元素要么是最小值,
要么是最大值,根本无法发挥分治法的优势,快速排序需要进行n轮,时间复杂度退化成了O(n²)】
避免上面这种情况,可以随机选择一个元素作为基准元素,并且让基准元素和数列首元素交换位置
通过上述方法,可以有效地将数列分成两部分,但即使随机选择基准元素,也会有极小的几率选到数列的最大值或最小 值,同样会影响分治的效果;所以,快速排序的平均时间复杂度是O(nlogn),但最坏情况下的时间复杂度O(n²)
【在后文中,直接将首元素作为基准元素】
3、元素的交换
选定了基准元素之后要进行元素的交换,即把其他元素中小于基准元素的都交换到基准元素一边,大于基准元素的都交换到基准元素另一边,实现有两种方法:双边循环法和单边循环法
双边循环法(递归)
给出原始数列如下,要求对其从小到大进行排序
1、选定基准元素pivot,并且设置两个指针left和right,指向数列的最左和最右两个元素
2、进行第1次循环,从right指针开始,让指针所指向的元素和基准元素做比较【如果大于或等于pivot,则指针向左移动;如果小于pivot,则right指针停止移动,切换到left指针】;
在当前数列中1<4,所以right直接停止移动,换到left指针;让指针所指向的元素和基准元素做比较【如果小于或等于 pivot,则指针向右移动;如果大于pivot,则left指针停止移动】;
由于left开始指向的是基准元素,判断肯定相等,所以left右移1位,如下图:
由于7>4,left指针在元素7的位置停下;这时让left和right指针所指向的元素进行交换
3、进入第2次循环,重新切换到right指针,向左移动;right指针先移动到8,8>4,继续左移;由于2<4,停止在2的位置,后续步骤如下图所示:
双边循环法代码实现
Code:【使用递归】
import java.util.Arrays;
/**
* @ClassName QuickSort
* @Description 快速排序
* @Date: 2020/3/28
* @Version 1.0
*/
public class QuickSort {
public static void quickSort(int[] arr,int startIndex,int endIndex){
//递归结束条件:startIndex >= endIndex
if(startIndex >= endIndex){
return;
}
// 获取基准元素
int pivotIndex = partiton(arr,startIndex,endIndex);
// 根据基准元素,分成两部分进行递归排序
quickSort(arr,startIndex,pivotIndex -1);
quickSort(arr,pivotIndex + 1,endIndex);
}
//双边循环法
//arr 带交换的数组
//startIndex 起始下标
//endIndex 结束下标
public static int partiton(int[] arr,int startIndex,int endIndex){
//取第一个位置(也可以随机)的元素为基准元素
int pivot = arr[startIndex];
int left = startIndex;
int right = endIndex;
while (left != right){
//控制right指针比较并左移
while (left<right && arr[right]>pivot){
right--;
}
//控制left指针比较并右移
while (left < right && arr[left] <= pivot){
left++;
}
//交换left和right指针所指向的元素
if(left < right){
int p = arr[left];
arr[left] = arr[right];
arr[right] = p;
}
}
//pivot和指针重合点交换
arr[startIndex] = arr[left];
arr[left] = pivot;
return left;
}
public static void main(String [] args){
int[] arr = new int[]{4,7,6,5,3,2,8,1};
System.out.println("排序前:" + Arrays.toString(arr));
quickSort(arr,0,arr.length-1);
System.out.println("排序后:" + Arrays.toString(arr));
}
}
编译输出:【partition方法则实现了元素的交换,让数列中的元素依据自身大小分别交换到基准元素的左右两边】
单边循环法(递归)
双边循环法从数组的两边交替遍历元素,虽然更加直观,但是代码实现相对烦琐;
单边循环法只从数组的一边对元素进行遍历和交换,较为简单,详细过程:
给出原始数列如下,要求对其从小到大进行排序:
1、选定基准元素pivot,同时设置一个mark指针指向数列起始位置,这个mark指针代表小于基准元素的区域边界
2、从基准元素的下一个位置开始遍历数组
- 如果遍历到的元素大于基准元素,续往后遍历;
- 如果遍历到的元素小于基准元素,则需要做两件事:
- 1、把mark指针右移1 位,因为小于pivot的区域边界增大了1;
- 2、让最新遍历到的元素和mark指针所在位置的元素交换位置,【因为最新遍历的元素归属于小于pivot的区域】
遍历到元素7,7>4,所以继续遍历
来遍历到的元素是3,3<4,所以mark指针右移1位
让元素3和mark指针所在位置的元素交换,因为元素3归属于小于pivot 的区域
3、继续遍历,后续步骤如图所示:
单边循环法代码实现
Code:【使用递归】
/**
* @ClassName QuickSort
* @Description 快速排序
* @Date: 2020/3/28
* @Version 1.0
*/
public class QuickSort2 {
public static void quickSort(int[] arr,int startIndex,int endIndex){
//递归结束条件:startIndex >= endIndex
if(startIndex >= endIndex){
return;
}
// 获取基准元素
int pivotIndex = partiton(arr,startIndex,endIndex);
// 根据基准元素,分成两部分进行递归排序
quickSort(arr,startIndex,pivotIndex -1);
quickSort(arr,pivotIndex + 1,endIndex);
}
//单边循环法
//arr 带交换的数组
//startIndex 起始下标
//endIndex 结束下标
public static int partiton(int[] arr,int startIndex,int endIndex){
//取第一个位置(也可以随机)的元素为基准元素
int pivot = arr[startIndex];
int mark = startIndex;
for(int i = startIndex+1;i<endIndex;i++){
if(arr[i]<pivot){
mark++;
int p = arr[mark];
arr[mark] = arr[i];
arr[i] = p;
}
}
arr[startIndex] = arr[mark];
arr[mark] = pivot;
return mark;
}
public static void main(String [] args){
int[] arr = new int[]{4,7,6,5,3,2,8,1};
System.out.println("排序前:" + Arrays.toString(arr));
quickSort(arr,0,arr.length-1);
System.out.println("排序后:" + Arrays.toString(arr));
}
}
编译输出:【partition方法则实现了元素的交换,让数列中的元素依据自身大小分别交换到基准元素的左右两边】
非递归实现
绝大多数的递归逻辑,都可以用栈的方式来代替
代码中一层一层的方法调用,本身就使用了一个方法调用栈;
【每次进入一个新方法,就相当于入栈;每次有方法返回,就相当于出栈】
所以,可以把原本的递归实现转化成一个栈的实现,在栈中存储每一次方法调用的参数。
非递归代码实现
Code:【非递归】
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Stack;
/**
* @ClassName QuickSort
* @Description 快速排序
* @Date: 2020/3/28
* @Version 1.0
*/
public class QuickSort3 {
public static void quickSort(int[] arr,int startIndex,int endIndex){
//用一个集合栈来代替递归的函数栈
Stack<Map<String,Integer>> quickSortStack = new Stack<Map<String,Integer>>();
// 整个数列的起止下标,以哈希的形式入栈
Map rootParam = new HashMap();
rootParam.put("startIndex",startIndex);
rootParam.put("endIndex",endIndex);
quickSortStack.push(rootParam);
// 循环结束条件:栈为空
while (!quickSortStack.isEmpty()){
//栈顶元素出栈,得到起止下标
Map<String,Integer> param = quickSortStack.pop();
//得到基准元素位置
int pivotIndex = partiton(arr,param.get("startIndex"),param.get("endIndex"));
//根据基准元素分成两部分,把每一部分的起止下标入栈
if(param.get("startIndex")< (pivotIndex -1)){
Map<String,Integer> leftParam = new HashMap<String, Integer>();
leftParam.put("startIndex",param.get("startIndex"));
leftParam.put("endIndex",pivotIndex-1);
quickSortStack.push(leftParam);
}
if(pivotIndex + 1 < param.get("endIndex")){
Map<String,Integer> rightParam = new HashMap<String, Integer>();
rightParam.put("startIndex",pivotIndex+1);
rightParam.put("endIndex",param.get("endIndex"));
quickSortStack.push(rightParam);
}
}
}
//单边循环法
//arr 带交换的数组
//startIndex 起始下标
//endIndex 结束下标
public static int partiton(int[] arr,int startIndex,int endIndex){
//取第一个位置(也可以随机)的元素为基准元素
int pivot = arr[startIndex];
int mark = startIndex;
for(int i = startIndex+1;i<= endIndex;i++){
if(arr[i]<pivot){
mark++;
int p = arr[mark];
arr[mark] = arr[i];
arr[i] = p;
}
}
arr[startIndex] = arr[mark];
arr[mark] = pivot;
return mark;
}
public static void main(String [] args){
int[] arr = new int[]{4,7,6,5,3,2,8,1};
System.out.println("排序前:" + Arrays.toString(arr));
quickSort(arr,0,arr.length-1);
System.out.println("排序后:" + Arrays.toString(arr));
}
}
编译输出:【非递归方式代码的变动只发生在quickSort方法中; 该方法引入了一个存储Map类型元素的栈,用于存储每一次交换时的起始下标和结束下标。
**每一次循环,都会让栈顶元素出栈,通过partition方法进行分治,并且按照 基准元素的位置分成左右两部分,左右两部分再分别入栈,**当栈为空时,说明排序 已经完毕,退出循环】
———————————————————————————————————————
内容来源:《漫画算法》
关注公众号,回复 【算法】,获取高清算法书!