LeetCode – Kth Largest Element in an Array (Java)

Find the kth largest element in an unsorted array. Note that it is the kth largest element in the sorted order, not the kth distinct element.

For example, given [3,2,1,5,6,4] and k = 2, return 5.

Note: You may assume k is always valid, 1 ≤ k ≤ array's length.

Java Solution 1 - Sorting

public int findKthLargest(int[] nums, int k) {
    Arrays.sort(nums);
    return nums[nums.length-k];
}

Time is O(nlog(n)).

Java Solution 2 - Quick Sort

This problem can also be solved by using quickselect, which is similar to quicksort.

public int findKthLargest(int[] nums, int k) {
	if (k < 1 || nums == null) {
		return 0;
	}
 
	return getKth(nums.length - k +1, nums, 0, nums.length - 1);
}
 
public int getKth(int k, int[] nums, int start, int end) {
 
	int pivot = nums[end];
 
	int left = start;
	int right = end;
 
	while (true) {
 
		while (nums[left] < pivot && left < right) {
			left++;
		}
 
		while (nums[right] >= pivot && right > left) {
			right--;
		}
 
		if (left == right) {
			break;
		}
 
		swap(nums, left, right);
	}
 
	swap(nums, left, end);
 
	if (k == left + 1) {
		return pivot;
	} else if (k < left + 1) {
		return getKth(k, nums, start, left - 1);
	} else {
		return getKth(k, nums, left + 1, end);
	}
}
 
public void swap(int[] nums, int n1, int n2) {
	int tmp = nums[n1];
	nums[n1] = nums[n2];
	nums[n2] = tmp;
}

Average case time is O(n), worst case time is O(n^2).

Java Solution 3 - Heap

We can use a min heap to solve this problem. The heap stores the top k elements. Whenever the size is greater than k, delete the min. Time complexity is O(nlog(k)). Space complexity is O(k) for storing the top k numbers.

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

Reference:
http://www.cs.yale.edu/homes/aspnes/pinewiki/QuickSelect.html

Category >> Algorithms >> Interview >> Others  
If you want someone to read your code, please put the code inside <pre><code> and </code></pre> tags. For example:
<pre><code> 
String foo = "bar";
</code></pre>

  1. Jason Zhu on 2015-6-21

    An O(NlogK) solution applying MinHeap:


    public static int solution_1(int[] arr, int k) throws Exception {
    //parameter check
    assert (arr != null && arr.length > 0 && k > 0 && k <= arr.length);
    MinHeap minHeap = new MinHeap(k);
    for(int i = 0; i < arr.length; ++i) {
    if(minHeap.getCurSize() < k) minHeap.insert(arr[i]);
    else if(minHeap.peek() < arr[i]) {
    minHeap.getHeapArray()[0] = arr[i];
    minHeap.siftDown(0);
    }
    }
    return minHeap.removeMin();
    }
    public static void main(String[] args) throws Exception {
    System.out.println(solution_1(new int[]{3,2,1,5,6,4}, 1));
    System.out.println(solution_1(new int[]{3,2,1,5,6,4}, 2));
    System.out.println(solution_1(new int[]{3,2,1,5,6,4}, 3));
    System.out.println(solution_1(new int[]{3,2,1,5,6,4}, 4));
    System.out.println(solution_1(new int[]{3,2,1,5,6,4}, 5));
    System.out.println(solution_1(new int[]{3,2,1,5,6,4}, 6));
    System.out.println(solution_1(new int[]{4,6,5,1,2,3}, 1));
    System.out.println(solution_1(new int[]{4,6,5,1,2,3}, 2));
    System.out.println(solution_1(new int[]{4,6,5,1,2,3}, 3));
    System.out.println(solution_1(new int[]{4,6,5,1,2,3}, 4));
    System.out.println(solution_1(new int[]{4,6,5,1,2,3}, 5));
    System.out.println(solution_1(new int[]{4,6,5,1,2,3}, 6));
    }

  2. Riaz Ud Din on 2015-12-11

    The heading is wrong, it finds the kth smallest element. Not the kth largest element

  3. 肖永博 on 2016-3-5

    for the recursive code above, the last condition(k > left + 1), the 1st parameter for recursive function should be (k – left – 1)

  4. Aaron Ke on 2016-3-19

    i think original post is correct, it should be k since the calculation is always based on the indexs of nums,

  5. Matias SM on 2016-4-3

    A guaranteed processing O(K log N) and space O(N) solution is:
    1- Build max heap with the contents of the array O(N)
    2- remove first K elements (K log N)
    3- the Kth max is the last removed element in step 2

    Also, just a note: the average case time for the given solution (quickselect) is O(n) _only_ when using randomized pivot selection (just like in quick sort), not for the naive selection logic used in the example.

  6. Jay on 2016-6-12
  7. Hooman on 2017-4-14

    Build max heap with the contents of the array actually takes O(n * log(n)) .

  8. Matias SM on 2017-4-17
  9. John Smith on 2017-5-25

    agree. current implementation is for k-th SMALLEST element in array

Leave a comment

*