最小堆中的第 K 个最小元素

给定一个大小为 n 的最小堆，找到最小堆中第 k^个最小的元素。

例子：

Input : {10, 50, 40, 75, 60, 65, 45}
k = 4
Output : 50

Input : {10, 50, 40, 75, 60, 65, 45}
k = 2
Output : 40

天真的方法：
我们可以从最小堆中提取最小元素 k 次，提取的最后一个元素将是第 k^个最小元素。每次删除操作需要 O(log n) 时间，因此这种方法的总时间复杂度为 O(k * log n)。

// C++ program to find k-th smallest
// element in Min Heap.
#include 
using namespace std;
  
// Structure for the heap
struct Heap {
    vector v;
    int n; // Size of the heap
  
    Heap(int i = 0)
        : n(i)
    {
        v = vector(n);
    }
};
  
// Generic function to
// swap two integers
void swap(int& a, int& b)
{
    int temp = a;
    a = b;
    b = temp;
}
  
// Returns the index of
// the parent node
inline int parent(int i)
{
    return (i - 1) / 2;
}
  
// Returns the index of
// the left child node
inline int left(int i)
{
    return 2 * i + 1;
}
  
// Returns the index of
// the right child node
inline int right(int i)
{
    return 2 * i + 2;
}
  
// Maintains the heap property
void heapify(Heap& h, int i)
{
    int l = left(i), r = right(i), m = i;
    if (l < h.n && h.v[i] > h.v[l])
        m = l;
    if (r < h.n && h.v[m] > h.v[r])
        m = r;
    if (m != i) {
        swap(h.v[m], h.v[i]);
        heapify(h, m);
    }
}
  
// Extracts the minimum element
int extractMin(Heap& h)
{
    if (!h.n)
        return -1;
    int m = h.v[0];
    h.v[0] = h.v[h.n-- - 1];
    heapify(h, 0);
    return m;
}
  
int findKthSmalles(Heap &h, int k)
{
    for (int i = 1; i < k; ++i)
        extractMin(h);
    return extractMin(h);
}
  
int main()
{
    Heap h(7);
    h.v = vector{ 10, 50, 40, 75, 60, 65, 45 };
    int k = 2;
    cout << findKthSmalles(h, k);
    return 0;
}

输出：

时间复杂度：O(k * log n)

有效的方法：
我们可以注意到一个关于最小堆的有趣观察。^第i 层的元素 x 有 i – 1 个祖先。根据最小堆的特性，这些 i-1 个祖先保证小于 x。这意味着 x 不能在堆的最少 i – 1 个元素中。使用此属性，我们可以得出结论，第 k^个最小元素的级别最多为 k。

我们可以减小最小堆的大小，使其只有 k 层。然后我们可以通过我们之前提取最小元素 k 次的策略来获得第 k^个最小元素。请注意，堆的大小减少到最大 2 ^k – 1，因此每个 heapify 操作将花费 O(log 2 ^k ) = O(k) 时间。总时间复杂度为 O(k ² )。如果 n >> k，则此方法的性能优于前一种。

// C++ program to find k-th smallest
// element in Min Heap using k levels
#include 
using namespace std;
  
// Structure for the heap
struct Heap {
    vector v;
    int n; // Size of the heap
  
    Heap(int i = 0)
        : n(i)
    {
        v = vector(n);
    }
};
  
// Generic function to
// swap two integers
void swap(int& a, int& b)
{
    int temp = a;
    a = b;
    b = temp;
}
  
// Returns the index of
// the parent node
inline int parent(int i)
{
    return (i - 1) / 2;
}
  
// Returns the index of
// the left child node
inline int left(int i)
{
    return 2 * i + 1;
}
  
// Returns the index of
// the right child node
inline int right(int i)
{
    return 2 * i + 2;
}
  
// Maintains the heap property
void heapify(Heap& h, int i)
{
    int l = left(i), r = right(i), m = i;
    if (l < h.n && h.v[i] > h.v[l])
        m = l;
    if (r < h.n && h.v[m] > h.v[r])
        m = r;
    if (m != i) {
        swap(h.v[m], h.v[i]);
        heapify(h, m);
    }
}
  
// Extracts the minimum element
int extractMin(Heap& h)
{
    if (!h.n)
        return -1;
    int m = h.v[0];
    h.v[0] = h.v[h.n-- - 1];
    heapify(h, 0);
    return m;
}
  
int findKthSmalles(Heap &h, int k)
{
    h.n = min(h.n, int(pow(2, k) - 1));
    for (int i = 1; i < k; ++i)
        extractMin(h);
    return extractMin(h);
}
  
int main()
{
    Heap h(7);
    h.v = vector{ 10, 50, 40, 75, 60, 65, 45 };
    int k = 2;
    cout << findKthSmalles(h, k);
    return 0;
}

输出：

时间复杂度：O(k ² )

更有效的方法：
我们可以通过以下算法进一步提高这个问题的时间复杂度：

创建一个优先队列P（或Min Heap），将min-heap的根节点插入到P中。优先队列的比较器函数应该是弹出最少的元素。
重复这些步骤 k – 1 次：
1. 从 P 中弹出最少的元素。
2. 插入弹出元素的左右子元素。（如果它们存在）。
P 中的最少元素是最小堆的^第k^个元素。

优先级队列的初始大小为 1，并且在 k-1 步中的每一步最多增加 1。因此，优先级队列中最多有 k 个元素，pop 和 insert 操作的时间复杂度为 O(log k)。因此总时间复杂度为 O(k * log k)。

// C++ program to find k-th smallest
// element in Min Heap using another
// Min Heap (Or Priority Queue)
#include 
using namespace std;
  
// Structure for the heap
struct Heap {
    vector v;
    int n; // Size of the heap
  
    Heap(int i = 0)
        : n(i)
    {
        v = vector(n);
    }
};
  
// Returns the index of
// the left child node
inline int left(int i)
{
    return 2 * i + 1;
}
  
// Returns the index of
// the right child node
inline int right(int i)
{
    return 2 * i + 2;
}
  
int findKthSmalles(Heap &h, int k)
{
    // Create a Priority Queue
    priority_queue,
                   vector >,
                   greater > >
        p;
  
    // Insert root into the priority queue
    p.push(make_pair(h.v[0], 0));
  
    for (int i = 0; i < k - 1; ++i) {
        int j = p.top().second;
        p.pop();
        int l = left(j), r = right(j);
        if (l < h.n)
            p.push(make_pair(h.v[l], l));
        if (r < h.n)
            p.push(make_pair(h.v[r], r));
    }
  
    return p.top().first;
}
  
int main()
{
    Heap h(7);
    h.v = vector{ 10, 50, 40, 75, 60, 65, 45 };
    int k = 4;
    cout << findKthSmalles(h, k);
    return 0;
}

输出：

时间复杂度：O(k * log k)

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。