快速排序（algs4）

   排序类算法模板API

                                                       

package _2_Sorting;

import java.util.Scanner;

import edu.princeton.cs.algs4.StdRandom;
/**算法2.5 快速排序
 * 应用最广泛的排序算法
 * 优点：
 * 1.原地排序（只需要一个很小的栈）
 * 2.将长度为N的数组排序所需的时间和NlgN成正比
 * 缺点：
 * 非常脆弱
 * */
public class Quick
{
	public static void sort(Comparable[] a)
	{
		StdRandom.shuffle(a);     /*重新随机排序，消除对输入的依赖*/
		sort(a,0,a.length-1);
	}
	private static void sort(Comparable[] a,int lo,int hi)
	{
		if(hi<=lo)
			return;
		int j=partition(a,lo,hi); /*切分*/
		sort(a,lo,j-1);           /*将左半部分a[lo...j-1]排序*/
		sort(a,j+1,hi);          /*将右半部分a[j+1...hi]排序*/
	}
	private static int partition(Comparable[] a,int lo,int hi)
	{/**将数组切分为a[lo...i-1],a[i],a[i+1..hi]
	  *按照a[lo]的值v进行切分
	  *当指针i和j相遇时主循环退出，交换a[lo]和a[j]
	  *在循环中，a[i]<v时不做移动，i继续右移；同理a[j]>v时不做移动，继续左移
	  *遇到不符合次序的就进行交换
	  **/
		int i=lo, j=hi+1;/*左右扫描指针*/
		Comparable v=a[lo];/*切分元素*/
		while(true)
		{
			while(less(a[++i],v))/*扫描左右，检查扫描是否结束并交换元素*/
				if(i==hi)
					break;
			while(less(v,a[--j]));   /*切分元素是左边界*/
		    if(i>=j)
			  break;
	    	exch(a,i,j);
		}
		exch(a,lo,j);          /*将v=a[i]放入正确位置*/
		return j;             /*a[lo..j-1]<=a[j]<==a[j+1..hi]达成*/
	}
	private static void exch(Comparable[] a,int i,int j)
	{
		Comparable t=a[i];
		a[i]=a[j];
		a[j]=t;
	}
	private static boolean less(Comparable v,Comparable w)
	{
		return v.compareTo(w)<0;
	}
	private static void show(Comparable[] a)
	{
		for(int i=0;i<a.length;i++)
			System.out.println(a[i]+" ");
		System.out.println();
	}
	public static void main(String[] args)
	{
		Scanner sc=new Scanner(System.in);
		int N;
		N=sc.nextInt();
		String[] a=new String[N];
		sc.nextLine();                  /*读走换行*/
		System.out.println("请输入"+N+"个字符串：");
		for(int i=0;i<N;i++)
			a[i]=sc.nextLine();
		sort(a);
		show(a);
	}
}

                                     

                        

                                                            

	private static void sort(Comparable[] a,int lo,int hi)
	{/**三向切分的快速排序
	能将和切分元素相等的元素归位
	对存在大量重复元素的数组，这种方法比标准的快速排序的效率高得多。
	*/
		if(hi<=lo)
			return;
		int lt=lo,i=lo+1,gt=hi;
		Comparable v=a[lo];
		while(i<=gt)
		{/*a[i]小于v，将a[lt]和a[i]交换，将lt和i加一；
		a[i]大于v，将a[gt]和a[i]交换，将gt减一；
		a[i]等于v，将i加一
		*/
			int cmp=a[i].compareTo(v);
			if(cmp<0) 
				exch(a,lt++,i++);
				else if(cmp>0)
					exch(a,i,gt--);
					else i++;
		}
		sort(a,lo,lt-1);
		sort(a,gt+1,hi);
	}