快速排序（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;
}
}
58万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
