# Kth Largest Element in an Array LeetCode Solution

Here, We see Kth Largest Element in an Array LeetCode Solution. This Leetcode problem is done in many programming languages like C++, Java, JavaScript, Python, etc. with different approaches.

# List of all LeetCode Solution

## Problem Statement

Given an integer array `nums` and an integer `k`, return the `kth` largest element in the array.

Note that it is the `kth` largest element in the sorted order, not the `kth` distinct element.

Can you solve it without sorting?

Example 1:
Input: nums = [3,2,1,5,6,4], k = 2
Output: 5

Example 2:
Input: nums = [3,2,3,1,2,4,5,5,6], k = 4
Output: 4

## Kth Largest Element in an Array LeetCode SolutionC++

``````class Solution {
public:
int findKthLargest(std::vector<int>& nums, int k) {
int left = 0, right = nums.size() - 1;
while (true) {
int pivot_index = rand() % (right - left + 1) + left;
int new_pivot_index = partition(nums, left, right, pivot_index);
if (new_pivot_index == nums.size() - k) {
return nums[new_pivot_index];
} else if (new_pivot_index > nums.size() - k) {
right = new_pivot_index - 1;
} else {
left = new_pivot_index + 1;
}
}
}

private:
int partition(std::vector<int>& nums, int left, int right, int pivot_index) {
int pivot = nums[pivot_index];
std::swap(nums[pivot_index], nums[right]);
int stored_index = left;
for (int i = left; i < right; i++) {
if (nums[i] < pivot) {
std::swap(nums[i], nums[stored_index]);
stored_index++;
}
}
std::swap(nums[right], nums[stored_index]);
return stored_index;
}
};```Code language: PHP (php)```

## Kth Largest Element in an Array LeetCode SolutionJava

``````public class Solution {
public int findKthLargest(int[] nums, int k) {
int left = 0, right = nums.length - 1;
Random rand = new Random();
while (true) {
int pivot_index = left + rand.nextInt(right - left + 1);
int new_pivot_index = partition(nums, left, right, pivot_index);
if (new_pivot_index == nums.length - k) {
return nums[new_pivot_index];
} else if (new_pivot_index > nums.length - k) {
right = new_pivot_index - 1;
} else {
left = new_pivot_index + 1;
}
}
}

private int partition(int[] nums, int left, int right, int pivot_index) {
int pivot = nums[pivot_index];
swap(nums, pivot_index, right);
int stored_index = left;
for (int i = left; i < right; i++) {
if (nums[i] < pivot) {
swap(nums, i, stored_index);
stored_index++;
}
}
swap(nums, right, stored_index);
return stored_index;
}

private void swap(int[] nums, int i, int j) {
int temp = nums[i];
nums[i] = nums[j];
nums[j] = temp;
}
}```Code language: PHP (php)```

## Kth Largest Element in an Array SolutionJavaScript

``````var findKthLargest = function(nums, k) {
const partition = (left, right, pivotIndex) => {
const pivot = nums[pivotIndex];
[nums[pivotIndex], nums[right]] = [nums[right], nums[pivotIndex]];
let storedIndex = left;
for (let i = left; i < right; i++) {
if (nums[i] < pivot) {
[nums[storedIndex], nums[i]] = [nums[i], nums[storedIndex]];
storedIndex++;
}
}
[nums[right], nums[storedIndex]] = [nums[storedIndex], nums[right]];
return storedIndex;
};

let left = 0, right = nums.length - 1;
while (true) {
const pivotIndex = left + Math.floor(Math.random() * (right - left + 1));
const newPivotIndex = partition(left, right, pivotIndex);
if (newPivotIndex === nums.length - k) {
return nums[newPivotIndex];
} else if (newPivotIndex > nums.length - k) {
right = newPivotIndex - 1;
} else {
left = newPivotIndex + 1;
}
}
};```Code language: JavaScript (javascript)```

## Kth Largest Element in an Array SolutionPython

``````class Solution:
def findKthLargest(self, nums, k):
left, right = 0, len(nums) - 1
while True:
pivot_index = random.randint(left, right)
new_pivot_index = self.partition(nums, left, right, pivot_index)
if new_pivot_index == len(nums) - k:
return nums[new_pivot_index]
elif new_pivot_index > len(nums) - k:
right = new_pivot_index - 1
else:
left = new_pivot_index + 1

def partition(self, nums, left, right, pivot_index):
pivot = nums[pivot_index]
nums[pivot_index], nums[right] = nums[right], nums[pivot_index]
stored_index = left
for i in range(left, right):
if nums[i] < pivot:
nums[i], nums[stored_index] = nums[stored_index], nums[i]
stored_index += 1
nums[right], nums[stored_index] = nums[stored_index], nums[right]
return stored_index```Code language: HTML, XML (xml)```
Scroll to Top