堆核心算法（c++）

最新推荐文章于 2022-05-27 10:13:42 发布
最新推荐文章于 2022-05-27 10:13:42 发布
阅读量206 收藏
点赞数
分类专栏： 面试 c++ 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaoxiaoyikesu/article/details/119319037
版权
c++ 同时被 3 个专栏收录
31 篇文章 0 订阅
订阅专栏
面试
27 篇文章 0 订阅
订阅专栏
数据结构与算法
22 篇文章 0 订阅
订阅专栏

以数组存放，下标从0开始，大顶堆为例 

1. 堆化（往堆中插入一个元素）

从下往上

/**
 * @brief 往堆中插入新元素
 * @param a 堆
 * @param data 新元素
 */
void Insert(vector<int> &a, int data) {
    a.push_back(data);
    int i = a.size() - 1;
    while (1) {
        int parent = (i-1)/2;
        if (parent >= 0 && a[i] > a[parent]) {
            swap(a[i], a[parent]);
            i = parent;
        }
        else {
            break;
        }
    }
}

 从上往下

/**
 * @brief 自上往下堆化
 * @param a 数据数组，原地算法，所以不能通过a.size()来判断当前的堆容量
 * @param n 堆容量
 * @param i 当前处理的下标位置
 */
void Heapify(vector<int> &a, int n, int i) {
    while (1) {
        int max_pos = i;
        int left = 2 * i + 1;
        int right = 2 * i + 2;
        if (left < n && a[max_pos] < a[left]) max_pos = left;
        if (right < n && a[max_pos] < a[right]) max_pos = right;
        if (max_pos == i) break;
        swap(a[i], a[max_pos]);
        i = max_pos;
    }
}

关键在于正确写成下标以及边界条件，堆化的时间复杂度和树的高度成正比，由于堆是完全二叉树，为O(logn) 

2. 删除堆顶元素

/**
 * @brief 从已经建好的堆中删除堆顶元素
 * @param a 堆
 */
void RemoveHeapTop(vector<int> &a) {
    if (a.size() == 0) return;
    a[0] = a.back();
    a.pop_back();
    Heapify(a, a.size(), 0);
}

删除就是用最后一个元素覆盖堆顶元素，在进行堆化，注意Heapify是从上往下进行堆化的，时间复杂度和树的高度成正比，为O(logn)

3. 建堆

/**
 * @brief 原地建堆
 * @param a 原始数据数组
 */
void BuildHeap(vector<int> &a) {
    for (int i = a.size()/2 - 1; i>=0; --i) {
        Heapify(a, a.size(), i);
    }
}

分析比较复杂，时间复杂度是O(n) 

4. 堆排序

/**
 * @brief 自上往下堆化
 * @param a 数据数组，原地算法，所以不能通过a.size()来判断当前的堆容量
 * @param n 堆容量
 * @param i 当前处理的下标位置
 */
void Heapify(vector<int> &a, int n, int i) {
    while (1) {
        int max_pos = i;
        int left = 2 * i + 1;
        int right = 2 * i + 2;
        if (left < n && a[max_pos] < a[left]) max_pos = left;
        if (right < n && a[max_pos] < a[right]) max_pos = right;
        if (max_pos == i) break;
        swap(a[i], a[max_pos]);
        i = max_pos;
    }
}

/**
 * @brief 原地建堆
 * @param a 原始数据数组
 */
void BuildHeap(vector<int> &a) {
    for (int i = a.size()/2 - 1; i>=0; --i) {
        Heapify(a, a.size(), i);
    }
}

/**
 * @brief 实现堆排序
 * @param a 原始数组
 */
void HeapSort(vector<int> &a) {
    BuildHeap(a);
    int k = a.size() - 1;
    while (k > 0) {
        swap(a[0],a[k]);
        Heapify(a, k,0); //前k个元素堆化
        --k;
    }
}

时间复杂度O(nlogn)，最好最坏平均都是这个，但是由于堆化时需要较好第一个元素和最后一个元素，因此堆排序不是稳定的排序算法 

以上完整代码总结如下：

#include <iostream>
#include <vector>
using namespace std;

/**
 * @brief 往堆中插入新元素
 * @param a 堆
 * @param data 新元素
 */
void Insert(vector<int> &a, int data) {
    a.push_back(data);
    int i = a.size() - 1;
    while (1) {
        int parent = (i-1)/2;
        if (parent >= 0 && a[i] > a[parent]) {
            swap(a[i], a[parent]);
            i = parent;
        }
        else {
            break;
        }
    }
}

/**
 * @brief 自上往下堆化
 * @param a 数据数组，原地算法，所以不能通过a.size()来判断当前的堆容量
 * @param n 堆容量
 * @param i 当前处理的下标位置
 */
void Heapify(vector<int> &a, int n, int i) {
    while (1) {
        int max_pos = i;
        int left = 2 * i + 1;
        int right = 2 * i + 2;
        if (left < n && a[max_pos] < a[left]) max_pos = left;
        if (right < n && a[max_pos] < a[right]) max_pos = right;
        if (max_pos == i) break;
        swap(a[i], a[max_pos]);
        i = max_pos;
    }
}

/**
 * @brief 原地建堆
 * @param a 原始数据数组
 */
void BuildHeap(vector<int> &a) {
    for (int i = a.size()/2 - 1; i>=0; --i) {
        Heapify(a, a.size(), i);
    }
}

/**
 * @brief 实现堆排序
 * @param a 原始数组
 */
void HeapSort(vector<int> &a) {
    BuildHeap(a);
    int k = a.size() - 1;
    while (k > 0) {
        swap(a[0],a[k]);
        Heapify(a, k,0); //前k个元素堆化
        --k;
    }
}

/**
 * @brief 对已经建好的堆进行排序
 * @param a 堆
 */
void HeapOnlySort(vector<int> &a) {
    int k = a.size() - 1;
    while (k > 0) {
        swap(a[0],a[k]);
        Heapify(a, k,0); //前k个元素堆化
        --k;
    }
}

/**
 * @brief 从已经建好的堆中删除堆顶元素
 * @param a 堆
 */
void RemoveHeapTop(vector<int> &a) {
    if (a.size() == 0) return;
    a[0] = a.back();
    a.pop_back();
    Heapify(a, a.size(), 0);
}

int main() {
    vector<int> a{1,5,2,3,4,7,9,8,6};
    //HeapSort(a);
    BuildHeap(a);
    Insert(a, 7);
    Insert(a, 10);
    Insert(a, -5);
    RemoveHeapTop(a);
    RemoveHeapTop(a);
    HeapOnlySort(a);
    for (auto &m : a) {
        cout << m << " ";
    }
    return 0;
}

5. 合并多个有序链表

leetcode23

思路：维护一个小顶堆，首先将所有非空链表压入堆，然后每次弹出堆顶元素，若弹出元素存在下一个非空结点，则将下一个结点压入堆，直到堆为空，需要自己实现建堆，出堆，往堆中插入元素，编码较为复杂 

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
private:
    void heapify(vector<ListNode*> &heap, int n, int i) {
        if (i < 0 || i>= n) return;
        int min_pos, left, right;
        while (1) {
            min_pos = i;
            left = 2*i + 1;
            right = 2*i + 2;
            if (left<n && heap[left]->val < heap[min_pos]->val) min_pos = left;
            if (right<n && heap[right]->val < heap[min_pos]->val) min_pos = right;
            if (min_pos == i) break;
            swap(heap[min_pos], heap[i]);
            i = min_pos;
        }
        
    }
    void buildHeap(vector<ListNode*> &heap) {
        int start = heap.size()/2 - 1;
        for (int i=start; i>=0; --i) {
            heapify(heap, heap.size(), i);
        }
    }
    void removeTop(vector<ListNode*> &heap) {
        if (0 == heap.size()) return;
        heap[0] = heap.back();
        heap.pop_back();
        if (heap.size() < 2) return;
        heapify(heap, heap.size(), 0);
    }
    void insert(vector<ListNode*> &heap, ListNode* node) {
        heap.push_back(node);
        if (heap.size() < 2) return;
        int i = heap.size() - 1;
        int parent;
        while (1) {
            parent = (i-1) / 2;
            if (parent<0 || heap[parent]->val < heap[i]->val) break;
            swap(heap[parent], heap[i]);
            i = parent;
        }
    }
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        // 0.准备
        ListNode* guard = new ListNode();
        ListNode* curr = guard;
        // 1.建堆,小顶堆
        vector<ListNode*> heap;
        for (auto &m : lists) {
            if (m) {
                heap.push_back(m);
            }
        }
        buildHeap(heap);

        // 2.循环处理
        while (1) {
            // 2.0 若堆为空，则退出
            if (0 == heap.size()) break;
            // 2.1 存放结果
            curr->next = heap[0];
            curr = curr->next;
            // 2.2 若堆顶元素下一个结点非空，则替换堆顶元素为它下一个结点，再堆化
            if (heap[0]->next) {
                heap[0] = heap[0]->next;
                heapify(heap, heap.size(), 0);
            }
            // 2.3 若堆顶元素下一个结点为空，则删除堆顶元素
            else {
                removeTop(heap);
            }
        }
        
        // 3. 返回结果
        return guard->next;
    }
};

时间复杂度O(nlogk)，其中n为所有结点总数，k为链表数量，空间复杂度O(k) 

这道题可以使用c++自带的优先队列，priority_queue，底层实现就是堆，需要自行定义<操作符函数，默认是大顶堆

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
struct Status {
    int val;
    ListNode* ptr;
    bool operator < (const Status &rhs) const {
        return val > rhs.val;
    }
    Status(int v, ListNode* p) : val(v), ptr(p) {} //可以省略，使用默认初始化列表，但是写了更加清晰
};
class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        // 1.初始化优先队列
        priority_queue<Status> q;
        for (auto &m : lists) {
            if (m) {
                q.push(Status(m->val, m));
            }
        }
        // 2.循环处理
        ListNode *guard = new ListNode();
        ListNode *tail = guard;
        while (!q.empty()) {
            // 2.1 取出堆顶元素
            tail->next = q.top().ptr;
            tail = tail->next;
            q.pop();
            // 2.2 若堆顶元素存在下一个非空结点则压入堆，注意此时tail就是上一个堆顶元素对应的指针
            if (tail->next) {
                q.push(Status{tail->next->val, tail->next});
            }
        }
        // 3.返回结果
        return guard->next;
    }
};

思路和上面基本一致，不过用c++自带的priority_queue来代替自己实现的堆，编码更加简单，不容易出错，不过注意这种方式需要定义堆的元素类型，并且需要定义<运算符函数，最好也定义构造函数

6. 利用堆求 Top K

leetcode题目

思路：维护一个大顶堆，每次将小于堆顶的元素压入堆，然后弹出新的堆的堆顶，到最后堆中剩下的k个元素就是最小的k个元素

class Solution {
public:
    vector<int> smallestK(vector<int>& arr, int k) {
        vector<int> ans;
        if (k == 0) return ans;
        // 1.初始化优先队列，默认是大顶堆
        priority_queue<int, vector<int>, less<>> q;
        //priority_queue<int> q;
        for (int i=0; i<k; ++i) {
            q.push(arr[i]);
        }
        // 2.每次比较，若当前元素小于堆顶元素则压入堆，然后弹出堆顶元素
        for (int i=k; i<arr.size(); ++i) {
            if (arr[i] < q.top()) {
                q.push(arr[i]);
                q.pop();
            }
        }
        // 3.最终堆中元素就是答案
        while (!q.empty()) {
            ans.push_back(q.top());
            q.pop();
        }
        return ans;
    }
};

时间复杂度O(nlogk)，空间复杂度O(k) 

7. 利用堆求中位数

leetcode295

思路：维护两个堆，一个大顶堆，一个小顶堆，当元素小于大顶堆堆顶时压入大顶堆，否则压入小顶堆，然后平衡两个堆使得小顶堆数量为sum/2，其中sum是总的元素个数；再求中位数时，如果元素总数为奇数，则返回大顶堆堆顶，若元素总数为偶数，则返回两个堆堆顶元素的平均值

class MedianFinder {
private:
    priority_queue<int, vector<int>, less<>> max_top_heap; //大顶堆
    priority_queue<int, vector<int>, greater<>> min_top_heap; //小顶堆
public:
    /** initialize your data structure here. */
    MedianFinder() {

    }
    
    void addNum(int num) {
        // 1.入堆
        if (0 == max_top_heap.size() || num < max_top_heap.top()) {
            max_top_heap.push(num);
        }
        else {
            min_top_heap.push(num);
        }
        // 2.平衡两个堆
        int sum = min_top_heap.size() + max_top_heap.size();
        int temp;
        while (1) {
            if (min_top_heap.size() == sum/2) break; //平衡了
            else if (min_top_heap.size() < sum/2) {
                temp = max_top_heap.top();
                max_top_heap.pop();
                min_top_heap.push(temp);
            }
            else {
                temp = min_top_heap.top();
                min_top_heap.pop();
                max_top_heap.push(temp);
            }
        }
    }
    
    double findMedian() {
        int sum = min_top_heap.size() + max_top_heap.size();
        if (sum % 2 == 0) {
            return ((double)max_top_heap.top() + min_top_heap.top()) / 2;
        }
        else {
            return max_top_heap.top();
        }
    }
};

/**
 * Your MedianFinder object will be instantiated and called as such:
 * MedianFinder* obj = new MedianFinder();
 * obj->addNum(num);
 * double param_2 = obj->findMedian();
 */

时间复杂度：加入元素是O(log(n/2))，最大是log(n)，空间复杂度为O(n)，求中位数的时间复杂度为O(1) 

CrazyFox%
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
堆的向上调整、向下调整（堆化）
fll980205的博客
05-01 8918
数据结构上的堆在物理上是一个数组，在逻辑上是一个二叉树。 大堆：根结点比孩子结点大； 小堆：根结点比孩子结点小； 堆化（向下调整）、向上调整的前提都是：在二叉树中，只有一个位置不满足堆的性质，其它位置都满足堆的性质。 向下调整 是让调整的结点与其孩子节点进行比较 向上调整 是让调整的结点与其父亲结点进行比较 已知双亲的下标，则左孩子的下标为：left=...
堆排序自下向上建堆和自上向下调整的时间复杂度
chengchaonan的博客
04-12 6818
堆排序分为 因为初始化建堆的过程，是一个杂乱无序的数组构成的完全二叉树，所以需要从第一个非叶节点开始与它的叶子节点进行比较，然后移动。不是说每一层选一个根节点进行比较就可以了，是每一层的所有元素都要跟它的左右节点进行比较。这也就导致了它的时间复杂度不是logn,对于重建堆的过程，因为是从最上面的根节点开始进行左右节点的比较，选择一个较小的左节点或者有节点进行交换。而因为只破坏了一层的有序性，另外...
C++STL——堆化heap
R.I.P Kobe Bryant
05-08 208
C++STL——堆化heap
数据结构——堆(C++)
Wiki~
11-13 8752
数据结构——堆 文章目录数据结构——堆堆与堆排序二叉树满二叉树完全二叉树二叉堆堆的存储堆的插入删除具体的实现堆排序 堆与堆排序 堆（heap）分为二叉堆、二项式堆、斐波那契堆，堆是非线性数据结构，相当于一维数组，有两个直接后继。堆又被称为优先队列，尽管名为优先队列，但堆并不是队列。因为队列遵循First in, First out，但是堆是按照元素的优先级取出元素。所以“堆”是实现调度器的理想数据...
C++数据结构详解——堆
热门推荐
qq_54169998的博客
11-02 1万+
1.堆的原理精讲 最大堆特点： 当然，也有最小堆，最小堆就是将最大堆反过来，根结点为最小值~ 堆是树中最有个性的树，他是用数组表示的树 。 2.在数组中快速创建堆算法 1.首先我们需要找到最后一个结点的父结点如图(a),我们找到的结点是 87，然后找出该结点的最大子节点与自己比较，若该子节点比自身大，则将两个结点交换。 图(a)中，87 比左子节点 95 小,则交换之。如图(b)所示 2.我们移动到第一步前一个父节点 93，如图(c)所示.同理做第一步的比较...
C++堆排序算法实例详解
08-29
堆排序算法的核心是建立一个堆结构，然后通过堆化和交换元素来实现排序。堆结构可以是一个max-heap或min-heap，前者每个节点的key都大于等于孩子节点的key，后者每个节点的key都小于等于孩子节点的key。 二、C++...
C++堆排序算法的实现
10-09
总结一下，C++中的堆排序算法通过构建和调整最大堆实现排序。`heapify`函数确保每个子树都是最大堆，而`heapSort`函数整体上负责构建最大堆和交换元素以达到排序目的。这个过程无需额外的存储空间，且时间复杂度为O...
排序算法之堆排序算法：用C++语言实现堆排序算法
最新发布
05-22
标题"排序算法之堆排序算法：用C++语言实现堆排序算法"，意味着我们将讨论如何用C++编程语言来实现堆排序的过程。C++是面向对象的编程语言，具有丰富的库支持和高效的执行性能，是实现算法的理想选择。 描述"排序...
解读堆排序算法及用C++实现基于最大堆的堆排序示例
09-02
本文将详细解析堆排序算法，并通过C++实现基于最大堆的堆排序示例。 首先，理解堆排序的核心概念。堆是一个近似完全二叉树的数据结构，分为最大堆和最小堆。在最大堆中，每个节点的键值都不小于其子节点的键值，根...
C++贪心算法.zip
10-28
4. **代码实现**：在C++中，贪心算法的实现通常涉及数据结构如数组、链表、堆（优先队列）等。例如，对于求解最小生成树的Prim算法，可以使用邻接矩阵或邻接表来表示图，并利用优先队列来选取边。 5. **证明正确性*...
C++实现最大堆的创建
11-29
分享一下最大堆的创建。代码不算完美，请见谅。如有不解的或者有错误的欢迎交流哈。
Leetcode语法笔记
qq_42941526的博客
06-10 297
Leetcode语法笔记链表问题无重复字符的最长子串功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 链表问题 ListNode* l3=new ListNode(-1);//存放结果的链表 List
数据结构与算法详解——堆篇（附c++实现代码）
JMasker的博客
05-27 701
堆，堆排序，topK问题，求中位数
建堆（C/C++）
Pulsar
04-28 324
/** * 最大堆最小堆建立 * 堆的插入删除 **/
C++ 类的栈和堆实例化
feikon's blog
01-09 1738
#include "stdafx.h" #include using namespace std; class Coordnate { public: Coordnate(); ~Coordnate(); int x; int y; void printX() { cout << x << endl; } void printY() { cout << y << en
如何判断堆栈是从上往下还是从下往上增长的
Cloud-Datacenter-Renewable Energy-Big Data-Model
04-15 4013
如何判断堆栈是从上往下还是从下往上增长的 刚才自己想出了一个方法，代码如下，请各位指教：    void StackTest()  {     int i = 0;     int j = 0;     int *pi = &i;     int *pj = &j;       if(pi pj)         cout"bottom up"endl;     else
堆的构建及堆排序（C++）
Darlewo
05-13 1050
首先给出堆的定义（这里转自https://blog.csdn.net/u011068702/article/details/52771173） n个元素的序列{k1，k2，…,kn}当且仅当满足下列关系之一时，称之为堆。 　　情形1：<= 且<= （最小化堆或小顶堆） 　　情形2：>= 且>= （最大化堆或大顶堆） 　　其中i=1,2,…,n/2向下...
Leetcode中的经典算法（归并/分治/快排/数学问题）如何体现在题目中
qq_41605114的博客
06-12 549
分治 合并K个排序链表 https://leetcode-cn.com/problems/merge-k-sorted-lists/ 合并两个链表的经验我们有，那么n个也是一样的，我们两个两个合并，如图所示： /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NU
堆排序算法的C/C++实现
本文主要介绍了一项数据结构课程设计项目，其中的核心内容是对堆排序算法的实现。堆排序是一种基于比较的排序算法，利用了完全二叉树的特性，通过构建堆并不断调整来达到排序的目的。 堆排序的基本思想是首先构建一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值