Related Articles

# k largest(or smallest) elements in an array | added Min Heap method

• Difficulty Level : Medium
• Last Updated : 12 Aug, 2021

Question: Write an efficient program for printing k largest elements in an array. Elements in array can be in any order.
For example, if given array is [1, 23, 12, 9, 30, 2, 50] and you are asked for the largest 3 elements i.e., k = 3 then your program should print 50, 30, and 23.

Method 1 (Use Bubble k times)
Thanks to Shailendra for suggesting this approach.
1) Modify Bubble Sort to run the outer loop at most k times.
2) Print the last k elements of the array obtained in step 1.
Time Complexity: O(n*k)

Like Bubble sort, other sorting algorithms like Selection Sort can also be modified to get the k largest elements.

Method 2 (Use temporary array)
K largest elements from arr[0..n-1]

1) Store the first k elements in a temporary array temp[0..k-1].
2) Find the smallest element in temp[], let the smallest element be min
3-a) For each element x in arr[k] to arr[n-1]. O(n-k)
If x is greater than the min then remove min from temp[] and insert x
3-b)Then, determine the new min from temp[]. O(k)
4) Print final k elements of temp[]

Time Complexity: O((n-k)*k). If we want the output sorted then O((n-k)*k + k*log(k))
Thanks to nesamani1822 for suggesting this method.

Method 3(Use Sorting)
1) Sort the elements in descending order in O(n*log(n))
2) Print the first k numbers of the sorted array O(k).

Following is the implementation of the above.

## C++

 // C++ code for k largest elements in an array#include using namespace std; void kLargest(int arr[], int n, int k){    // Sort the given array arr in reverse    // order.    sort(arr, arr + n, greater());     // Print the first kth largest elements    for (int i = 0; i < k; i++)        cout << arr[i] << " ";} // driver programint main(){    int arr[] = { 1, 23, 12, 9, 30, 2, 50 };    int n = sizeof(arr) / sizeof(arr[0]);    int k = 3;    kLargest(arr, n, k);} // This article is contributed by Chhavi

## Java

 // Java code for k largest elements in an arrayimport java.util.Arrays;import java.util.Collections;import java.util.ArrayList; class GFG {    public static void kLargest(Integer[] arr, int k)    {        // Sort the given array arr in reverse order        // This method doesn't work with primitive data        // types. So, instead of int, Integer type        // array will be used        Arrays.sort(arr, Collections.reverseOrder());         // Print the first kth largest elements        for (int i = 0; i < k; i++)            System.out.print(arr[i] + " ");    }     //This code is contributed by Niraj Dubey  public static ArrayList kLargest(int[] arr, int k)    {        //Convert using stream        Integer[] obj_array = Arrays.stream( arr ).boxed().toArray( Integer[] :: new);        Arrays.sort(obj_array, Collections.reverseOrder());        ArrayList list = new ArrayList<>(k);         for (int i = 0; i < k; i++)            list.add(obj_array[i]);             return list;    }     public static void main(String[] args)    {        Integer arr[] = new Integer[] { 1, 23, 12, 9,                                        30, 2, 50 };        int k = 3;        kLargest(arr, k);               //This code is contributed by Niraj Dubey        //What if primitive datatype array is passed and wanted to return in ArrayList        int[] prim_array = { 1, 23, 12, 9, 30, 2, 50 };          System.out.print(kLargest(prim_array, k));    }}// This code is contributed by Kamal Rawal

## Python

 ''' Python3 code for k largest elements in an array''' def kLargest(arr, k):    # Sort the given array arr in reverse    # order.    arr.sort(reverse = True)    # Print the first kth largest elements    for i in range(k):        print (arr[i], end =" ") # Driver programarr = [1, 23, 12, 9, 30, 2, 50]# n = len(arr)k = 3kLargest(arr, k) # This code is contributed by shreyanshi_arun.

## C#

 // C# code for k largest elements in an arrayusing System; class GFG {    public static void kLargest(int[] arr, int k)    {        // Sort the given array arr in reverse order        // This method doesn't work with primitive data        // types. So, instead of int, Integer type        // array will be used        Array.Sort(arr);        Array.Reverse(arr);         // Print the first kth largest elements        for (int i = 0; i < k; i++)            Console.Write(arr[i] + " ");    }     // Driver code    public static void Main(String[] args)    {        int[] arr = new int[] { 1, 23, 12, 9,                                30, 2, 50 };        int k = 3;        kLargest(arr, k);    }} // This code contributed by Rajput-Ji



## Javascript


Output
50 30 23

Time complexity: O(n*log(n))

Method 4 (Use Max Heap)
1) Build a Max Heap tree in O(n)
2) Use Extract Max k times to get k maximum elements from the Max Heap O(k*log(n))

Time complexity: O(n + k*log(n))

Method 5(Use Order Statistics)
1) Use order statistic algorithm to find the kth largest element. Please see the topic selection in worst-case linear time O(n)
2) Use QuickSort Partition algorithm to partition around the kth largest number O(n).
3) Sort the k-1 elements (elements greater than the kth largest element) O(k*log(k)). This step is needed only if sorted output is required.

Time complexity: O(n) if we don’t need the sorted output, otherwise O(n+k*log(k))
Thanks to Shilpi for suggesting the first two approaches.

Method 6 (Use Min Heap)
This method is mainly an optimization of method 1. Instead of using temp[] array, use Min Heap.
1) Build a Min Heap MH of the first k elements (arr[0] to arr[k-1]) of the given array. O(k*log(k))
2) For each element, after the kth element (arr[k] to arr[n-1]), compare it with root of MH.
……a) If the element is greater than the root then make it root and call heapify for MH
……b) Else ignore it.
// The step 2 is O((n-k)*log(k))
3) Finally, MH has k largest elements and root of the MH is the kth largest element.
Time Complexity: O(k*log(k) + (n-k)*log(k)) without sorted output. If sorted output is needed then O(k*log(k) + (n-k)*log(k) + k*log(k)) so overall it is O(k*log(k) + (n-k)*log(k))

All of the above methods can also be used to find the kth largest (or smallest) element.

## C++

 #include using namespace std; // Swap function to interchange// the value of variables x and yint swap(int& x, int& y){    int temp = x;    x = y;    y = temp;} // Min Heap Class// arr holds reference to an integer// array size indicate the number of// elements in Min Heapclass MinHeap {     int size;    int* arr; public:    // Constructor to initialize the size and arr    MinHeap(int size, int input[]);     // Min Heapify function, that assumes that    // 2*i+1 and 2*i+2 are min heap and fix the    // heap property for i.    void heapify(int i);     // Build the min heap, by calling heapify    // for all non-leaf nodes.    void buildHeap();}; // Constructor to initialize data// members and creating mean heapMinHeap::MinHeap(int size, int input[]){    // Initializing arr and size     this->size = size;    this->arr = input;     // Building the Min Heap    buildHeap();} // Min Heapify function, that assumes// 2*i+1 and 2*i+2 are min heap and// fix min heap property for i void MinHeap::heapify(int i){    // If Leaf Node, Simply return    if (i >= size / 2)        return;     // variable to store the smallest element    // index out of i, 2*i+1 and 2*i+2    int smallest;     // Index of left node    int left = 2 * i + 1;     // Index of right node    int right = 2 * i + 2;     // Select minimum from left node and    // current node i, and store the minimum    // index in smallest variable    smallest = arr[left] < arr[i] ? left : i;     // If right child exist, compare and    // update the smallest variable    if (right < size)        smallest = arr[right] < arr[smallest]                             ? right : smallest;     // If Node i violates the min heap    // property, swap  current node i with    // smallest to fix the min-heap property    // and recursively call heapify for node smallest.    if (smallest != i) {        swap(arr[i], arr[smallest]);        heapify(smallest);    }} // Build Min Heapvoid MinHeap::buildHeap(){    // Calling Heapify for all non leaf nodes    for (int i = size / 2 - 1; i >= 0; i--) {        heapify(i);    }} void FirstKelements(int arr[],int size,int k){    // Creating Min Heap for given    // array with only k elements    MinHeap* m = new MinHeap(k, arr);     // Loop For each element in array    // after the kth element    for (int i = k; i < size; i++) {         // if current element is smaller        // than minimum element, do nothing        // and continue to next element        if (arr[0] > arr[i])            continue;         // Otherwise Change minimum element to        // current element, and call heapify to        // restore the heap property        else {            arr[0] = arr[i];            m->heapify(0);        }    }    // Now min heap contains k maximum    // elements, Iterate and print    for (int i = 0; i < k; i++) {        cout << arr[i] << " ";    }}// Driver Programint main(){     int arr[] = { 11, 3, 2, 1, 15, 5, 4,                           45, 88, 96, 50, 45 };     int size = sizeof(arr) / sizeof(arr[0]);     // Size of Min Heap    int k = 3;     FirstKelements(arr,size,k);     return 0;}// This code is contributed by Ankur Goel

## Java

 import java.io.*;import java.util.*; class GFG{   public static void FirstKelements(int arr[],                                  int size,                                  int k){         // Creating Min Heap for given    // array with only k elements    // Create min heap with priority queue    PriorityQueue minHeap = new PriorityQueue<>();    for(int i = 0; i < k; i++)    {        minHeap.add(arr[i]);    }         // Loop For each element in array    // after the kth element    for(int i = k; i < size; i++)    {                 // If current element is smaller        // than minimum ((top element of        // the minHeap) element, do nothing        // and continue to next element        if (minHeap.peek() > arr[i])            continue;                 // Otherwise Change minimum element        // (top element of the minHeap) to        // current element by polling out        // the top element of the minHeap        else        {            minHeap.poll();            minHeap.add(arr[i]);        }    }         // Now min heap contains k maximum    // elements, Iterate and print    Iterator iterator = minHeap.iterator();         while (iterator.hasNext())    {        System.out.print(iterator.next() + " ");    }} // Driver codepublic static void main (String[] args){    int arr[] = { 11, 3, 2, 1, 15, 5, 4,                  45, 88, 96, 50, 45 };         int size = arr.length;         // Size of Min Heap    int k = 3;         FirstKelements(arr, size, k);}} // This code is contributed by Vansh Sethi

## Python3

 def FirstKelements(arr,size,k):         # Creating Min Heap for given    # array with only k elements    # Create min heap with priority queue    minHeap = []    for i in range(k):        minHeap.append(arr[i])         # Loop For each element in array    # after the kth element    for i in range(k, size):        minHeap.sort()                 # If current element is smaller        # than minimum ((top element of        # the minHeap) element, do nothing        # and continue to next element        if (minHeap[0] > arr[i]):            continue                     # Otherwise Change minimum element        # (top element of the minHeap) to        # current element by polling out        # the top element of the minHeap        else:            minHeap.pop(0)            minHeap.append(arr[i])                 # Now min heap contains k maximum    # elements, Iterate and print      for i in minHeap:        print(i, end = " ") # Driver codearr=[11, 3, 2, 1, 15, 5, 4,45, 88, 96, 50, 45]size = len(arr) # Size of Min Heapk=3FirstKelements(arr, size, k) # This code is contributed by avanitrachhadiya2155

## C#

 using System;using System.Collections.Generic;public class GFG{   public static void FirstKelements(int []arr,                                  int size,                                  int k){         // Creating Min Heap for given    // array with only k elements    // Create min heap with priority queue    List minHeap = new List();    for(int i = 0; i < k; i++)    {        minHeap.Add(arr[i]);    }         // Loop For each element in array    // after the kth element    for(int i = k; i < size; i++)    {        minHeap.Sort();               // If current element is smaller        // than minimum ((top element of        // the minHeap) element, do nothing        // and continue to next element        if (minHeap[0] > arr[i])            continue;                 // Otherwise Change minimum element        // (top element of the minHeap) to        // current element by polling out        // the top element of the minHeap        else        {            minHeap.RemoveAt(0);            minHeap.Add(arr[i]);        }    }         // Now min heap contains k maximum    // elements, Iterate and print      foreach (int i in minHeap)    {        Console.Write(i + " ");    }} // Driver codepublic static void Main(String[] args){    int []arr = { 11, 3, 2, 1, 15, 5, 4,                  45, 88, 96, 50, 45 };    int size = arr.Length;         // Size of Min Heap    int k = 3;    FirstKelements(arr, size, k);}} // This code is contributed by aashish1995.
Output
50 88 96

Method 7(Using Quick Sort partitioning algorithm):

1. Choose a pivot number.
2. if K is lesser than the pivot_Index then repeat the step.
3. if K == pivot_Index : Print the array (low to pivot to get K-smallest elements and (n-pivot_Index) to n fotr K-largest elements)
4. if  K > pivot_Index : Repeat the steps for right part.

We can improve on standard quicksort algorithm by using random() function. Instead of using pivot element as last element, we can randomly choose the pivot element. The worst case time complexity of this version is O(n2) and average time complexity is O(n).

Following is the implementation of the above algorithm:

## C++

 #include using namespace std; //picks up last element between start and endint findPivot(int a[], int start, int end){         // Selecting the pivot element    int pivot = a[end];       // Initially partition-index will be    // at starting    int pIndex = start;     for (int i = start; i < end; i++) {               // If an element is lesser than pivot, swap it.        if (a[i] <= pivot) {            swap(a[i], a[pIndex]);                       // Incrementing pIndex for further            // swapping.            pIndex++;        }    }       // Lastly swapping or the    // correct position of pivot    swap(a[pIndex], a[end]);    return pIndex;}  //THIS PART OF CODE IS CONTRIBUTED BY - rjrachit//Picks up random pivot element between start and endint findRandomPivot(int arr[], int start, int end){    int n = end - start + 1;    // Selecting the random pivot index    int pivotInd = random()%n;      swap(arr[end],arr[start+pivotInd]);      int pivot = arr[end];      //initialising pivoting point to start index    pivotInd = start;    for (int i = start; i < end; i++) {               // If an element is lesser than pivot, swap it.        if (arr[i] <= pivot) {            swap(arr[i], arr[pivotInd]);                       // Incrementing pivotIndex for further            // swapping.            pivotInd++;        }    }       // Lastly swapping or the    // correct position of pivot    swap(arr[pivotInd], arr[end]);    return pivotInd;}//THIS PART OF CODE IS CONTRIBUTED BY - rjrachit void SmallestLargest(int a[], int low, int high, int k,                     int n){    if (low == high)        return;    else {        int pivotIndex = findRandomPivot(a, low, high);         if (k == pivotIndex) {            cout << k << " smallest elements are : ";            for (int i = 0; i < pivotIndex; i++)                cout << a[i] << "  ";             cout << endl;             cout << k << " largest elements are : ";            for (int i = (n - pivotIndex); i < n; i++)                cout << a[i] << "  ";        }         else if (k < pivotIndex)            SmallestLargest(a, low, pivotIndex - 1, k, n);         else if (k > pivotIndex)            SmallestLargest(a, pivotIndex + 1, high, k, n);    }} // Driver Codeint main(){    int a[] = { 11, 3, 2, 1, 15, 5, 4, 45, 88, 96, 50, 45 };    int n = sizeof(a) / sizeof(a[0]);     int low = 0;    int high = n - 1;       // Lets assume k is 3    int k = 4;     // Function Call    SmallestLargest(a, low, high, k, n);     return 0;}
Output
3 smallest elements are : 3  2  1
3 largest elements are : 96  50  88

Please write comments if you find any of the above explanations/algorithms incorrect, or find better ways to solve the same problem.
References:
http://en.wikipedia.org/wiki/Selection_algorithm

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up