基于快速排序的几种算法变型

一，快速排序算法

基本思想：通过一趟排序将待排序记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可以分别对这两部分记录继续进行排序，从而达到整个序列有序的目的。

复杂度以及稳定性分析：时间复杂度为O（nlogn），最坏情况下，时间复杂度为O（n*n）;就空间复杂度来说，主要是递归造成栈空间的使用，最好情况，递归树的深度为log2（n），其空间复杂度为O（logn）,最坏情况，需要n - 1次递归调用，其空间复杂度为O（n），平均情况，空间复杂度为O（logn）。

由于关键字的比较和交换是跳跃式进行的，因此，快速排序是一种不稳定的排序方法。

参考代码如下：

import java.util.Arrays;

public class QSort {
	public static void qSort(int[] arr, int low,int high){
		int pivot = 0;
		if(low < high){
			pivot = parition(arr,low,high);
			qSort(arr, low, pivot - 1);   //对低子表递归排序
			qSort(arr, pivot + 1, high);  //对高子表递归排序
		}
	}
	//选取枢轴，使得左边的值比它小，右边的值比它大
	public static int parition(int[] arr, int low, int high){
		int key = arr[low];   //用子表第一个元素作为枢轴元素
		while(low < high){   //从数组两端交替向中间扫描
			while(low < high && arr[high] >= key){
				high--;
			}
			arr[low] = arr[high];
			while(low < high && arr[low] <= key){
				low++;
			}
			arr[high] = arr[low];
		}
		arr[low] = key;   //将枢轴替换为arr[low]
		return low;
	}
	public static void main(String[] args) {
		int[] arr = {1,3,5,7,9,2,4,6,8,10};
		qSort(arr, 0, arr.length - 1);
		System.out.println("排序后：" + Arrays.toString(arr));
	}
}

二，快速排序的几种变型

（1）得到数组中任意第k大的数字

算法思想：基于快速排序的思想，如果基于数组的第k个数字来调整，使得比第k个数字小的所有数字都位于数组的左边，比第k个数字大的所有数字都位于数组的右边，调整之后返回第k个数字即可

参考代码如下：

import java.util.ArrayList;

public class GetLeastNums {
	public static int partition(int[] array,int low,int high){
		int key = array[low];
		while(low < high){
			while(low < high && array[high] >= key){
				high--;
			}
			array[low] = array[high];
			while(low < high && array[low] <= key){
				low++;
			}
			array[high] = array[low];
		}
		array[low] = key;
		return low;
	}
	
	public static void getLeastNums(int[] arr, int k){
		int low = 0;
		int high = arr.length - 1;
		int index = partition(arr, low, high);
		while(index != k - 1){
			if(index > k -1){
				index = partition(arr, low, index - 1);
			}else {
				index = partition(arr, index + 1, high);
			}
		}
		int result = arr[k -1];
		System.out.println(result);
	}
	public static void main(String[] args) {
		int[] arr = {4,5,1,6,2,7,3,8};
		getLeastNums(arr,5);
	}
}

（2）最小的k个数字，第一题的一种变型。例如输入4,5,1,6,2,7,3,8，则最小的4个数字是1,2,3,4.

算法思想：基于快速排序的思想，如果基于数组的第k个数字来调整，使得比第k个数字小的所有数字都位于数组的左边，比第k个数字大的所有数字都位于数组的右边。调整之后，位于数组左边的k个数字就是最小的k个数字（这k个数字不一定是排序的）。

参考代码如下：

import java.util.ArrayList;

public class GetLeastNums {
	public static int partition(int[] array,int low,int high){
		int key = array[low];
		while(low < high){
			while(low < high && array[high] >= key){
				high--;
			}
			array[low] = array[high];
			while(low < high && array[low] <= key){
				low++;
			}
			array[high] = array[low];
		}
		array[low] = key;
		return low;
	}
	/*
	 * 最小的k个数字
	 * 算法思想：基于快速排序的思想，如果基于数组的第k个数字来调整，使得比第k个数字小的所有数字都位于数组的左边，比第k个数字大的所有数字都位于数组的右边
	 * */
	public static void getLeastNums(int[] arr, int k){
		int low = 0;
		int high = arr.length - 1;
		int index = partition(arr, low, high);
		while(index != k - 1){
			if(index > k -1){
				index = partition(arr, low, index - 1);
			}else {
				index = partition(arr, index + 1, high);
			}
		}
		ArrayList<Integer> list = new ArrayList<>();
		for(int i = 0; i < k; i++){
			list.add(arr[i]);
		}
		System.out.println(list);
	}
	public static void main(String[] args) {
		int[] arr = {4,5,1,6,2,7,3,8};
		getLeastNums(arr,5);
	}
}

（3）数组中出现次数超过一半的数字

例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}，由于数字2在数组中出现了5次，超过了数组长度的一半，因此输出2.

算法思想：基于快排的思想，如果基于数组的第n/2个数字来调整，使得比第n/2个数字小的所有数字都位于数组的左边，比第n/2个数字大的所有数字都位于数组的右边

参考代码如下：

public class MoreThanHalfNum {
	public static int partition(int[] array,int low,int high){
		int key = array[low];
		while(low < high){
			while(low < high && array[high] >= key){
				high--;
			}
			array[low] = array[high];
			while(low < high && array[low] <= key){
				low++;
			}
			array[high] = array[low];
		}
		array[low] = key;
		return low;
	}
	/*
	 * 
	 * 数组中出现次数超过一半的数字
	 * 算法思想：基于快排的思想，如果基于数组的第n/2个数字来调整，使得比第n/2个数字小的所有数字都位于数组的左边，比第n/2个数字大的所有数字都位于数组的右边
	 * */
	public static int moreThanHalfNum(int[] arr){
		int middle = arr.length >> 1;
		int low = 0;
		int high = arr.length - 1;
		int index = partition(arr, low, high);
		while(index != middle){
			if(index > middle){
				index = partition(arr, low, index - 1);
			}else {
				index = partition(arr, index + 1, high);
			}
		}
		int result = arr[middle];
		return result;
	}
	public static void main(String[] args) {
		int[] arr = {1,2,3,2,2,2,5,4,2};
		System.out.println(moreThanHalfNum(arr));
	}
}