给定整数数组 nums 和整数 k，请返回数组中第 k 个最大的元素。
请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。
你必须设计并实现时间复杂度为 O(n) 的算法解决此问题。
示例 1:
输入: [3,2,1,5,6,4], k = 2
输出: 5
示例 2:
输入: [3,2,3,1,2,4,5,5,6], k = 4
输出: 4
本题就是考排序算法
public int findKthLargest(int[] nums, int k) {
// selectSort(nums);
// insertSort(nums);
// shellSort(nums);
// mergeSort(nums,0,k);
// bubbleSort(nums);
heapSort(nums);
// quickSort(nums,0,k);
return nums[nums.length-k];
}
//selectSort 每次将当前元素替换为后面最小的元素（选择排序）
public static void selectSort(int [] nums){
int N = nums.length;
for(int i = 0; i < N; i ++){
int min = i;
for(int j = i + 1; j < N; j ++){
if(nums[j] < nums[min]) min = j;
}
int t = nums[i];
nums[i] = nums[min];
nums[min] = t;
}
}
//insertSort 每次将当前元素插入到前面已经排好序的元素中（插入排序）
public static void insertSort(int[] a){
int N = a.length;
for (int i = 0; i < N; i++) {
int temp = a[i];
int j = i;
for (; j > 0 && a[j-1] > temp; j--) {
a[j] = a[j-1];
}
a[j] = temp;
}
}
//shellSort 将数组分组，并不断减小分组的步长直到为1，每次分组均进行插入排序（希尔排序）
public static void shellSort(int[] a){
for (int step = a.length/2; step > 0; step/=2) {
for (int i = step; i < a.length; i++) {
int temp = a[i];
int j = i;
for (; j >= step && a[j-step] > temp ; j-=step) {
a[j] = a[j-step];
}
a[j] = temp;
}
}
}
//mergeSort 递归 对两个有序节点序列进行合并来实现排序，分治思想（归并排序）
//分解的方法
public void mergeSort(int[] arr,int left,int right){
//如果左边索引小于右边就可以一直分，l=r时，就是分到只剩一个数了
if(left<right){
int mid = (left + right) / 2;//左少右多
//向左递归分解
mergeSort(arr,left,mid);
//向右递归分解
mergeSort(arr,mid+1,right);
//合并
merge(arr,left,mid,right);
}
}
//合并的方法
public void merge(int[] arr, int left,int mid,int right) {
int i = left;
int j = mid +1;
int[] temp = new int[right-left+1];//中转数组
int t = 0;//temp数组的当前索引
//合并数组，比较找最大
while (i<=mid && j<=right){
if(arr[i]<=arr[j])temp[t++] = arr[i++];
else temp[t++] = arr[j++];
}
while (i<=mid) temp[t++] = arr[i++];
while (j<=right) temp[t++] = arr[j++];
//将temp数组拷贝到arr数组，并不是每次都拷贝所有
t = 0;
while (left<=right) arr[left++] = temp[t++];
}
//bubbleSort n-1遍历，每次找到未排序数组的最大值（冒泡）
public void bubbleSort(int[] arr){
for (int i = arr.length-1; i >= 0; i--) {
for (int j = 0; j < i; j++) {
if(arr[j]>arr[j+1]){
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
}
//heapSort 构建大顶堆或者小顶堆，将堆顶元素与堆尾元素交换后再调整，如此反复
public void heapSort(int[] arr){
//构建大顶堆 k为最后一个非叶子节点，逐渐-1，即从下向上，从右往左
for(int k = arr.length/2 - 1;k>=0;k--){
adjustHeap(arr,k,arr.length);
}
//排序 交换+调整
int temp =0;
for (int i = arr.length-1; i >= 0; i--) {
temp =arr [0];
arr[0] = arr[i];
arr[i] = temp;
adjustHeap(arr,0,i);
}
}
public void adjustHeap(int[] arr,int i,int length){
int temp = arr[i];//取出当前非叶子叶结点的值
//k为当前节点的左子节点
for(int k = 2*i+1;k<length;k=2*k+1){
if(k+1<length && arr[k+1]>arr[k]){//右子节点大于左子节点
k++;//k指向右子节点
}
if(arr[k]>temp){//如果当前节点大于父节点就交换
arr[i] = arr[k];
i =k;//!!!!!!精髓，因为该子节点值大小发生了改变，可能会使其子根堆发生改变，索引要调整其子根堆
}else {
break;//否则直接退出，因为其后面的节点一定满足堆定义
}
}
arr[i] = temp;
}
//quickSort 每次选择一个元素并且将整个数组以这个元素分为两部分，小于该元素的放右边，大于该元素的放左边
public void quickSort(int[] arr,int l,int r){
if(l<r){ //跳出递归的条件
//partition就是划分操作，将arr划分成满足条件的两个子表
int n= partition(arr,l,r);
//依次对左右两个子表进行递归排序
quickSort(arr,l,n - 1);
quickSort(arr,n + 1,r);
}
}
public int partition(int[] arr,int l,int r){
//以当前数组的最后一个元素作为中枢pivot，进行划分
int pivot = arr[r];
while (l<r){
while (l<r && arr[l]<pivot) l++;
arr[r] = arr[l];//将比中枢值大的移动到右端r处 由于r处为中枢或者该位置值已经被替换到l处，所以直接可以替换
while (l<r && arr[r]>=pivot) r--;
arr[l] = arr[r];//将比中枢值小的移动到左端l处 由于前面l处的值已经换到r处，所以该位置值也可以替换掉
}
//l==r时，重合，这个位置就是中枢的最终位置
arr[l] = pivot;
//返回存放中枢的最终位置
return l;
}
