LeetCode215. 数组中的第K个最大元素-手写快排（非最优）

1.题目

2.思路

快排实际是一个递归的操作，我们来看第一次操作：

1.随机取一个数，一般可以固定为start = 0作为比较的值key = nums[start]

2.首先从尾部开始移动end 指针，如果nums[end] >= key , 就继续移动，直到nums[end] < key 为止

3.再移动头部指针start, 如果nums[start] <= key, 就继续移动，直到nums[start] > key为止

4.交换 start 和 end 的数字 ，然后递归1 - 3步骤。

核心思想：其实就是为了让前面的数都小于key, 后面的数都大于key

3.代码

里面还有一个冒泡排序的写法 -- n * n   居然没超时！！！

快排 -- n logn

还有堆排序啥的，之后再写！

class Solution {
    public int findKthLargest(int[] nums, int k) {
        // Arrays.sort(nums); //官方实现的就是快
        quickSort(nums, 0, nums.length - 1);
        // sort(nums); // 冒泡
        return nums[nums.length - k];
    }
    // public void sort(int[]arr){
    //     int n = arr.length;
    //     for(int i = 0 ; i < n; i++){
    //         for(int j = i + 1; j < n; j++){
    //             if(arr[i] > arr[j])
    //                 swap(arr, i, j);
    //         }
    //     }
    //     return ;
    // }

    public void quickSort(int[]arr, int low, int high){
        int start = low, end = high;
        int key = arr[start];
        while(start != end){
            // 必须先从尾部开始遍历 -- 等于还不能少
            while(start < end && key <= arr[end])
                end--;
            // 然后才从头部开始 ---等于还不能少
            while(start < end && key >= arr[start])
                start++;
            // 如果颠倒顺序，就不对

            if(start != end)
                swap(arr, start, end);
        }
        //更换初始比较的key
        swap(arr, start, low);
        if(low < start)
            quickSort(arr, low, start - 1);
        if(end < high)
            quickSort(arr, end + 1, high);
        return ;
    }

    public void swap(int[]arr, int i, int j){
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
        return ;
    }
}

4.结果