快速排序、堆排序

//快速排序
/*
1. 选取Pivot作为中心轴，这个是随便选择的
2. 将大于Pivot的数字放在Pivot的右边
3. 将小于Pivot的数字发那个在Pivot的左边
4. 分别对左右子序列重复前三个步骤
*/
class Solution {
    public int findKthLargest(int[] nums, int k) {
        quickSort(nums, nums.length);
        return nums[nums.length-k];
    }

    public void quickSort(int[] arr, int n){
        qsort(arr, 0, n-1);
    }

    public void qsort(int[] arr, int low, int high){
        if(low<high){
            int mid = partition(arr, low, high);
            qsort(arr, low, mid-1);
            qsort(arr, mid+1, high);
        }
    }

    public int partition(int[] arr, int low, int high){
        int i=low-1, j=high;
        int pivot = arr[high];
        while(true){
            while(arr[++i] < pivot && i<high);
            while(arr[--j] > pivot && j>low);
            if(i<j){
                swap(arr, i, j);
            }else{
                break;
            }
        }
        //交换枢纽元素，把枢纽元素放到正确的位置上
        swap(arr, i, high);
        return i;
    }
    
    public void swap(int[] a, int i, int j) {
        int temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
}




//堆排序，这一题主要考察不同的排序
/*
针对堆排序，对于其代码实现不作阐述，因为太过于复杂，主要是堆处理的复杂。

在此，对其算法的核心步骤作一定描述：

堆排序，本质上，分为两步：

        1   建立堆：

                        1 广度优先初始化堆

                        2大数上浮，使满足堆属性

       2   堆排序：

                        1 取走树根的值

                        2 将树根的值与 最下层 最右侧（注意这个描述所代表的位置）的叶子节点交换

                        3 去掉经过步骤2交换后的最下层，最右侧的叶子节点（也就是原根节点）

                        4 将最大数上浮至根

                        5 重复1、2、3、4

堆排序使用了堆这种数据结构，对数据进行排序，尽管上述过程看起来并不复杂，但在实际写程序的时候，也并不是一个简单的过程。
*/
 class Solution {
     public int findKthLargest(int[] nums, int k) {
         int heapSize = nums.length;
         buildMaxHeap(nums, heapSize);
         //到这里堆排就结束了
         for(int i= nums.length-1;i>=nums.length-k+1;i--){
             swap(nums, 0, i);
             --heapSize;
             maxHeapify(nums, 0, heapSize);
         }  
         return nums[0];
     }
     public void buildMaxHeap(int[] arr, int heapSize){
         for(int i = heapSize/2;i>=0;i--){
             maxHeapify(arr, i, heapSize);
         }
     } 
     public void maxHeapify(int[] arr, int i, int heapSize){
         int l = i*2+1, r = i*2+2, largest = i;
         if(l<heapSize && arr[l]>arr[largest]){
             largest = l;
         }
         if(r<heapSize && arr[r]>arr[largest]){
             largest = r;
         }
         if(largest != i){
             swap(arr, i, largest);
             maxHeapify(arr, largest, heapSize);
         }
     }
     public void swap(int[] a, int i, int largest){
         int temp = a[i];
         a[i] = a[largest];
         a[largest] = temp;
     }
 }


//使用内置api
 class Solution {
     public int findKthLargest(int[] nums, int k) {
         Arrays.sort(nums);
         return nums[nums.length - k];

     }
 }