经典快排代码:
package cn.itcats.sort;
import org.junit.Test;
/**
* (<R =R >R)归类快速排序,每次取数组最后一个数进行比较归类
* @author fatah
*/
public class QuickSort {
public void quickSort(int arr[]) {
if(arr ==null && arr.length < 2) {
return;
}
quickSort(arr,0,arr.length-1);
}
public void quickSort(int[] arr, int L, int R) {
if(L < R) {
int [] p = partition(arr,L,R);
quickSort(arr, L, p[0]-1);
quickSort(arr,p [1] +1,R);
}
}
public int[] partition(int[] arr, int L, int R) {
int less = L -1;
int more = R;
while(L < more) {
if(arr[L] < arr[R]) {
swap(arr,++less,L++);
}
else if(arr[L] >arr[R]) {
swap(arr,--more,L);
}else {
L++;
}
}
//交换最后一个数字,把最后比较的x值和more的第一个位置(被排好序的x)放到一起
//小于x =x 大于x
swap(arr,more,R);
return new int [] {less +1 ,more};
}
private void swap(int[] arr, int i, int j) {
int temp = arr[j];
arr[j] = arr[i];
arr[i] = temp;
}
@Test
public void flagTest() {
int num = 5;
int[] arr = { 4, 5, 3, 7, 6, 8, 0, 5 };
quickSort(arr, 0, arr.length - 1);
for (int i : arr) {
System.out.print(i + " ");
}
}
}
经典快排 时间复杂度O(N²),每次排序只解决一个数字的排序。(小于区域和大于区域规模不均),和数据状况有关系。
使用随机快速排序和经典快排不同,经典快排序每次取数组最后一个数进行比较归类,而随机快排是每次从数组中随机取一个数,放在数组末尾索引,进行排序,后续步骤同经典快排,只是取值比较的值是随机取的,那么无论最好还是最坏情况它都是一个概率事件,在大样本环境下,经过概率学证明后可以得到随机快排时间复杂度可以达到O(N*logN)。
随机快排代码:
package cn.itcats.sort;
import org.junit.Test;
public class RandomQuickSort {
public void RandomQuickSort(int [] arr) {
if(arr == null && arr.length <2) {
return ;
}
RandomQuickSort(arr,0,arr.length-1);
}
public void RandomQuickSort(int[] arr, int L, int R) {
if(L<R) {
int [] part = partition(arr,L,R);
RandomQuickSort(arr,L,part[0]-1);
RandomQuickSort(arr,part[1]+1,R);
}
}
private int[] partition(int[] arr, int L, int R) {
int less = L - 1;
//只加了这么一句代码。指在L ~ R范围内产生一个随机数
int ranR = L + (int)(Math.random() * (R-L+1));
//把随机数作为索引,将索引对应值与最后一位值 R 交换
swap(arr,ranR,R);
int more = R;
while(L < more) {
if(arr[L] < arr[R]) {
swap(arr,++less,L++);
}else if(arr[L] > arr[R]) {
swap(arr,--more,L);
}else {
L++;
}
}
swap(arr,R,more);
return new int[] {less+1,more};
}
public void swap(int[] arr, int L, int R) {
int temp = arr[L];
arr[L] = arr[R];
arr[R] = temp;
}
@Test
public void flagTest() {
int num = 5;
int[] arr = { 4, 5, 3, 7, 6, 8, 0, 5 };
RandomQuickSort(arr);
for (int i : arr) {
System.out.print(i + " ");
}
}
}
经典快速排序过渡到随机快速排序,时间复杂度由O(N²)上升到了O(N * logN)。其实在算法里面,规避样本量对时间复杂度的影响有两种做法,除了产生随机数的方式外,还可以使用hash。
随机快速排序时间复杂度O(N*logN),额外空间复杂度O(logN)