Java_快速排序

快排思路：

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)       
// 稳定性 ---------- 不稳定