快速排序的两种实现方式

相互覆盖类

public class quickSort1 {
    public static void main(String args[])
    {
        int[] array = {2,3,1,4,5,7,5,8,9,10};
        quickSort(0,array.length-1,array);
        for(int i : array)
        {
            System.out.println(i);
        }

    }
    public static void quickSort(int low,int high,int[] array)
    {
       	//定义递归结束条件，当low>=high的时候，说明只有1个元素
      	if(low>=high)
      	{
      		return ; //直接返回
      	}else{
      		int index = partiton(low,high,array);
      		//给左侧子序列做快排
      		quickSort(low,index-1,array);
      		//给右侧子序列做快排
      		quickSort(index+1,high,array);
      	}
    }
    public static int  partition(int low,int high,int[] array)
    {
    //以数组的
       	int key = array[low];
       	while(low<high)
       	{
       		//从后往前遍历，如果 array[high] > key,high--
       		while((array[high]>key)&&(high>low))
       		{
       			high--;
       		}
       		//如果此时low<high,说明array[high]是一个小于key的数
       		//把array[high]赋值给array[low](正好是key)
       		if(low<high)
       		{
       			array[low] = array[high];
       		}
       		//从前到后，如果array[low]<key，low++
       		while((array[low]<key)&&(high>low))
       		{
       			low++;
       		}
       		//如果此时low<high,说明array[low]是一个大于key的数
       		//把array[low]赋值给array[high](之前已经覆盖到了前面)，从而完成了交换
       		if(low<high)
       		{
       			array[high] = array[low];
       		}
       	}
       	//在遍历的时候严格限制了low<high,因此在这里就只有一种情况，即low==high,此时low的位置就是基准key的位置
       	array[low] = key;
       	return low; //把新的位置返回
    }
}

直接交换类型

public class quickSort2 {
    //快拍第二种实现方式,交换
    public static void main(String args[])
    {
        int[] array = {10,9,8,7,6,5,4,3,2,1};
        quickSort(0,array.length-1,array);
        for(int i : array)
        {
            System.out.print(i+" ");
        }
        System.out.println();
    }
    public static void quickSort(int low,int high,int[] array)
    {
        //递归终止条件
        if(low>=high)
        {
            return ;
        }if(low<high)
        {
            int index = partition(low,high,array);
            //左侧子序列 快排
            quickSort(low,index-1,array);
            //右侧子序列 快拍
            quickSort(index+1,high,array);
        }
    }
    public static int  partition(int low,int high,int[] array)
    {
    	//先定义基准值
    	int key = array[low];
    	int keyValue = low;
    	//开始partition
    	while(low<high)
    	{
    		//从后向前遍历，如果array[high] > key,high--
    		while((array[high]>key)&&(low<high))
    		{
    			high--;
    		}
    		//如果array[low] > key ,high++
    		while((array[low]<=key)&&(low<high))
    		{
    			low++;
    		}
    		/*
    		此时只有两种情况：
    		1、low<high 说明array[low]和array[high]一个大一个小，符合交换条件
    		1、low == high，说明array[low]和array[high]在同一位置无影响
    		*/
    		//执行交换
    		int temp = array[low];
    		array[low] = array[high];
    		array[high] = temp;
    	} 
    	//这个时候low==high但有两种情况
    	/*
    	 1、array[low] = array[high] >key
    	 2、array[low] = array[high] <key
    	*/
    	if(array[low]>key)
    	{
    		//array[low-1]与key互换
    		array[keyValue] = array[low-1];
    		array[low-1] = key;
    		//返回index low-2
    		return low-1;
    	}else
    	{
    		//array[low]与key互换
    		array[keyValue] = array[low];
    		array[low] = key;
    		//返回index low
    		return low;
    	}
    }
}