Find k largest elements in an array

// JavaScript program to find k largest elements  
// in an array using sorting

function kLargest(arr, k) {
  
    // sort the given array in descending order
    arr.sort((a, b) => b - a);
    
    // store the first k elements in result array
    let res = arr.slice(0, k);
    return res;
}

// Driver Code
const arr = [1, 23, 12, 9, 30, 2, 50];
const k = 3;
const res = kLargest(arr, k);
console.log(res.join(' '));

//Driver Code Starts
// JavaScript program to find the k largest elements in the  
// array using min heap

class MinHeap {
    constructor() {
        this.heap = [];
    }
    
    // Swap two elements in the heap
    swap(i, j) {
        [this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]];
    }
    
    // Heapify up to maintain min heap property
    heapifyUp() {
        let index = this.heap.length - 1;
        while (index > 0) {
            let parentIndex = Math.floor((index - 1) / 2);
            if (this.heap[parentIndex] <= this.heap[index]) break;
            this.swap(parentIndex, index);
            index = parentIndex;
        }
    }
    
    // Heapify down to maintain min heap property
    heapifyDown() {
        let index = 0;
        while (2 * index + 1 < this.heap.length) {
            let leftChild = 2 * index + 1;
            let rightChild = 2 * index + 2;
            let smallest = leftChild;
            if (rightChild < this.heap.length && this.heap[rightChild] < this.heap[leftChild]) {
                smallest = rightChild;
            }
            if (this.heap[index] <= this.heap[smallest]) break;
            this.swap(index, smallest);
            index = smallest;
        }
    }
    
    // Insert element into the min heap
    push(val) {
        this.heap.push(val);
        this.heapifyUp();
    }
    
    // Remove and return the top element (smallest)
    pop() {
        if (this.heap.length === 1) return this.heap.pop();
        let min = this.heap[0];
        this.heap[0] = this.heap.pop();
        this.heapifyDown();
        return min;
    }
    
    // Get the top element (smallest)
    top() {
        return this.heap[0];
    }
    
    // Check if the heap is empty
    empty() {
        return this.heap.length === 0;
    }
}
//Driver Code Ends


// Function to find the k largest elements in the array 
function kLargest(arr, k) {
    
    // Min Priority Queue (Min-Heap) with first k
    // elements of the array
    let minH = new MinHeap();
    for (let i = 0; i < k; i++) {
        minH.push(arr[i]);
    }
    
    // Traverse n - k elements
    for (let i = k; i < arr.length; i++) {
        
        // If the top of heap is less than the arr[i]
        // then remove top element and insert arr[i] 
        if (minH.top() < arr[i]) {
            minH.pop();
            minH.push(arr[i]);
        }
    }
    
    let res = [];
    
    // Min heap will contain only k 
    // largest elements
    while (!minH.empty()) {
        res.push(minH.pop());
    }
    
    // Reverse the result array, so that all
    // elements are in decreasing order
    res.reverse();
    return res;
}


//Driver Code Starts
// Driver Code
let arr = [1, 23, 12, 9, 30, 2, 50];
let k = 3;

let res = kLargest(arr, k);
console.log(res.join(" "));

//Driver Code Ends

// JavaScript program to find the k largest elements in the array
// using partitioning step of quick sort

// Function to partition the array around a pivot
function partition(arr, left, right) {
    
    // Last element is chosen as a pivot.
    let pivot = arr[right];
    let i = left;

    for (let j = left; j < right; j++) {
    
    	// Elements greater than or equal to pivot are
       	// placed in the left part of pivot
        if (arr[j] >= pivot) {
            [arr[i], arr[j]] = [arr[j], arr[i]];
            i++;
        }
    }
    
    [arr[i], arr[right]] = [arr[right], arr[i]];
    
    // The correct sorted position of the pivot
    return i;
}

function quickSelect(arr, left, right, k) {
    if (left <= right) {
        let pivotIdx = partition(arr, left, right);
        
        // Count of all elements in the left part
        let leftCnt = pivotIdx - left + 1;
      
        // If leftCnt is equal to k, then the first
        // k element of the array will be largest
        if (leftCnt === k)
            return;
        
        // Search in the left subarray
        if (leftCnt > k)
            quickSelect(arr, left, pivotIdx - 1, k);
        
        // Reduce the k by number of elements already covered
        // and search in the right subarray
        else
            quickSelect(arr, pivotIdx + 1, right, k - leftCnt);
    }
}

function kLargest(arr, k) {
    quickSelect(arr, 0, arr.length - 1, k);
    
    // First k elements of the array, will be the largest
    let res = arr.slice(0, k);
    
    // Sort the first k elements in descending order
    res.sort((a, b) => b - a);
    return res;
}

// Driver Code
const arr = [1, 23, 12, 9, 30, 2, 50];
const k = 3;
const res = kLargest(arr, k);
console.log(res.join(' '));