Kth Largest element in an array

This article will teach us to find the kth largest element in an unsorted array. There are different ways to find the solution to the given problem. The best possible practices are discussed below:

Problem - Consider an unsorted array with N number of elements. A number k less than the size of the array is given; we have to find the kth largest element in the best possible ways.

For example:

K = 3
Input: A[] = {14, 5, 6, 12, 14, 8, 10, 6, 25}
Output: Kth largest element = 12

K = 5
Input: A[] = {18, 15, 3, 1, 2, 6, 2, 18, 16}
Output: Kth largest element = 3

Approach 1: The most straightforward method that comes to mind is sorting the given array and returning the required value. We can find the solution in O(N Log N) time using either the Heap Sort or Merge Sort.

Assuming the array has no identical elements:

In C++

// Program to find the kth largest element using the sorting method in C++
#include <iostream>
#include <bits/stdc++.h>
using namespace std;

// Function that returns the Kth largest element
int kth_largest_element(int arr[], int k, int n){
    // Sorts the array
    sort(arr, arr + n);

    // Reverses the array
    reverse(arr, arr+n);

    // Returns the required element
    return arr[k-1];
}

int main(){
    // Given array
    int arr[] = {12, 15, 7, 3, 8, 16, 25};

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

    int k = 3;
    cout << "The "<< k << "th largest element = " << kth_largest_element(arr, k, n) << endl;
    return 0;
}

Sample Output:

The 3th largest element = 15

In C

// Program to find the kth largest element using sorting method in C
#include <stdio.h>
#include <stdlib.h>

// Compare function for the qsort
int cmp_func (const void * a, const void * b) {
   return ( *(int*)a - *(int*)b );
}

// Function that reverses the array
void reverse (int arr[], int n){
    for(int i = 0; i < n/2; i++){
        int temp = arr[i];
        arr[i] = arr[n-i-1];
        arr[n-i-1] = temp;
    }
}

// Function that returns the Kth largest element
int kth_largest_element(int arr[], int k, int n){
    // Sorts the array
    qsort(arr, n, sizeof(int), cmp_func);

    // Reverses the array
    reverse(arr, n);

    // Returns the required element
    return arr[k-1];
}

int main(){
    // Given array
    int arr[] = {12, 15, 7, 3, 8, 16, 25};
    
    // n represents the size of the array
    int n = sizeof(arr) / sizeof(arr[0]);

    int k = 4;
    printf("The %dth largest element = %d", k, kth_largest_element(arr, k, n));
    return 0;
}

Sample Output:

The 4th largest element = 12

In Python

# Python program to find the Kth largest element
# Treating the given array as a python list
arr = [12, 15, 7, 3, 8, 16, 25]

# Function that returns the Kth largest value
def kth_largest_element(k):
    global arr

    # Sorts the function in reverse order
    arr.sort(reverse = True)

    # Returns the correct value
    return arr[k-1]

k = 5
print(f"The {k}th largest element = {kth_largest_element(k)}")

Sample Output:

The 5th largest element = 8

C++ code

#include <bits/stdc++.h>
using namespace std;

// Given array
int arr[] = {10, 12, 2, 54, 5, 18, 36, 22, 12, 4, 10};
// n = number of elements in the array 
int n = sizeof(arr) / sizeof(arr[0]);
// We have to find the kth largest value                
int k = 3;                                             

// Our set
set<int> mySet(arr, arr + n);
// Itr -> iterator for the set
set<int>::iterator itr;

// Function to calculate the length of the set
int len(int x)
{
    // The for loop starts from the starting of the set and ends at the end of the set
    for (itr = mySet.begin(); itr != mySet.end(); itr++)
    {
        x++;
    }
    return x; // returns the length of the set to the main function
}

// Function to find the kth largest value
int find_kth(int k, int set_len)
{
    // The for loop starts from the starting of the set and ends at the end of the set
    for (itr = mySet.begin(); itr != mySet.end(); itr++)
    {
        // When the set length becomes equal to the k means itr is pointing to the kth largest value
        if (set_len == k)
        {
            return *itr; // Returning the value to the main function
        }
        set_len--;
    }
}

// Funtion to display the set
void display_set()
{
    cout << "My set = {";
    for (itr = mySet.begin(); itr != mySet.end(); itr++)
    {
        cout << *itr << ", ";
    }
    cout << "}" << endl;
}

int main()
{
    int set_len = 0;
    // Calling the set length to calculate the length of the set
    set_len = len(set_len);

    // Printing all the elements of the set
    display_set();

    // Calling the find_kth function to find the desired value
    int kth_largest_element = find_kth(k, set_len);

    // Printing the result in output
    cout << "The " << k << "th largest element = " << kth_largest_element << endl;

    return 0;
}

Sample Output:

My set = {2, 4, 5, 10, 12, 18, 22, 36, 54}
The 3th largest element = 22

Python code:

# Funtion to calculate the length of the set
def set_len():
    x = 0
    for item in myset:
        x += 1
    return x

# Funtion to find the kth largest value
def find_kth():
    global len_set
    global k
    for item in myset:
        if(len_set == k):
            print(f"The {k}th largest element = {item}")
        len_set -= 1

# Treating the given array as a python list
arr = [15, 17, 28, 26, 27, 12, 10, 8, 10, 12, 9, 22, 29]

# Typecasting the list into a set
myset = set(arr)
k = 5

# Calculating the length of the set using the set_len function
len_set = set_len()

# Printing the set
print(f"My set = {myset}")

# Finding the kth largest value by calling the find_kth
find_kth()

Output:

My set = {8, 9, 10, 12, 15, 17, 22, 26, 27, 28, 29}
The 5th largest element = 22

Approach 3 - Using Max-Heap

The kth largest element can be found with the help of the heap. Here, we have used max heap; we first convert the given array into a max-heap first, then replace the root with the last element, decrease the heap size by one and then convert it into a max-heap again. We follow the same steps k-1 times. After that, the kth element is found at the root index = 0.

C++ Code

C++ program to find the kth largest element in an array with the distinct element using heaps
#include <iostream>
using namespace std;

void max_heapify(int arr[], int n, int i)
{
    int largest = i;             // Initializing the parent index as the largest
    int left_child = 2 * i + 1;  // Formula to find the left child of i
    int right_child = 2 * i + 2; // Formula to find the right child of i

    // If the left child is present in the heap and greater than the largest
    if (left_child < n && arr[left_child] > arr[largest])
        largest = left_child; // If condition passes, then left child becomes the largest

    // If the right child is in the heap and greater than the largest
    if (right_child < n && arr[right_child] > arr[largest])
        largest = right_child; // If condition passes, then right child becomes the largest

    // If the largest is not the parent
    if (largest != i)
    {
        swap(arr[i], arr[largest]);
        max_heapify(arr, n, largest);
    }
}

// Function that converts the given array into a max heap
void build_max_heap(int arr[], int n)
{
    int start = (n / 2) - 1;

    for (int i = start; i >= 0; i--)
    {
        max_heapify(arr, n, i);
    }
}

// Function that returns the kth largest element
int find_kth(int arr[], int n, int k)
{
    // Converting the given array into a max - heap first
    build_max_heap(arr, n);
        // The below for loops selects the max and replaces the root element with the last element k-1 times
        for (int i = 0; i != k - 1; i++)
        {
            swap(arr[0], arr[n - i - 1]);
            n = n - 1;
            max_heapify(arr, n, 0);
        } // At the end of the loop, the kth element can be found at the root, i.e., at index = 0
    return arr[0];
}

// Main function
int main()
{
    int arr[] = {25, 16, 12, 5, 9, 3, 4, 7}; // Initializing the array
    int n = sizeof(arr) / sizeof(arr[0]);    // N -> number of element in arr
    int k = 2;                               // Initializing the value of k

    int kth_largest_element;
    kth_largest_element = find_kth(arr, n, k);

    cout << "The " << k << "th largest element = " << kth_largest_element << endl;

    return 0;
}

Output:

The 2th largest element = 16

C Code

// C++ program to find the kth largest element in an array with distinct element using heaps
#include <stdio.h>

void swap(int *p, int *q){
    int temp = *p;
    *p = *q;
    *q = temp;
}

void max_heapify(int arr[], int n, int i)
{
    int largest = i;             // Initializing the parent index as the largest
    int left_child = 2 * i + 1;  // Formula to find the left child of i
    int right_child = 2 * i + 2; // Formula to find the right child of i

    // If the left child is present in the heap and greater than the largest
    if (left_child < n && arr[left_child] > arr[largest])
        largest = left_child; // If condition passes, then left child becomes the largest

    // If the right child is in the heap and greater than the largest
    if (right_child < n && arr[right_child] > arr[largest])
        largest = right_child; // If condition passes, then right child becomes the largest

    // If the largest is not the parent
    if (largest != i)
    {
        swap(&arr[i], &arr[largest]);
        max_heapify(arr, n, largest);
    }
}

// Function that converts the given array into a max heap
void build_max_heap(int arr[], int n)
{
    int start = (n / 2) - 1;

    for (int i = start; i >= 0; i--)
    {
        max_heapify(arr, n, i);
    }
}

// Function that returns the kth largest element
int find_kth(int arr[], int n, int k)
{
    // Converting the given array into a max - heap first
    build_max_heap(arr, n);
        // The below for loops selects the max and replaces the root element with the last element k-1 times
        for (int i = 0; i != k - 1; i++)
        {
            swap(&arr[0], &arr[n - i - 1]);
            n = n - 1;
            max_heapify(arr, n, 0);
        } // At the end of the loop, the kth element can be found at the root, i.e., at index = 0
    return arr[0];
}

// Main function
int main()
{
    int arr[] = {25, 16, 12, 5, 9, 3, 4, 7}; // Initializing the array
    int n = sizeof(arr) / sizeof(arr[0]);    // n -> number of element in arr
    int k = 4;                               // Initializing the value of k

    int kth_largest_element;
    kth_largest_element = find_kth(arr, n, k);

    printf("The %dth largest element = %d", k, kth_largest_element);

    return 0;
}

Output:

The 3th largest element = 12

Approach 4 - Using Min Heap

In this method, we create a min heap with k number of elements and the minimum of that (root element) would be the kth largest value. If there would be more than k elements in the array, then we check each element whether it is greater than the root element of the heap or not, we will follow the below steps for all the remaining elements:

If the element would be smaller than the root means the kth largest value is still the root element and we check the condition for the next element.
If the element would be greater than the root means the root element is not the kth largest value and we replace the root with the element and call min-heapify at the root index.
At the end of the execution, we will return the root element, which would be the kth largest value.

The time complexity of this approach is T(n) = klogk + (n-k)logk

And the space complexity = O(k)

C++ code

// C++ program to find the kth largest value using a min-heap
#include <iostream>
using namespace std;

// Function to find the parent index of the child k
int parent(int k)
{
    return (k - 1) / 2;
}

// Function to find the left child index of parent k
int left_child(int k)
{
    return 2 * k + 1;
}

// Function to find the right child index of parent k
int right_child(int k)
{
    return 2 * k + 2;
}

// Function to convert the given array into a min heap
void min_heapify(int auxiliary_array[], int parent_index, int heap_size)
{
    // Finding the index value of left and right children
    int left_child_index = left_child(parent_index);
    int right_child_index = right_child(parent_index);

    // Assuming the parent is the smallest
    int smallest_index = parent_index;

    // If the left child is smaller than the parent
    if (left_child_index < heap_size && auxiliary_array[left_child_index] < auxiliary_array[smallest_index])
    {
        smallest_index = left_child_index;
    }

    // If the right child is smaller than the parent
    if (right_child_index < heap_size && auxiliary_array[right_child_index] < auxiliary_array[smallest_index])
    {
        smallest_index = right_child_index;
    }

    // If the smallest is not the parent
    if (smallest_index != parent_index)
    {
        // Swapping parent with the smallest child
        swap(auxiliary_array[smallest_index], auxiliary_array[parent_index]);
        // Calling min heapify for further improvement at the index of the smallest child
        min_heapify(auxiliary_array, smallest_index, heap_size);
    }
}

// Min - heap function
int min_heap(int arr[], int n, int k)
{
    // Creating an auxiliary array of size k
    int auxiliary_array[k];

    // Intializing the values of the main array into the auxiliary array
    for (int i = 0; i < k; i++)
    {
        auxiliary_array[i] = arr[i];
    }

    // Converting the auxiliary array into a min heap
    for (int i = (k - 1) / 2; i < 0; i--)
    {
        min_heapify(auxiliary_array, i, k);
    }

    // When there are more than k elements in the given array
    if (k < n)
    {
        // For loop runs for the heap size - k elements
        for (int i = k; i < n; i++)
        {
            // If the element is greater than the root elements of the auxiliary array
            if (arr[i] > auxiliary_array[0])
            {
                // Updating the root value
                auxiliary_array[0] = arr[i];

                // Converting the auillary array into a min heap again
                min_heapify(auxiliary_array, 0, k);
            }
        }
    }

    // Returning the root element of the auxiliary array
    return auxiliary_array[0];
}

// Main function
int main()
{
    // Initializing the array
    int arr[] = {12, 15, 17, 23, 9, 16, 7, 45, 6, 42, 33};

    // n -> number of elements in main array
    int n = sizeof(arr) / sizeof(arr[0]);

    // K -> would be the size of the min heap
    int k = 5;

    // Storing the kth largest value in a variable
    int kth_largest_value = min_heap(arr, n, k);

    // Printing the array
    cout << "My array = {";
    for (int i = 0; i < n; i++)
    {
        cout << arr[i] << ", ";
    }
    cout << "}" << endl;

    // Printing the kth largest value
    cout << "The " << k << "th largest value = " << kth_largest_value << endl;
    return 0;
}

Output:

My array = {12, 15, 17, 23, 9, 16, 7, 45, 6, 42, 33}
The 5th largest value = 17

C code

// C program to find the kth largest value using a min heap
#include <stdio.h>

// Function to find the parent index of the child k
int parent(int k)
{
    return (k - 1) / 2;
}

// Function to find the left child index of parent k
int left_child(int k)
{
    return 2 * k + 1;
}

// Function to find the right child index of parent k
int right_child(int k)
{
    return 2 * k + 2;
}

void swap(int *p, int *q)
{
    int temp = *p;
    *p = *q;
    *q = temp;
}

// Function to convert the given array into a min heap
void min_heapify(int auxiliary_array[], int parent_index, int heap_size)
{
    // Finding the index value of left and right children
    int left_child_index = left_child(parent_index);
    int right_child_index = right_child(parent_index);

    // Assuming the parent is the smallest
    int smallest_index = parent_index;

    // If the left child is smaller than the parent
    if (left_child_index < heap_size && auxiliary_array[left_child_index] < auxiliary_array[smallest_index])
    {
        smallest_index = left_child_index;
    }

    // If the right child is smaller than the parent
    if (right_child_index < heap_size && auxiliary_array[right_child_index] < auxiliary_array[smallest_index])
    {
        smallest_index = right_child_index;
    }

    // If the smallest is not the parent
    if (smallest_index != parent_index)
    {
        // Swapping parent with the smallest child
        swap(&auxiliary_array[smallest_index], &auxiliary_array[parent_index]);
        // Calling min heapify for further improvement at the index of the smallest child
        min_heapify(auxiliary_array, smallest_index, heap_size);
    }
}

// Min - heap function
int min_heap(int arr[], int n, int k)
{
    // Creating an auxiliary array of size k
    int auxiliary_array[k];

    // Initializing the values of the main array into the auxiliary array
    for (int i = 0; i < k; i++)
    {
        auxiliary_array[i] = arr[i];
    }

    // Converting the auxiliary array into a min heap
    for (int i = (k - 1) / 2; i < 0; i--)
    {
        min_heapify(auxiliary_array, i, k);
    }

    // When there are more than k elements in the given array
    if (k < n)
    {
        // For loop runs for the heap size - k elements
        for (int i = k; i < n; i++)
        {
            // If the element is greater than the root elements of the auxiliary array
            if (arr[i] > auxiliary_array[0])
            {
                // Updating the root value
                auxiliary_array[0] = arr[i];

                // Converting the auillary array into a min heap again
                min_heapify(auxiliary_array, 0, k);
            }
        }
    }

    // Returning the root element of the auxiliary array
    return auxiliary_array[0];
}

// Main function
int main()
{
    // Intializing the array
    int arr[] = {12, 15, 17, 23, 9, 16, 7, 45, 6, 42, 33};

    // n -> number of elements in main array
    int n = sizeof(arr) / sizeof(arr[0]);

    // K -> would be the size of the min heap
    int k = 4;

    // Storing the kth largest value in a variable
    int kth_largest_value = min_heap(arr, n, k);

    // Printing the array
    printf("My array = {");
    for (int i = 0; i < n; i++)
    {
        printf("%d, ", arr[i]);
    }
    printf("}\n");

    // Printing the kth largest value
    printf("The %dth largest value = %d", k, kth_largest_value);
    return 0;
}

Output:

My array = {12, 15, 17, 23, 9, 16, 7, 45, 6, 42, 33, }
The 4th largest value = 23

Approach 5 - Partial Quick Sort

In this approach, we use the idea of the quick sort to find the kth largest element in the array. As we know, the quick sort selects a pivot element, places it at its right index, and recursively repeats the same process until the array gets sorted. Similarly, we perform the same steps but not the complete execution of the quick sort. When the pivot is itself the kth largest value, we will stop the execution and print the required value. The worst time complexity of this approach is O(n^2) and the average time complexity is O(N logN). We achieve our desired out in less time than the average case complexity.

C++ Code:

// C++ program to find the kth largest value using partial quick sort
// The below code is the modified quick sort in reverse order
#include <iostream>
using namespace std;

// Function to swap two values using pointers
void swap(int *p, int *j)
{
    int temp = *p;
    *p = *j;
    *j = temp;
}

// Partition function
int partition(int arr[], int first, int last)
{
    // Selects the last element as the pivot
    int pivot_element = arr[last];

    int i = first - 1;

    for (int j = first; j < last; j++)
    {
        // If the pivot is smaller than the pivot. It increases the value of i and swaps the elements at indices i and j
        if (arr[j] > pivot_element)
        {
            i++;
            swap(&arr[i], &arr[j]);
        }
    }

    // Places the pivot element at its correct position
    swap(&arr[i + 1], &arr[last]);

    // Returns the index of the pivot element
    return i + 1;
}

// Quick sort function
int quicksort(int arr[], int first, int last, int k)
{
    // If the array has at least two elements in it
    if (first < last)
    {
        // Pi -> stores the index of the pivot
        int pi = partition(arr, first, last);

        // When pi points to the kth largest value
        if (pi == k - 1)
        {
            return arr[k - 1];
        }

        // If the kth largest value is smaller than the pivot
        else if (pi < k)
        {
            quicksort(arr, pi + 1, last, k);
        }

        // If the kth largest value is greater than the pivot
        else
        {
            quicksort(arr, first, pi - 1, k);
        }
    }
    // Returns the kth largest value
    return arr[k - 1];
}

// Main function
int main()
{
    int arr[] = {12, 45, 66, 13, 85, 14, 69, 25, 33, 18};
    int n = sizeof(arr) / sizeof(arr[0]);
    int k = 5;

    // Variable to store the kth largest value
    int kth_largest_element;
    kth_largest_element = quicksort(arr, 0, n - 1, k);

    // Printing the array
    cout << "The array = [";
    for (int i = 0; i < n; i++)
    {
        cout << arr[i] << ", ";
    }
    cout << "]" << endl;

    // Printing the desired output
    cout << "The " << k << "th largest element = " << kth_largest_element << endl;

    return 0;
}

Output:

The array = [45, 66, 85, 69, 33, 25, 18, 12, 14, 13]
The 5th largest element = 33

C Code

// C program to find the kth largest value using partial quick sort
// The below code is the modified quick sort in reverse order
#include <stdio.h>

// Function to swap two values using pointers
void swap(int *p, int *j)
{
    int temp = *p;
    *p = *j;
    *j = temp;
}

// Partition function
int partition(int arr[], int first, int last)
{
    // Selects the last element as the pivot
    int pivot_element = arr[last];

    int i = first - 1;

    for (int j = first; j < last; j++)
    {
        // If the pivot is smaller than the pivot. It increases the value of i and swaps the elements at indices i and j
        if (arr[j] > pivot_element)
        {
            i++;
            swap(&arr[i], &arr[j]);
        }
    }

    // Places the pivot element at its correct position
    swap(&arr[i + 1], &arr[last]);

    // Returns the index of the pivot element
    return i + 1;
}

// Quick sort function
int quicksort(int arr[], int first, int last, int k)
{
    // If the array has at least two elements in it
    if (first < last)
    {
        // Pi -> stores the index of the pivot
        int pi = partition(arr, first, last);

        // When pi points to the kth largest value
        if (pi == k - 1)
        {
            return arr[k - 1];
        }

        // If the kth largest value is smaller than the pivot
        else if (pi < k)
        {
            quicksort(arr, pi + 1, last, k);
        }

        // If the kth largest value is greater than the pivot
        else
        {
            quicksort(arr, first, pi - 1, k);
        }
    }
    // Returns the kth largest value
    return arr[k - 1];
}

// Main function
int main()
{
    int arr[] = {11, 35, 60, 18, 75, 85, 69, 28, 37, 26};
    int n = sizeof(arr) / sizeof(arr[0]);
    int k = 4;

    // Variable to store the kth largest value
    int kth_largest_element;
    kth_largest_element = quicksort(arr, 0, n - 1, k);

    // Printing the array
    printf("The array = [");
    for (int i = 0; i < n; i++)
    {
        printf("%d, ", arr[i]);
    }
    printf("]\n");

    // Printing the desired output
    printf("The %dth largest element = %d\n", k, kth_largest_element);

    return 0;
}

Output:

The array = [75, 85, 69, 60, 37, 28, 35, 26, 11, 18]
The 4th largest element = 60

# Python program to find the kth largest value in the array using the quick sort partially.
# In this program, we have used the quick sort algorithm to sort the array in reverse order.
# At any stage, when the pivot element itself becomes the kth largest value, we stop the execution
# of the program and return the value.

# Partition function of the quick sort
def partition(array, first, last):
    # Last element as the pivot
    pivot = array[last]
    i = first - 1
    
    # For loop runs from first to last - 1
    for j in range(first, last):
        # If the element is greater than the pivot
        if array[j] > pivot:
            i += 1
            # Swapping method in python
            array[j], array[i] = array[i], array[j]

    # Swapping the pivot element with the element at index = i+1
    array[i+1], array[last] = array[last], array[i+1]

    # Returning the index of the pivot
    return i + 1

def quicksort(array, first, last, k):
    # If the array has at least two elements
    if first < last:
        # Calling the partition function with the 0 and 9 index values
        # and storing the index of the pivot in pi
        pi = partition(array, first, last)

        # when pi is equal to the k-1 means the pivot is itself the kth largest value
        if pi == k-1:
            return array[k-1]

        # When the kth largest value is at the right side of the pivot
        elif pi < k:
            quicksort(array, pi+1, last, k)

        #When the kth largest value is at the left side of the pivot
        else:
            quicksort(array, first, pi-1, k)

    # Returning the kth largest value   
    return array[k-1]

# Treating the given array as the python list
My_array = [41, 15, 11, 32, 14, 12, 20, 25, 33, 78]
k = 6

# Storing the kth largest element in the below variable
kth_largest_element = quicksort(My_array, 0, len(My_array)-1, k)

# Printing the result
print(f"My array = {My_array}")
print(f"The {k}th largest element = {kth_largest_element}")

Output:

My array = [78, 41, 33, 32, 25, 20, 15, 14, 12, 11]
The 6th largest element = 20

Next TopicSort an almost-sorted, k-sorted or nearly-sorted array

← prev next →

For Videos Join Our Youtube Channel: Join Now

Feedback

Send your Feedback to [email protected]

Help Others, Please Share

Learn Latest Tutorials

Splunk

SPSS

Swagger

Transact-SQL

Tumblr

ReactJS

Regex

Reinforcement Learning

R Programming

RxJS

React Native

Python Design Patterns

Python Pillow

Python Turtle

Keras

Preparation

Aptitude

Reasoning

Verbal Ability

Interview Questions

Company Questions

Trending Technologies

Artificial Intelligence

AWS

Selenium

Cloud Computing

Hadoop

ReactJS

Data Science

Angular 7

Blockchain

Git

Machine Learning

DevOps

B.Tech / MCA

DBMS

Data Structures

DAA

Operating System

Computer Network

Compiler Design

Computer Organization

Discrete Mathematics

Ethical Hacking

Computer Graphics

Software Engineering

Web Technology

Cyber Security

Automata

C Programming

C++

Java

.Net

Python

Programs

Control System

Data Mining

Data Warehouse

^{Like/Subscribe us for latest updates or newsletter}

DS Tutorial

DS Array

DS Linked List

DS Stack

DS Queue

DS Tree

DS Graph

DS Searching

DS Sorting

Differences

Misc

DS MCQ

Kth Largest element in an array

In C++

In C

In Python

C++ code

Python code:

Approach 3 - Using Max-Heap

C++ Code

C Code

Approach 4 - Using Min Heap

C++ code

C code

Approach 5 - Partial Quick Sort

C++ Code:

C Code

Feedback

Help Others, Please Share

Learn Latest Tutorials

Preparation

Trending Technologies

B.Tech / MCA