# Find kth largest element in array

Here given code implementation process.

``````//C Program
//Find kth largest elements in array
#include <stdio.h>

//Swap two element in array
void swap(int arr[],int first,int second)
{
int temp=arr[first];
arr[first]=arr[second];
arr[second]=temp;
}
//Check the properties of max heap
int compare(int arr[],int left,int right,int root,int size)
{
int location = -1;

if(left < size &&  arr[left] > arr[root] )
{

if(right < size && arr[right] > arr[left])
{

swap(arr,right,root);
location = right;
}
else
{
swap(arr,left,root);
location = left;
}
}
else if(right < size && arr[right] > arr[root])
{
swap(arr,right,root);
location = right;
}
return location;
}
//Perform max heap sort
void heap(int arr[],int size,int root)
{
//Get location of left and right child
int left  = 2*root+1;
int right = 2*root+2;

int next_in = compare(arr, left, right, root, size);

if(next_in != -1)
{
//When array is modified then check other array elements
heap(arr,size,next_in);
}
}
//Display array elements
void print_data(int arr[],int size)
{
printf("\n");
for(int i = 0; i < size; i++)
{
printf("%3d",arr[i] );
}
}

//Finding the kth largest element in array
void kth_largest(int arr[],int size,int k)
{

if(k>size || k <=0)
{
//invalid position
return;
}
//Auxiliary memory that will be used to store array elements
int auxiliary[size];

//Set initial values into the auxiliary array
for (int i = 0; i < size; ++i)
{
auxiliary[i] = arr[i];
}

for (int i = (size/2)-1; i >= 0; i--)
{
heap(auxiliary,size,i);
}

for (int i = size-1; i >= (size-1 -k); i--)
{
//Swap large element at the end
swap(auxiliary, 0, i);
heap(auxiliary, i, 0);
}

printf("\n  %d-th Largest Element is : ",k);

printf(" %d\n",auxiliary[size-k] );

}
int main()
{
//Define collection of array elements
int arr[] = {6, 8, 2, 7,14, 34, 1, 3, 9, 21, 11, 12 ,5};

//Get the size of array
int size = sizeof(arr)/sizeof(arr[0]);

//position of find largest element
int k = 5;

print_data(arr,size);

kth_largest(arr,size,k);

return 0;
}```
```

#### Output

``````  6  8  2  7 14 34  1  3  9 21 11 12  5
5-th Largest Element is :  11``````
``````/*
C++ Program
Find kth largest elements in array
*/
#include<iostream>

using namespace std;

class MyHeap {
public:

//Swap two element in array
void swap(int arr[], int first, int second) {
int temp = arr[first];
arr[first] = arr[second];
arr[second] = temp;
}
//Check the properties of max heap
int compare(int arr[], int left, int right, int root, int size) {
int location = -1;
if (left < size && arr[left] > arr[root]) {
if (right < size && arr[right] > arr[left]) {
this->swap(arr, right, root);
location = right;
} else {
this->swap(arr, left, root);
location = left;
}
} else
if (right < size && arr[right] > arr[root]) {
this->swap(arr, right, root);
location = right;
}
return location;
}
//Perform max heap sort
void heap(int arr[], int size, int root) {
//Get location of left and right child
int left = 2 *root + 1;
int right = 2 *root + 2;
int next_in = this->compare(arr, left, right, root, size);
if (next_in != -1) {
//When array is modified then check other array elements
this->heap(arr, size, next_in);
}
}
//Display array elements
void print_data(int arr[], int size) {
cout << "\n";
for (int i = 0; i < size; i++) {
cout << " " << arr[i];
}
}
//Finding the kth largest element in array
void kth_largest(int arr[], int size, int k) {
if (k > size || k <= 0) {
//invalid position

return;
}
int *auxiliary = new int[size];
//Set initial values into the auxiliary array

for (int i = 0; i < size; ++i) {
auxiliary[i] = arr[i];
}
for (int i = (size / 2) - 1; i >= 0; i--) {
this->heap(auxiliary, size, i);
}
for (int i = size - 1; i >= (size - 1 - k); i--) {
//Swap large element at the end
this->swap(auxiliary, 0, i);
this->heap(auxiliary, i, 0);
}
cout << "\n " << k << "-th Largest Element is : ";
cout << " " << auxiliary[size - k] << "\n";
}
};
int main() {
MyHeap obj = MyHeap();
int arr[] = {
6,
8,
2,
7,
14,
34,
1,
3,
8,
21,
11,
12,
5
};
//Get the size of array
int size = sizeof(arr) / sizeof(arr[0]);
//Number of largest element
int k = 5;
//Display array elements
obj.print_data(arr, size);
obj.kth_largest(arr, size, k);
return 0;
}```
```

#### Output

`````` 6 8 2 7 14 34 1 3 8 21 11 12 5
5-th Largest Element is :  11``````
``````/*
Java Program
Find kth largest elements in array
*/
public class MyHeap {

//Swap two element in array
public void swap(int []arr,int first,int second)
{
int temp=arr[first];
arr[first]=arr[second];
arr[second]=temp;
}
//Check the properties of max heap
public int compare(int []arr,int left,int right,int root,int size)
{
int location = -1;

if(left < size &&  arr[left] > arr[root] )
{

if(right < size && arr[right] > arr[left])
{

swap(arr,right,root);
location = right;
}
else
{
swap(arr,left,root);
location = left;
}
}
else if(right < size && arr[right] > arr[root])
{
swap(arr,right,root);
location = right;
}
return location;
}
//Perform max heap sort
public void heap(int []arr,int size,int root)
{
//Get location of left and right child
int left  = 2*root+1;
int right = 2*root+2;

int next_in = compare(arr, left, right, root, size);

if(next_in != -1)
{
//When array is modified then check other array elements
heap(arr,size,next_in);
}
}
//Display array elements
public void print_data(int []arr,int size)
{
System.out.print("\n");
for(int i = 0; i < size; i++)
{
System.out.print("  "+arr[i] );
}
}

//Finding the kth largest element in array
public void kth_largest(int []arr,int size,int k)
{

if(k>size || k <=0)
{
//invalid position
return;
}
//Auxiliary memory that will be used to store array elements
int []auxiliary= new int[size];

//Set initial values into the auxiliary array
for (int i = 0; i < size; ++i)
{
auxiliary[i] = arr[i];
}

for (int i = (size/2)-1; i >= 0; i--)
{
heap(auxiliary,size,i);
}

for (int i = size-1; i >= (size-1 -k); i--)
{
//Swap large element at the end
swap(auxiliary, 0, i);
heap(auxiliary, i, 0);
}

System.out.print("\n  "+k+"-th Largest Element is : ");

System.out.print(" "+auxiliary[size-k]+"\n" );

}
public static void main(String[] args) {

MyHeap obj = new MyHeap();

//Define Collection of array elements
int []arr =  {6, 8, 2, 7,14, 34, 1, 3, 8, 21, 11, 12 ,5};

//Get the size of array
int size = arr.length;

//Number of largest element
int k = 5;

//Display array elements
obj.print_data(arr,size);

obj.kth_largest(arr,size,k);
}
}```
```

#### Output

`````` 6 8 2 7 14 34 1 3 8 21 11 12 5
5-th Largest Element is :  11``````
``````/*
C# Program
Find kth largest elements in array
*/
using System;

public class MyHeap {
//Swap two element in array
public void swap(int[] arr, int first, int second) {
int temp = arr[first];
arr[first] = arr[second];
arr[second] = temp;
}
//Check the properties of max heap
public int compare(int[] arr, int left, int right, int root, int size) {
int location = -1;
if (left < size && arr[left] > arr[root]) {
if (right < size && arr[right] > arr[left]) {
swap(arr, right, root);
location = right;
} else {
swap(arr, left, root);
location = left;
}
} else
if (right < size && arr[right] > arr[root]) {
swap(arr, right, root);
location = right;
}
return location;
}
//Perform max heap sort
public void heap(int[] arr, int size, int root) {
//Get location of left and right child
int left = 2 * root + 1;
int right = 2 * root + 2;
int next_in = compare(arr, left, right, root, size);
if (next_in != -1) {
heap(arr, size, next_in);
}
}
//Display array elements
public void print_data(int[] arr, int size) {
Console.Write("\n");
for (int i = 0; i < size; i++) {
Console.Write(" " + arr[i]);
}
}
//Finding the kth largest element in array
public void kth_largest(int[] arr, int size, int k) {
if (k > size || k <= 0) {
return;
}
int[]
//Auxiliary memory that will be used to store array elements
auxiliary = new int[size];
//Set initial values into the auxiliary array

for (int i = 0; i < size; ++i) {
auxiliary[i] = arr[i];
}
for (int i = (size / 2) - 1; i >= 0; i--) {
heap(auxiliary, size, i);
}
for (int i = size - 1; i >= (size - 1 - k); i--) {
swap(auxiliary, 0, i);
heap(auxiliary, i, 0);
}
Console.Write("\n " + k + "-th Largest Element is : ");
Console.Write(" " + auxiliary[size - k] + "\n");
}
public static void Main(String[] args) {
MyHeap obj = new MyHeap();
int[]
//Define Collection of array elements
arr = {
6,
8,
2,
7,
14,
34,
1,
3,
8,
21,
11,
12,
5
};
//Get the size of array
int size = arr.Length;
//Number of largest element
int k = 5;
obj.print_data(arr, size);
obj.kth_largest(arr, size, k);
}
}```
```

#### Output

`````` 6 8 2 7 14 34 1 3 8 21 11 12 5
5-th Largest Element is :  11``````
``````<?php
/*
Php Program
Find kth largest elements in array
*/
class MyHeap {
//Swap two element in array
public 	function swap(&\$arr, \$first, \$second) {
\$temp = \$arr[\$first];
\$arr[\$first] = \$arr[\$second];
\$arr[\$second] = \$temp;
}
//Check the properties of max heap
public 	function compare(&\$arr, \$left, \$right, \$root, \$size) {
\$location = -1;
if (\$left < \$size && \$arr[\$left] > \$arr[\$root]) {
if (\$right < \$size && \$arr[\$right] > \$arr[\$left]) {
\$this->swap(\$arr, \$right, \$root);
\$location = \$right;
} else {
\$this->swap(\$arr, \$left, \$root);
\$location = \$left;
}
} else
if (\$right < \$size && \$arr[\$right] > \$arr[\$root]) {
\$this->swap(\$arr, \$right, \$root);
\$location = \$right;
}
return \$location;
}
//Perform max heap sort
public 	function heap(&\$arr, \$size, \$root) {
//Get location of left and right child
\$left = 2 *\$root + 1;
\$right = 2 *\$root + 2;
\$next_in = \$this->compare(\$arr, \$left, \$right, \$root, \$size);
if (\$next_in != -1) {
//When array is modified then check other array elements
\$this->heap(\$arr, \$size, \$next_in);
}
}
//Display array elements

public 	function print_data(\$arr, \$size) {
echo("\n");
for (\$i = 0; \$i < \$size; \$i++) {
echo(" ". \$arr[\$i]);
}
}
//Finding the kth largest element in array

public 	function kth_largest(\$arr, \$size, \$k) {
if (\$k > \$size || \$k <= 0) {
return;
}
//Auxiliary memory that will be used to store array elements
\$auxiliary = array_fill(0, \$size, 0);
//Set initial values into the auxiliary array

for (\$i = 0; \$i < \$size; ++\$i) {
\$auxiliary[\$i] = \$arr[\$i];
}
for (\$i = (intval(\$size / 2)) - 1; \$i >= 0; \$i--) {
\$this->heap(\$auxiliary, \$size, \$i);
}
for (\$i = \$size - 1; \$i >= (\$size - 1 - \$k); \$i--) {
//Swap large element at the end
\$this->swap(\$auxiliary, 0, \$i);
\$this->heap(\$auxiliary, \$i, 0);
}
echo("\n ". \$k ."-th Largest Element is : ");
echo(" ". \$auxiliary[\$size - \$k] ."\n");
}
}

function main() {
\$obj = new MyHeap();
//Define Collection of array elements
\$arr = array(6, 8, 2, 7, 14, 34, 1, 3, 8, 21, 11, 12, 5);
//Get the size of array
\$size = count(\$arr);
//Number of largest element
\$k = 5;
//Display array elements

\$obj->print_data(\$arr, \$size);
\$obj->kth_largest(\$arr, \$size, \$k);

}
main();```
```

#### Output

`````` 6 8 2 7 14 34 1 3 8 21 11 12 5
5-th Largest Element is :  11``````
``````/*
Node Js Program
Find kth largest elements in array
*/
class MyHeap {
//Swap two element in array
swap(arr, first, second) {
var temp = arr[first];
arr[first] = arr[second];
arr[second] = temp;
}

//Check the properties of max heap
compare(arr, left, right, root, size) {
var location = -1;
if (left < size && arr[left] > arr[root]) {
if (right < size && arr[right] > arr[left]) {
this.swap(arr, right, root);
location = right;
} else {
this.swap(arr, left, root);
location = left;
}
}
else if (right < size && arr[right] > arr[root]) {
this.swap(arr, right, root);
location = right;
}

return location;
}

//Perform max heap sort
heap(arr, size, root) {
//Get location of left and right child
var left = 2 *root + 1;
var right = 2 *root + 2;
var next_in = this.compare(arr, left, right, root, size);
if (next_in != -1) {
//When array is modified then check other array elements
this.heap(arr, size, next_in);
}
}

//Display array elements
print_data(arr, size) {
process.stdout.write("\n");
for (var i = 0; i < size; i++) {
process.stdout.write(" " + arr[i]);
}
}

//Finding the kth largest element in array
kth_largest(arr, size, k) {
if (k > size || k <= 0) {
return;
}

//Auxiliary memory that will be used to store array elements
var auxiliary = Array(size).fill(0);
//Set initial values into the auxiliary array

for (var i = 0; i < size; ++i) {
auxiliary[i] = arr[i];
}

for (var i = (parseInt(size / 2)) - 1; i >= 0; i--) {
this.heap(auxiliary, size, i);
}

for (var i = size - 1; i >= (size - 1 - k); i--) {
//Swap large element at the end
this.swap(auxiliary, 0, i);
this.heap(auxiliary, i, 0);
}

process.stdout.write("\n " + k + "-th Largest Element is : ");
process.stdout.write(" " + auxiliary[size - k] + "\n");
}
}

function main(args) {
var obj = new MyHeap();
//Define Collection of array elements
var arr = [6, 8, 2, 7, 14, 34, 1, 3, 8, 21, 11, 12, 5];
//Get the size of array
var size = arr.length;
//Number of largest element
var k = 5;
//Display array elements
obj.print_data(arr, size);
obj.kth_largest(arr, size, k);
}

main();```
```

#### Output

`````` 6 8 2 7 14 34 1 3 8 21 11 12 5
5-th Largest Element is :  11``````
``````# Python 3 Program
# Find kth largest elements in array
class MyHeap :
# Swap two element in array
def swap(self, arr, first, second) :
temp = arr[first]
arr[first] = arr[second]
arr[second] = temp

# Check the properties of max heap
def compare(self, arr, left, right, root, size) :
location = -1
if (left < size and arr[left] > arr[root]) :
if (right < size and arr[right] > arr[left]) :
self.swap(arr, right, root)
location = right
else :
self.swap(arr, left, root)
location = left

elif (right < size and arr[right] > arr[root]) :
self.swap(arr, right, root)
location = right

return location

# Perform max heap sort
def heap(self, arr, size, root) :
left = 2 * root + 1
right = 2 * root + 2
next_in = self.compare(arr, left, right, root, size)
if (next_in != -1) :
self.heap(arr, size, next_in)

# Display array elements
def print_data(self, arr, size) :
print("\n", end = "")
i = 0
while (i < size) :
print(" ", arr[i], end = "")
i += 1

# Finding the kth largest element in array
def kth_largest(self, arr, size, k) :
if (k > size or k <= 0) :
return

auxiliary = [0] * size
# Set initial values into the auxiliary array
i = 0
while (i < size) :
auxiliary[i] = arr[i]
i += 1

i = (int(size / 2)) - 1
while (i >= 0) :
self.heap(auxiliary, size, i)
i -= 1

i = size - 1
while (i >= (size - 1 - k)) :
self.swap(auxiliary, 0, i)
self.heap(auxiliary, i, 0)
i -= 1

print("\n ", k ,"-th Largest Element is : ", end = "")
print(" ", auxiliary[size - k] ,"\n", end = "")

def main() :
obj = MyHeap()
arr = [6, 8, 2, 7, 14, 34, 1, 3, 8, 21, 11, 12, 5]
size = len(arr)
k = 5
obj.print_data(arr, size)
obj.kth_largest(arr, size, k)

if __name__ == "__main__":
main()```
```

#### Output

``````  6  8  2  7  14  34  1  3  8  21  11  12  5
5 -th Largest Element is :   11``````
``````# Ruby Program
# Find kth largest elements in array
class MyHeap
# Swap two element in array
def swap(arr, first, second)
temp = arr[first]
arr[first] = arr[second]
arr[second] = temp
end
# Check the properties of max heap
def compare(arr, left, right, root, size)
location = -1
if (left < size && arr[left] > arr[root])
if (right < size && arr[right] > arr[left])
self.swap(arr, right, root)
location = right
else
self.swap(arr, left, root)
location = left
end
elsif (right < size && arr[right] > arr[root])
self.swap(arr, right, root)
location = right
end
return location
end
# Perform max heap sort
def heap(arr, size, root)
left = 2 * root + 1
right = 2 * root + 2
next_in = self.compare(arr, left, right, root, size)
if (next_in != -1)
self.heap(arr, size, next_in)
end
end
# Display array elements
def print_data(arr, size)
print("\n")
i = 0
while (i < size)
print(" ", arr[i])
i += 1
end
end
# Finding the kth largest element in array
def kth_largest(arr, size, k)
if (k > size || k <= 0)
return
end
auxiliary = Array.new(size, 0)
# Set initial values into the auxiliary array
i = 0
while (i < size)
auxiliary[i] = arr[i]
i += 1
end
i = (size / 2) - 1
while (i >= 0)
self.heap(auxiliary, size, i)
i -= 1
end
i = size - 1
while (i >= (size - 1 - k))
self.swap(auxiliary, 0, i)
self.heap(auxiliary, i, 0)
i -= 1
end
print("\n ", k ,"-th Largest Element is  :")
print(" ", auxiliary[size - k] ,"\n")
end
end
def main()
obj = MyHeap.new()
arr = [6, 8, 2, 7, 14, 34, 1, 3, 8, 21, 11, 12, 5]
size = arr.length
k = 5
obj.print_data(arr, size)
obj.kth_largest(arr, size, k)
end
main()```
```

#### Output

`````` 6 8 2 7 14 34 1 3 8 21 11 12 5
5-th Largest Element is  : 11
``````
``````/*
Scala Program
Find kth largest elements in array
*/
class MyHeap {
//Swap two element in array
def swap(arr: Array[Int], first: Int, second: Int): Unit = {
val temp: Int = arr(first);
arr(first) = arr(second);
arr(second) = temp;
}
//Check the properties of max heap
def compare(arr: Array[Int], left: Int, right: Int, root: Int, size: Int): Int = {
var location: Int = -1;

if (left < size && arr(left) > arr(root)) {
if (right < size && arr(right) > arr(left)) {
this.swap(arr, right, root);
location = right;
} else {
this.swap(arr, left, root);
location = left;
}
} else
if (right < size && arr(right) > arr(root)) {
this.swap(arr, right, root);
location = right;
}
return location;
}
//Perform max heap sort
def heap(arr: Array[Int], size: Int, root: Int): Unit = {
val left: Int = 2 * root + 1;
val right: Int = 2 * root + 2;
val next_in: Int = this.compare(arr, left, right, root, size);

if (next_in != -1) {
this.heap(arr, size, next_in);
}
}
//Display array elements
def print_data(arr: Array[Int], size: Int): Unit = {
print("\n");
var i: Int = 0;
while (i < size) {
print(" " + arr(i));
i += 1;
}
}
//Finding the kth largest element in array
def kth_largest(arr: Array[Int], size: Int, k: Int): Unit = {
if (k > size || k <= 0) {
return;
}
var auxiliary: Array[Int] = Array.fill[Int](size)(0);

//Set initial values into the auxiliary array
var i: Int = 0;
while (i < size) {
auxiliary(i) = arr(i);
i += 1;
}
i = ((size / 2).toInt) - 1;
while (i >= 0) {
this.heap(auxiliary, size, i);
i -= 1;
}
i = size - 1;
while (i >= (size - 1 - k)) {
this.swap(auxiliary, 0, i);
this.heap(auxiliary, i, 0);
i -= 1;
}
print("\n " + k + "-th Largest Element is : ");
print(" " + auxiliary(size - k) + "\n");
}
}
object Main {
def main(args: Array[String]): Unit = {
val obj: MyHeap = new MyHeap();
val arr: Array[Int] = Array(6, 8, 2, 7, 14, 34, 1, 3, 8, 21, 11, 12, 5);
val size: Int = arr.length;
val k: Int = 5;
obj.print_data(arr, size);
obj.kth_largest(arr, size, k);
}
}```
```

#### Output

`````` 6 8 2 7 14 34 1 3 8 21 11 12 5
5-th Largest Element is :  11``````
``````/*
Swift Program
Find kth largest elements in array
*/
class MyHeap {
//Swap two element in array
func swap(_ arr: inout [Int], _ first: Int, _ second: Int) {
let temp: Int = arr[first];
arr[first] = arr[second];
arr[second] = temp;
}
//Check the properties of max heap
func compare(_ arr: inout [Int], _ left: Int, _ right: Int, _ root: Int, _ size: Int) -> Int {
var location: Int = -1;
if (left < size && arr[left] > arr[root]) {
if (right < size && arr[right] > arr[left]) {
self.swap(&arr, right, root);
location = right;
} else {
self.swap(&arr, left, root);
location = left;
}
} else
if (right < size && arr[right] > arr[root]) {
self.swap(&arr, right, root);
location = right;
}
return location;
}
//Perform max heap sort
func heap(_ arr: inout [Int], _ size: Int, _ root: Int) {
let left: Int = 2 * root + 1;
let right: Int = 2 * root + 2;
let next_in: Int = self.compare(&arr, left, right, root, size);
if (next_in != -1) {
self.heap(&arr, size, next_in);
}
}
//Display array elements
func print_data(_ arr: [Int], _ size: Int) {
print("\n", terminator: "");
var i: Int = 0;
while (i < size) {
print(" ", arr[i], terminator: "");
i += 1;
}
}
//Finding the kth largest element in array
func kth_largest(_ arr: [Int], _ size: Int, _ k: Int) {
if (k > size || k <= 0) {
return;
}
var auxiliary: [Int] = Array(repeating: 0, count: size);
//Set initial values into the auxiliary array
var i: Int = 0;
while (i < size) {
auxiliary[i] = arr[i];
i += 1;
}
i = (size / 2) - 1;
while (i >= 0) {
self.heap(&auxiliary, size, i);
i -= 1;
}
i = size - 1;
while (i >= (size - 1 - k)) {
self.swap(&auxiliary, 0, i);
self.heap(&auxiliary, i, 0);
i -= 1;
}
print("\n ", k ,"-th Largest Element is : ", terminator: "");
print(" ", auxiliary[size - k] );
}
}
func main() {
let obj: MyHeap = MyHeap();
let arr: [Int] = [6, 8, 2, 7, 14, 34, 1, 3, 8, 21, 11, 12, 5];
let size: Int = arr.count;
let k: Int = 5;
obj.print_data(arr, size);
obj.kth_largest(arr, size, k);
}
main();```
```

#### Output

``````  6  8  2  7  14  34  1  3  8  21  11  12  5
5 -th Largest Element is :   11``````

## Comment

Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.