快排思路:
1.随机打乱所有数,保证数据的随机性。
2.需要两个辅助函数,一个是交换函数,一个是分区操作函数。
3.先从序列中挑取一个数,以该数作为基准,所有比基准大的数方在基准后面,比基准小的数放在基准前面。
基准函数:选取第一个数作为基准。选取头尾两个指针,将头指针向右移动,尾指针向左移动。如果头指针位置元素小于基准,则将头指针向右移动,如果尾指针元素大于基准,则将尾指针向左移动。直到,头指针元素大于等于基准,尾指针元素小于等于基准,将两个元素交换。
直至头指针>=尾指针,则将基准值与尾节点元素做交换,并返回尾节点位置。
Sort函数采用递归的方式:
递归基:如果hi<=lo的话则返回。
递归:调用partition函数,返回partition之后的基准节点位置j,之后基准节点位置j左边的元素全部小于基准节点,右边的元素都大于基准节点。
然后将排序分为基准节点左侧有右侧,分别进行排序。之后递归调用partition。
package Suanfa;
import java.util.Random;
//快排
public class Suanfa2 extends Suanfa1{
public static void sort(Comparable[] a) {
sort(a,0,a.length-1);
}
public static void sort(Comparable[] a,int lo,int hi) {
if(hi<=lo) return;
//这里可以进行修改,//if(hi<=lo+5) return InsertSort(a)//小规模数组用插入排序
int j=partition(a,lo,hi);
sort(a,lo,j-1);
sort(a,j+1,hi);
}
public static int partition(Comparable[] a,int lo,int hi) {
int i=lo,j=hi+1;
Comparable v=a[lo];
while(true) {
while(less(a[++i],v)) System.out.println(i);if(i==hi) break;
//当a[++i]小于v时,则++i循环,如果发现a[++i]大于v时,则不满足while条件退出小循环
while(less(v,a[--j])) System.out.println(j);if(j==lo) break;
//同样当a[--j]小于v时则退出小循环
if(j<=i) break;//这是最后一步退出大循环true
exch(a,i,j);//这是在退出小循环后,进行交换数据
}
exch(a,lo,j);//将基准索引位置和j向交换
return j;
}
public static void main(String[] args) {
String[] a= {"E","A","S","Y","Q"};
sort(a);
assert isSorted(a);
show(a);
}
}
package Jianzhi;
import java.util.Random;
public class kuaipai {
public static void sort(int[] array,int lo,int hi) {
if(lo>=hi) {
return ;
}
int index=partition(array,lo,hi);
sort(array,lo,index-1);
sort(array,index+1,hi);
}
public static int partition(int[] array,int lo,int hi) {
int key=array[lo];
while(lo<hi) {
while(array[hi]>=key&&hi>lo) {//从后向前扫面,保证后面的数字都大于
hi--;
}
if(array[hi]<key) {
int temp=array[hi];
array[hi]=array[lo];
array[lo]=temp;
}
while(array[lo]<=key&&hi>lo) {
lo++;
}
if(array[lo]>key) {
int temp=array[hi];
array[hi]=array[lo];
array[lo]=temp;
}
}
array[hi]=key;
return hi;
}
public static void main(String []args){
System.out.println("Hello World");
int[] a = {12,20,5,16,15,1,30,45,23,9};
int start = 0;
int end = a.length-1;
sort(a,start,end);
for(int i = 0; i<a.length; i++){
System.out.println(a[i]);
}
}
}
将长度为N的无重复数组排序,快速排序平均需要~2NlnN次比较。
快速排序最多需要N2/2次比较
三取样切分方法
设置三个指针,lt=lo,i=lo+1,gt=hi
每次循环都只能保证a[lo,lt-1]小于v,a[gt+1,hi]大于v,a[lt,i]等于v,a[i,gt]数据没确定。
package Suanfa;
public class Suanfa3 extends Suanfa1{
public static void sort(Comparable[] a,int lo,int hi) {
if(hi<=lo) return;
int lt=lo,i=lo+1,gt=hi;
//关键是这三个指针,每次都将i指针数值和v值比较
Comparable v=a[lo];
while(i<=gt) {
int cmp=a[i].compareTo(v);
if(cmp<0) exch(a,lt++,i++);
else if(cmp>0) exch(a,i,gt--);
//当a[i]比v大,将a[i]与gt位置交换,但gt位置数据不知道是否比v大小,所以这里i不加是为了保证下次循环,比较交换之后的数据是与v的大小
else i++;
}
//每次循环都只能保证a[lo,lt-1]小于v,a[gt+1,hi]大于v,a[lt,i]等于v,a[i,gt]数据没确定。
sort(a,lo,lt-1);
sort(a,gt+1,hi);
}
}
// 分类 ------------ 内部比较排序
// 数据结构 --------- 数组
// 最差时间复杂度 ---- 每次选取的基准都是最大(或最小)的元素,导致每次只划分出了一个分区,需要进行n-1次划分才能结束递归,时间复杂度为O(n^2)
// 最优时间复杂度 ---- 每次选取的基准都是中位数,这样每次都均匀的划分出两个分区,只需要logn次划分就能结束递归,时间复杂度为O(nlogn)
// 平均时间复杂度 ---- O(nlogn)
// 所需辅助空间 ------ 主要是递归造成的栈空间的使用(用来保存left和right等局部变量),取决于递归树的深度,一般为O(logn),最差为O(n)
// 稳定性 ---------- 不稳定