快速排序之topk

使用快排解决top k的问题 解法是最优的
时间复杂度 O(N)，空间复杂度 O(1)

public class Qs {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		System.out.println("dss");
		int array[]= {3,2,1,2,5};
		System.out.println(findKlargest(array,4));
	}
	public static int  findKlargest(int array[],int k) {
		k=array.length-k;
		int l=0;
		int r=array.length-1;
		while(l<r) {
			int j=parition(array,l,r);
			if(j==k) {
				break;
			}else if(j>k) {
				r=j-1;
			}else if (j<k) {
				l=j+1;
			}
		}
		return  array[k];
	}
	
	public static int parition(int array[],int l,int r) {
		
	int i=l;
	int j=r+1;
	while(true) {
	while(array[++i]<array[l]&&i<r);
	while (array[--j]>array[l]&&j>l);
	if(i>=j) 
	{break;}
	 swap(array, i, j);
	}
		swap(array, l, j);
		return j;
	}
	private static  void swap(int[] a, int i, int j) {
	    int t = a[i];
	    a[i] = a[j];
	    a[j] = t;
	}
}

解析
主要包含三个函数，主函数找到最大k， 循环l<r 然后判断partition 返回来的是不是k，进行判断
快排函数选取第一个作为pivot，进行对比 交换 返回该游标 的位置

快排

public class QuickSort<T extends Comparable<T>> extends Sort<T> {

    @Override
    public void sort(T[] nums) {
        shuffle(nums);//先洗牌
        sort(nums, 0, nums.length - 1);
    }

    private void sort(T[] nums, int l, int h) {
        if (h <= l)
            return;
        int j = partition(nums, l, h);
        sort(nums, l, j - 1);
        sort(nums, j + 1, h);
    }

    private void shuffle(T[] nums) {
        List<Comparable> list = Arrays.asList(nums);
        Collections.shuffle(list);
        list.toArray(nums);
    }
}
private int partition(T[] nums, int l, int h) {
    int i = l, j = h + 1;
    T v = nums[l];
    while (true) {
        while (less(nums[++i], v) && i != h) ;
        while (less(v, nums[--j]) && j != l) ;
        if (i >= j)
            break;
        swap(nums, i, j);
    }
    swap(nums, l, j);
    return j;
}