{"id":1588,"date":"2020-07-01T09:30:28","date_gmt":"2020-07-01T09:30:28","guid":{"rendered":"https:\/\/blog.prepbytes.com\/?p=1588"},"modified":"2023-11-23T12:44:33","modified_gmt":"2023-11-23T12:44:33","slug":"kth-largest-element","status":"publish","type":"post","link":"https:\/\/prepbytes.com\/blog\/kth-largest-element\/","title":{"rendered":"Kth Largest element"},"content":{"rendered":"

\"\"
\nIn the realm of data structures, heaps stand out as an essential tool for efficient manipulation of priority-based information. One common problem encountered when dealing with heaps is finding the Kth largest element within them. Whether it’s a min-heap or a max-heap, determining the Kth largest element involves specific techniques that leverage the structure’s properties to optimize the search.
\nThis article delves into the intricacies of finding the Kth largest element in a heap, exploring various approaches and algorithms tailored for different types of heaps. From understanding the fundamentals of heaps to implementing algorithms for extracting the Kth largest element, this guide aims to provide a comprehensive overview of this problem-solving process. Basically, Given the heights of N buildings and an integer k, we have to find the height of kth highest building.<\/p>\n

<\/strong><\/u><\/a><\/p>\n

How to Find Kth Largest Element?<\/h3>\n
\n

Idea is to create a max-heap<\/strong> of heights of buildings, in order to get kth<\/sup> highest height we need go remove first k-1<\/code> largest height. <\/p>\n<\/blockquote>\n

Method 1 :<\/h4>\n
\n

Sort the array containing heights of the buildings in decreasing order using any sorting algorithm. Now print the kth<\/sup> value in the array which is the kth<\/sup> highest height.<\/p>\n<\/blockquote>\n

Method 2 :<\/h4>\n
    \n
  • \n

    Geneate a max-heap<\/strong> from the heights of the buildings.<\/p>\n<\/li>\n

  • \n

    In a max-heap<\/strong>, the root always stores the larger value as compared to its left<\/strong> & right<\/strong> subtree, this condition needs to be true for every node. We need to insert each item one by one such that parent is always larger than the item itself. If parent is smaller, then swap the current item with its parent. <\/p>\n<\/li>\n

  • \n

    After generating max-heap<\/strong> now extract<\/strong> first k-1<\/code> heights from the heap. Among the remaining heights, the first element of the heap (heap[0]<\/code>) is the kth<\/code> highest element.<\/p>\n<\/li>\n<\/ul>\n

    extract()<\/strong>: Removes the maximum element from Max-Heap<\/strong>. Time Complexity of this Operation is O(Logn) as this operation needs to maintain the heap property (by calling heapify()<\/strong>) after removing root.<\/p>\n

    heapify()<\/strong>: Maintains the heap property for each node. If any node does not follow heap property it swaps the node with the node which is smaller ,or greater (in case of max-heap<\/strong>), than the node.<\/p>\n

    Algorithms :<\/h3>\n

    Insert() :<\/h4>\n
    \n
      \n
    1. Insert the item at the last index, and increment the size by 1.<\/li>\n
    2. Then, check if the inserted item is smaller than its parent,<\/li>\n
    3. If yes, then swap the inserted item with its parent.<\/li>\n
    4. If no, then do nothing.<\/li>\n
    5. Now, go to step 2<\/code> and repeat untill we reach root (first element).<\/li>\n<\/ol>\n<\/blockquote>\n

      Extract() :<\/h4>\n
      \n
        \n
      1. Store the value of the first node of our heap ( temp = heap[0]<\/code> ).<\/li>\n
      2. Replace the root node with the farthest right node (last element).<\/li>\n
      3. Decrease the size by 1<\/code>. (heap[0] = heap[size-1])<\/code><\/li>\n
      4. Perform heapify<\/strong> starting from the new root. <\/li>\n
      5. Return the stored value (temp<\/code>).<\/li>\n<\/ol>\n<\/blockquote>\n

        Heapify ():<\/h4>\n
        \n
          \n
        1. if the heap property holds true then you are done.<\/li>\n
        2. else if<\/li>\n
        3. the replacement node value < its parent nodes value
          \nthen swap them, and repeat step 3.<\/li>\n
        4. else<\/li>\n
        5. swap the replacement node with the largest child node, and
          \nrepeat step 3.<\/li>\n<\/ol>\n<\/blockquote>\n

          Example:<\/h3>\n

          \"\"<\/p>\n

          Solutions:<\/h3>\n\t\t\t\t\t\t