拉勾数据结构课之快速排序算法

快速排序算法：

实现代码一：

 /*快速排序
    以第一个数为基准点，把大于基准点的放在基准点右边，小于基准点的放在基准点左边。
    再把左边的当作一个新的数组1，右边的当作一个新数组2，分别重新选取新的数组1，2的基准点不断执行小于基准点的放左边，大于基准点的放右边
   不断划分左右数组序列，直到左右数组序列只剩一个数
    实现方法：
    定义两个哨兵i，j，j每次先从后往前找到第一个小于基准点的数,如果此时i，j,没有相遇，i在 j找到数后从前往后找到第一个大于基准点的数
    不断 重复该过程，直到i,j相遇，相遇点即为基准点应该所处的位置
    把基准点前后各划分为一个新的数组后重复1，2过程，直到形成的数组只有一个数*/
   public static void quickSort(int a[],int low,int high){
        if(low>high){//说明此时序列中只有一个数，可以退出递归
            return;
        }
        int i,j,key;
        i=low;
        j=high;
        key=a[low];
        while(i<j){
            while(i<j&&a[j]>=key){
                j--;
            }
            while(i<j&&a[i]<=key){
                i++;
            }
            if(i<j){
                int temp=a[i];
                a[i]=a[j];
                a[j]=temp;
            }
        }
        int temp=a[i];
        a[i]=a[low];
        a[low]=temp;
        quickSort(a,low,i-1);
        quickSort(a,i+1,high);
   }

实现代码二：

public void quickSortRecursion(int[] nums,int low,int high){
		if(low>=high) return;
		int p=getPartionValue(nums,low,high);
		quickSortRecursion(nums,low,p-1);
		quickSortRecursion(nums,p+1,high);
		
	}
	public int getPartionValue(int[] nums,int low,int high){
		 Random random = new Random();
		int s = random.nextInt(high)%(high-low+1) + low;
		swap(nums,s,high);
		int i=0,j=0;
		for(i=low,j=low;j<high;){
           //所注释的是对swap(nums,i++,j);过程的一个详细代码实现
			/*if(nums[j]<=nums[high]){
			  if(i!=j) swap(nums,i,j);
				i++;
				j++;
			}else{
			j++;
			}*/
			if(nums[j]<=nums[high])
				swap(nums,i++,j);
                //使用注释的代码请去掉j++;
                j++;
		}
			
		swap(nums,i,j);
		return i;
	}
	public void swap(int[] nums,int low,int high){
		int temp=nums[low];
		nums[low]=nums[high];
		nums[high]=temp;
	}

代码二相对代码一来说较难理解，其中的swap(nums,i++,j); 方法的具体过程是这样的:

假设数组中有2、1、7、9、5、8六个数，选取的基准点值假设为8，那么swap 方法流程如下：

i=0,j=0       nums[0]<nums[high]    swap(nums,0,0)

i=1,j=1      nums[1]<nums[high]    swap(nums,1,1)

i=2,j=2      nums[2]<nums[high]    swap(nums,2,2)

i=3,j=3      nums[3]>nums[high]   j=4

i=3,j=4      nums[4]<nums[high]    swap(nums,3,4) 此时数组变为 2、1、7、5、9、8 

i=4,j=5      j=high  退出循环     swap(nums,4,5)

此时数组变为 2、1、7、5、8、9  返回基准值8所应该在的正确位置4

递归继续进行上述操作。

复杂度分析：

时间复杂度：

最优情况：被选取出的基准值都为中间数 ：T(n)=2*T(n/2)+O(n),所以最优情况为O(nlogn)

最坏情况：基准值为最大值或最小值：T(n)=T(n-1)+O(n),所以最坏情况为O(n*n)

空间复杂度：O(1)*logn=O(logn)

LeetCode 相关题目：

LeetCode 215 题：求数组中第k大的数

public int quickKsort(int[] nums,int low,int high,int k){
		int j=0;
		while(low<high){
			j=getPartionValue(nums,low,high);
			if(j==k-1) return nums[j];
			else if(j<k-1) low=j+1;
			else high=j-1;
		}
		return -1;
	}
public int getPartionValue(int[] nums,int low,int high){
		 Random random = new Random();
		int s = random.nextInt(high)%(high-low+1) + low;
		swap(nums,s,high);
		int i=0,j=0;
		for(i=low,j=low;j<high;j++){
			/*if(nums[j]<=nums[high]){
			  if(i!=j) swap(nums,i,j);
				i++;
				j++;
			}else{
			j++;
			}*/
			if(nums[j]<=nums[high])
				swap(nums,i++,j);
		
		}
			
		swap(nums,i,j);
		return i;
	}