快速排序(QUICK SORT)
原理
通过一组排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另一部分的所有数据要小,然后再按照此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此使所有数据变成有序序列。
动态示意图
思路
- 分解:先从数列中取出一个元素作为基准元素。以基准元素为标准,将问题分解为两个子序列,使小于或等于基准元素的子序列在左侧,使大于基准元素的子序列在右侧。在 R[low : high] 选定一个元素 R[pivot] ,以此为标准将要排序的序列划分为两个序列 R[low : pivot-1] 和 R[pivot+1 :high] ,并使序列 R[low : pivot-1] 中所有元素的值小于或等于 R[pivot],序列 R[pivot+1 :high] 中所有的元素均大于 R[pivot],此时基准元素已经位于正确的位置,它无需参与后面的排序。
- 治理:对两个子序列 R[low : pivot-1] 和 R[pivot+1 :high] 分别通过递归调用快速排序算法来进行排序。
- 合并:将排好序的两个子序列合并在一起,得到原问题的解。由于对 R[low : pivot-1] 和 R[pivot+1 :high] 的排序是在原地进行的,所以在 R[low : pivot-1] 和 R[pivot+1 :high] 都排好序后,合并步骤无需做什么。
基准元素的选取方法 基准元素的选取方法:
-
取第一个元素
-
取最后一个元素
-
取中间位置的元素
-
取第一个、最后一个、中间位置元素三者之中位数
-
举例说明
30,24,5,58,18,36,12,42,39(再次选区第一个元素作为基准元素)
============================================================================
第一趟快速排序:
- 初始化。i = low,j = high,piovt = R[low] = 30
- 向左走。从数组右边位置向左找,一直找到小于等于 piovt 的数 12
R[i] 和 R[j] 交换,i++。
- 向右走。从数组的左边位置向右找,一直找到比 piovt 大的数58
j– - 向左走。从数组的右边位置向左找,一直找到小于或等于 piovt 的数18,
R[i] 和 R[j] 交换,i++
此时,i = j,第一轮快速排序结束,返回 i 的位置, mid = i。此时以 mid 为界,把原数据分为两个子序列,左侧序列都比 piovt 小,右侧序列都比 piovt 大。
然后分别对两个子序列(12,24,5,18,)和(36,58,42,39)进行快速排序
代码实现
//划分函数
public static int partition(int[] r, int low, int high){
int i = low;
int j = high;
int pivot = r[low];
while(i < j){
//向左扫描
while(i < j && r[j] > pivot)
j--;
if(i < j){
//交换r[i]和r[j]
int temp = r[i];
r[i] = r[j];
r[j] = temp;
i++;
}
//向右扫描
while(i < j && r[i] < pivot)
i++;
if(i < j){
//交换r[i]和r[j]
int temp = r[i];
r[i] = r[j];
r[j] = temp;
j--;
}
}
return i; //返回基准元素的位置
}
//快速排序递归算法
public static void quickSort(int[] R, int low, int high){
int mid = 0;
if(low < high){
mid = partition(R, low, high);
quickSort(R, low, mid-1);
quickSort(R,mid+1, high);
}
}
//快速排序非递归
import java.util.Stack;
public class Main {
Stack<Record> stack = new Stack<>();
public void quickSort(int[] arr){
int left = 0;
int right = arr.length - 1;
if(left < right){
int pivot = 小米.partition.Main.partition(arr, left, right);
if(pivot - 1 >= left){
stack.push(new Record(left, pivot-1));
}
if(pivot + 1 < right){
stack.push(new Record(pivot + 1, right));
}
while (!stack.isEmpty()){
Record record = stack.pop();
pivot = 小米.partition.Main.partition(arr, record.left, record.right);
if(pivot-1 > record.left){
stack.push(new Record(record.left, pivot-1));
}
if(pivot + 1 > record.right){
stack.push(new Record(pivot+1, record.right));
}
}
}
}
private static class Record{
int left;
int right;
private Record(int left, int right){
this.left = left;
this.right = right;
}
}
}
相关题目
数组中出现次数超过一半的数字
题目描述
数组中有一个数字出现的次数超过数组长度的一半,请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次,超过数组长度的一半,因此输出2。如果不存在则输出0。
思路及解答
/*
思路:
1. 如果一个数组中的一个数字出现的次数超过数组长度的一半,那么如果将这个数组排序,这个数组的中位数一定
就是长度超过一半的数字。我们知道,对于中位数来说,他左边的数都比它小,它右边的数都比它大。看到这里,
我们想到了快速排序中的Partition函数,首先随机选择一个数,把小于这个数的所有数字放到这个数的左边,大于
这个数的所有数字放到它的右边。
2. 结合前面的分析,如果这个数字的下标正好是n/2,说明它就是我们要找的那个数;如果这个数的下标小于n/2,我们就到
这个数的右边去找,如果大于n/2,我们就到这个数的左边去找。
3. 大的问题的解决需要小的问题的解决,而且解决的思路一样,所以这里使用递归的思路去解这道题。
*/
public class Solution {
public int MoreThanHalfNum_Solution(int [] array) {
//判断输入的数组是不是无效的
if(checkInvalidArray(array))
return 0;
int middle = array.length >> 1;//定义中位数的位置
int start = 0;//定义需要查找的起始位置
int end = array.length - 1;//定义查找的终止位置
int index = partition(array, start, end);//定义调整位置后返回的位置
//1. 寻找中位数
while(index != middle){
//如果返回的位置小于middle,则到index的右边去找
if(index < middle){
start = index + 1;
index = partition(array, start, end);
}else{//如果返回的位置大于middle,则到index的左边去找
end = index - 1;
index = partition(array, start, end);
}
}
int result = array[index];
return result;
}
//检查是否为无效数组
boolean arrayInvalid = false;
public boolean checkInvalidArray(int[] array){
if(array == null || array.length == 0){
arrayInvalid = true;
}
return arrayInvalid;
}
//检查中位数是否位次数最多的元素
public boolean checkMoreThanHalf(int[] array, int number){
int times = 0;
for(int i = 0; i < array.length; i++){
if(array[i] == number){
times++;
}
}
boolean isMoreThanHalf = true;
if(times*2 <= array.length){
arrayInvalid = true;//为无效数组
isMoreThanHalf = false;
}
return isMoreThanHalf;
}
public int partition(int[] array, int low, int high){
int i = low;
int j = high;
int pivot = array[low];
while(i < j){
//向左扫描
while(i < j && array[j] > pivot)
j--;
if(i < j){
swap(array, i++, j);
}
//向右扫描
while(i < j && array[i] <= pivot)
i++;
if(i < j){
swap(array, i, j--);
}
}
return i;
}
//交换数组中两个元素的位置
public void swap(int[] array, int i, int j){
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
最小的K个数
题目描述
输入n个整数,找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字,则最小的4个数字是1,2,3,4,。
思路及解答
/*
思路:
利用partition算法的思路
1. 定义一个变量为index为每次partition函数的返回值
2. 如果index正好为k-1,则说明从0到index正好是最小的k个数
*/
import java.util.ArrayList;
public class Solution {
public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
ArrayList<Integer> res = new ArrayList<Integer>();
if(input == null || input.length == 0 || k > input.length || k <= 0)
return res;
int start = 0;
int end = input.length - 1;
int index = partition(input, start, end);
while(index != k-1){
//如果返回的index大于k-1,那么继续调整index左边的数
if(index > k-1){
end = index - 1;
index = partition(input, start, end);
}else{
start = index + 1;
index = partition(input, start, end);
}
//如果返回的inde小于k-1,那么到index的右边去找
}
for(int i = 0; i < k; i++){
res.add(input[i]);
}
return res;
}
public int partition(int[] arr, int low, int high){
int i = low;
int j = high;
int piovt = arr[low];
//向左扫描
while(i < j){
while(i < j && arr[j] > piovt) j--;
if(i < j) swap(arr, i++, j);
//向右扫描
while(i < j && arr[i] <= piovt) i++;
if(i < j) swap(arr, i, j--);
}
return i;
}
//交换数组中i和j的位置
public void swap(int[] arr, int i, int j){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}