数组系列—数组中第k大的数

最新推荐文章于 2023-02-09 21:16:15 发布

原创最新推荐文章于 2023-02-09 21:16:15 发布 · 881 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#快排应用

算法学习专栏收录该内容

23 篇文章

订阅专栏

博客介绍了找第k大的数的两种方法。一是用快速排序，有两种方式；二是利用堆，大根堆通过对数组构建大顶堆并进行K次deleteMax操作得到结果，小根堆则构建k大小的小根堆，装完数组元素后，堆顶即为第k大的数。

1、快速排序找第k大的数

方式1

	/**
	 *	
	 *			快排的每次将一个数排到有序时的位置，
	 *		 	前面的小于、后面的大于当前值
	 *
	 */
	public int findKMaxInteger(int array[],int low,int high, 
	int findK){
          int i = low;
          int j = high;
          int key = array[i];
          //一趟排序
          while(i<j){
              while(i<j&&array[j]>=key){
                   j--;
              }
              array[i] = array[j];
              while(i<j&&array[i]<=key){
                    i++;
              }
              array[j] = array[i];  
              array[i] = key;
          }
          if(j>findK-1) {
              return findKMaxInteger(array, low, j-1, findK);
          }else if(j<findK-1) {
              return findKMaxInteger(array, j+1, high, findK);
          }else{
              return j;
          }
      }

方式2

  public int findKthLargest(int[] arr, int k) {
        if (k > arr.length) {
            return -1;
        }
        return findKth(arr, 0, arr.length - 1, k);
    }

    public static int findKth(int[] a, int start, int end, int k) {
        int pivot = partition(a, start, end);
        if (k == pivot - start + 1){
            return a[pivot];
        } else if (k > pivot - start + 1) {
            return findKth(a, pivot + 1, end, k - pivot + start -1);
        } else{
            return findKth(a, start, pivot - 1, k);
        }
    }

    public static int partition(int[] a, int low, int high) {
        int key = a[low];
        while (low < high) {
            while (low < high && a[high] <= key){
                high--;
            }
            a[low] = a[high];
            while (low < high && a[low] >= key){
                low++;
            }
            a[high] = a[low];
        }
        a[low] = key;
        return low;
    }

2、最大堆/最小堆

大根堆思路：将数据读入一个数组，对数组进行buildHeap(我们这里构建大顶堆)，之后对堆进行K次deleteMax操作，第K次的结果就是我们需要的值。

小根堆：构建一个k大小的小根堆，把数组的数全部装进去，大的始终会被丢到下面，而最小的会被放到堆顶，所以装完之后，第k大的在小根堆堆顶。

  public  int findKthLargest(int[] nums, int k) {
        PriorityQueue<Integer> q = new PriorityQueue<>(k);
        for (int i : nums) {
            q.add(i);
            if (q.size() > k) {
                q.poll();
            }
        }
        return q.peek();
    }