c++从堆到哈希堆

最新推荐文章于 2024-02-26 08:37:50 发布
置顶 最新推荐文章于 2024-02-26 08:37:50 发布
阅读量201 收藏 2
点赞数
分类专栏： c++ 个人 常用算法 工具类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34179431/article/details/117966242
版权

普通堆的构建

#include <iostream>
#include <utility>
#include <string>
#include <cstring>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <unordered_map>
#include <unordered_set>
#include <algorithm>
#include <numeric>

using namespace std;

const int MAX_N = 1024;

int heap[MAX_N];
int tail = 0;

void push(int v) {
    int idx = tail++;
    while (idx > 0) {
        int p = (idx - 1) / 2;
        if (heap[p] <= v) {
            break;
        }
        heap[idx] = heap[p]；
        idx = p;
    }
    heap[idx] = v;
}

int top() {
    return heap[0];
}

void pop(int p = 0) {
    int res = heap[p];
    int v = heap[--tail];
    int newp = p;
    while (newp * 2 + 1 < tail) {
        int mm = newp * 2 + 1, ma = mm + 1;
        if (ma < tail && heap[ma] < heap[mm]) {
            mm = ma;
        }
        if (heap[mm] > v) {
            break;
        }
        heap[newp] = heap[mm];
        newp = mm;
    }
    heap[newp] = v;
}

int main() {
    for (int i = 0; i < 6; i++) {
        push(i);
    }
    cout << heap[0];
}

哈希堆的构造

class hash_heap {
private:
    vector<int> _indexes;

    unordered_map<int, int> _index_map;

    const vector<int> &_data;

    function<bool(int, int)> _cmp;

    int sz;

    int get_value(int index) {
        return _data[index];
    }

    void heap_down(int i = 0) {
        if (sz <= 1) {
            return;
        }
        int index = _indexes[i];
        while (2 * i + 1 < sz) {
            int mm = 2 * i + 1;
            int ma = mm + 1;
            if (ma < sz && _cmp(get_value(_indexes[ma]), get_value(_indexes[mm]))) {
                mm = ma;
            }
            if (_cmp(get_value(index), get_value(_indexes[mm]))) {
                break;
            }
            // 往下挪
            _indexes[i] = _indexes[mm];
            // 更新 kv
            _index_map[_indexes[i]] = i;
            i = mm;
        }
        _indexes[i] = index;
        _index_map[_indexes[i]] = i;
    }

    void heap_up(int i) {
        if (sz <= 1) {
            return;
        }
        int index = _indexes[i];
        while (i > 0) {
            int p = (i - 1) >> 1;
            if (_cmp(get_value(_indexes[p]), get_value(index))) {
                break;
            }
            _indexes[i] = _indexes[p];
            _index_map[_indexes[i]] = i;
            i = p;
        }
        _indexes[i] = index;
        _index_map[_indexes[i]] = i;
    }


public:
    explicit hash_heap(const vector<int> &data, function<bool(int, int)> cmp = less_equal<int>{}) : _data(data),
                                                                                              _cmp(std::move(cmp)),
                                                                                              sz(0) {}
    void push(int index) {
        if (index >= _data.size()) {
            return;
        }
        if (sz >= _indexes.size()) {
            _indexes.push_back(index);
        } else {
            _indexes[sz] = index;
        }
        // 更新 kv
        _index_map[index] = sz;
        ++sz;
        heap_up(sz - 1);
    }

    void pop(int inner_index = 0) {
        if (inner_index >= sz) {
            return;
        }
        // 存储大小减1
        --sz;
        // 删除 kv
        _index_map.erase(_indexes[inner_index]);
        if (inner_index == sz) {
            // 就是最后一个, 删除结束
            return;
        }
        // 最后一个往前挪
        _indexes[inner_index] = _indexes[sz];
        // 更新 kv
        _index_map[_indexes[inner_index]] = inner_index;

        // 更新堆
        if (inner_index == 0) {
            heap_down(inner_index);
        } else {
            // 对于 hash_pop 上移, 下移不确定
            int p = (inner_index - 1) >> 1;
            if (_cmp(get_value(_indexes[inner_index]), get_value(_indexes[p]))) {
                heap_up(inner_index);
            } else {
                heap_down(inner_index);
            }
        }
    }

    int top() {
        return _indexes[0];
    }

    bool hash_pop(int index) {
        if (_index_map.count(index) == 0) {
            return false;
        }
        int inner_index = _index_map[index];
        pop(inner_index);
        return true;
    }

    [[nodiscard]] int size() const {
        return sz;
    }

   /*
    * 辅助验证函数
    *
    * */
    // 对于小堆, 父节点小于等于子节点
    bool check_heap(int i = 0) {
        if (2 * i + 1 >= sz) {
            return true;
        }
        int mm = 2 * i + 1, ma = mm + 1;
        if (ma < sz) {
            if (!_cmp(get_value(_indexes[i]), get_value(_indexes[mm])) || !_cmp(get_value(_indexes[i]), get_value(_indexes[ma]))) {
                return false;
            }
            return check_heap(mm) && check_heap(ma);
        }
        return _cmp(get_value(_indexes[i]), get_value(_indexes[mm])) && check_heap(mm);
    }

    // hash 是否正确
    bool check_hash() {
        for (int i = 0; i < sz; i++) {
            if (_index_map[_indexes[i]] != i) {
                return false;
            }
        }
        return true;
    }

    void print() {
        for (auto &kv : _index_map) {
            cout << kv.first << "\t" << kv.second << "\t" << get_value(_indexes[kv.first]) << "\t" << _data[kv.second]
                 << endl;
        }
    }
};

哈希堆实战

https://leetcode-cn.com/problems/sliding-window-median/

class hash_heap {
private:
    vector<int> _indexes;

    unordered_map<int, int> _index_map;

    const vector<int> &_data;

    function<bool(int, int)> _cmp;

    int sz;

    int get_value(int index) {
        return _data[index];
    }

    void heap_down(int i = 0) {
        if (sz <= 1) {
            return;
        }
        int index = _indexes[i];
        while (2 * i + 1 < sz) {
            int mm = 2 * i + 1;
            int ma = mm + 1;
            if (ma < sz && _cmp(get_value(_indexes[ma]), get_value(_indexes[mm]))) {
                mm = ma;
            }
            if (_cmp(get_value(index), get_value(_indexes[mm]))) {
                break;
            }
            // 往下挪
            _indexes[i] = _indexes[mm];
            // 更新 kv
            _index_map[_indexes[i]] = i;
            i = mm;
        }
        _indexes[i] = index;
        _index_map[_indexes[i]] = i;
    }

    void heap_up(int i) {
        if (sz <= 1) {
            return;
        }
        int index = _indexes[i];
        while (i > 0) {
            int p = (i - 1) >> 1;
            if (_cmp(get_value(_indexes[p]), get_value(index))) {
                break;
            }
            _indexes[i] = _indexes[p];
            _index_map[_indexes[i]] = i;
            i = p;
        }
        _indexes[i] = index;
        _index_map[_indexes[i]] = i;
    }


public:
    explicit hash_heap(const vector<int> &data, function<bool(int, int)> cmp = less_equal<int>{}) : _data(data),
                                                                                              _cmp(std::move(cmp)),
                                                                                              sz(0) {}
    void push(int index) {
        if (index >= _data.size()) {
            return;
        }
        if (sz >= _indexes.size()) {
            _indexes.push_back(index);
        } else {
            _indexes[sz] = index;
        }
        // 更新 kv
        _index_map[index] = sz;
        ++sz;
        heap_up(sz - 1);
    }

    void pop(int inner_index = 0) {
        if (inner_index >= sz) {
            return;
        }
        // 存储大小减1
        --sz;
        // 删除 kv
        _index_map.erase(_indexes[inner_index]);
        if (inner_index == sz) {
            // 就是最后一个, 删除结束
            return;
        }
        // 最后一个往前挪
        _indexes[inner_index] = _indexes[sz];
        // 更新 kv
        _index_map[_indexes[inner_index]] = inner_index;

        // 更新堆
        if (inner_index == 0) {
            heap_down(inner_index);
        } else {
            // 对于 hash_pop 上移, 下移不确定
            int p = (inner_index - 1) >> 1;
            if (_cmp(get_value(_indexes[inner_index]), get_value(_indexes[p]))) {
                heap_up(inner_index);
            } else {
                heap_down(inner_index);
            }
        }
    }

    int top() {
        return _indexes[0];
    }

    bool hash_pop(int index) {
        if (_index_map.count(index) == 0) {
            return false;
        }
        int inner_index = _index_map[index];
        pop(inner_index);
        return true;
    }

    [[nodiscard]] int size() const {
        return sz;
    }

   /*
    * 辅助验证函数
    *
    * */
    // 对于小堆, 父节点小于等于子节点
    bool check_heap(int i = 0) {
        if (2 * i + 1 >= sz) {
            return true;
        }
        int mm = 2 * i + 1, ma = mm + 1;
        if (ma < sz) {
            if (!_cmp(get_value(_indexes[i]), get_value(_indexes[mm])) || !_cmp(get_value(_indexes[i]), get_value(_indexes[ma]))) {
                return false;
            }
            return check_heap(mm) && check_heap(ma);
        }
        return _cmp(get_value(_indexes[i]), get_value(_indexes[mm])) && check_heap(mm);
    }

    // hash 是否正确
    bool check_hash() {
        for (int i = 0; i < sz; i++) {
            if (_index_map[_indexes[i]] != i) {
                return false;
            }
        }
        return true;
    }

    void print() {
        for (auto &kv : _index_map) {
            cout << kv.first << "\t" << kv.second << "\t" << get_value(_indexes[kv.first]) << "\t" << _data[kv.second]
                 << endl;
        }
    }
};

class medianWindows {
private:
    const vector<int> &data;
    hash_heap min_heap;
    hash_heap max_heap;
    int k;
    int mid;
    int cur;
    int sz;
    double _m{};

    void adjust() {
        if (max_heap.size() > min_heap.size() + 1) {
            min_heap.push(mid);
            mid = max_heap.top();
            max_heap.pop();
        }

        if (min_heap.size() > max_heap.size()) {
            max_heap.push(mid);
            mid = min_heap.top();
            min_heap.pop();
        }
    }

    void init() {
        cur = 0;
        for (; cur < k && cur < data.size(); cur++) {
            ++sz;
            if (cur == 0) {
                mid = cur;
                continue;
            }
            if (data[cur] <= data[mid]) {
                max_heap.push(cur);
            } else {
                min_heap.push(cur);
            }
            adjust();
        }
        _m = median();
    }

    double median() {
        if (sz % 2 == 0) {
            return (double)((long long)data[mid] + data[max_heap.top()]) / 2.0;
        }
        return data[mid];
    }

public:
    medianWindows(const vector<int> &data, int k) :
            data(data), min_heap(data), max_heap(data, greater_equal<int>{}), k(k),
            mid(-1), cur(0), sz(0) {
        init();
    }

    bool nextMedian(double &m) {
        if (cur >= data.size()) {
            m = -1;
            return false;
        }
        if (k == 1) {
           m = data[cur++];
           return true;
        }
        // push
        if (data[cur] <= data[mid]) {
            max_heap.push(cur);
        } else {
            min_heap.push(cur);
        }
        // pop
        int pre = cur - k;
        if (pre == mid) {
            mid = max_heap.top();
            max_heap.pop();
        } else {
            max_heap.hash_pop(pre);
            min_heap.hash_pop(pre);
        }
        adjust();
        m = median();
        cur++;
        return true;
    }

    vector<double> getMedian() {
        vector<double> res;
        res.push_back(_m);
        while (nextMedian(_m)) {
            res.push_back(_m);
        }
        return res;
    }
};

class Solution {
public:
    vector<double> medianSlidingWindow(vector<int> &nums, int k) {
        medianWindows nw(nums, k);
        vector<double> res = nw.getMedian();
        return res;
    }
};

测试

// 答案对照
class violateWindows {
private:
    const vector<int> &data;
    int cur;
    int k;
    double m{};

public:
    violateWindows(const vector<int> &data, int k) : data(data), cur(0), k(k) {}

    bool median() {
        vector<int> res;
        if (cur + k > data.size()) {
            return false;
        }
        for (int i = 0; i < k; i++) {
            res.push_back(data[cur + i]);
        }
        sort(res.begin(), res.end());
        int sz = res.size();
        if (sz % 2 == 0) {
            m = (double)((long long)res[sz / 2 - 1] + res[sz / 2]) / 2.0;
        } else {
            m = res[sz / 2];
        }
        cur++;
        return true;
    }

    vector<double> getMedian() {
        vector<double> res;
        while (median()) {
            res.push_back(m);
        }
        return res;
    }
};


vector<int> get_random_vec(int n, int limit) {
    vector<int> data(n);
    random_device rd{};
    mt19937 mt(rd());
    uniform_int_distribution<int> u(-limit, limit);
    for (int i = 0; i < n; i++) {
        data[i] = u(mt);
    }
    return data;
}

int main() {
    // 自定义读取输入  规定输入边界
    vector<int> data = get_random_vec(30000, 10000);
    int k = 301;
    medianWindows mw(data, k);

    violateWindows vw(data, k);

    auto res = mw.getMedian();

    auto res1 = vw.getMedian();
    cout << res.size() << endl;
    cout << res1.size() << endl;

    for (int i = 0; i < res.size(); i++) {
        if (res[i] != res1[i]) {
            cout << "mis match" << endl;
            exit(-1);
        }
    }
    cout << endl;
}
Silent_Blue_Sky
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 哈希
m0_61548909的博客
08-27 2720
在 C++98 中， STL 提供了底层为红黑树结构的一系列关联式容器，在查询时效率可达到 $log_2N$，即最差情况下需要比较红黑树的高度次，当树中的节点非常多时，查询效率也不理想。最好的查询是，进行很少的比较次数就能够将元素找到，因此在C++11 中， STL 又提供了 4 个unordered系列的关联式容器，这四个容器与红黑树结构的关联式容器使用方式基本类似，只是其底层结构不同，本文中只对unordered_map 和 unordered_set 进行介绍，unordered_multimap和
C++语言实现hash表详解及实例代码
01-20
C++语言实现hash表详解 概要：  hash表，有时候也被称为散列表。个人认为，hash表是介于链表和二叉树之间的一种中间结构。链表使用十分方便，但是数据查找十分麻烦；二叉树中的数据严格有序，但是这是以多一个指针...
leetcode之数据结构（哈希表，栈，队列，堆）总结（C++）
L_smartworld的博客
08-14 320
基础知识： 栈：FILO，先进后出https://blog.csdn.net/L_smartworld/article/details/105862717 队列：FIFO，先进先出https://blog.csdn.net/L_smartworld/article/details/105841702 哈希表：主要用于统计和查询https://blog.csdn.net/L_smartworld/article/details/105296110 1.自建数组作为哈希表...
哈希表、堆排序
鸟哥哥的专栏
12-11 1708
哈希表、堆排序详细介绍
leetcode347.前k个高频元素(哈希 堆)
weixin_45019830的博客
03-29 201
思路 题目最终需要返回的是前 k 个频率最大的元素，可以想到借助堆这种数据结构，对于 k频率之后的元素不用再去处理，进一步优化时间复杂度。 具体操作为： 借助 哈希表 来建立数字和其出现次数的映射，遍历一遍数组统计元素的频率 维护一个元素数目为 k的** 最小堆** 每次都将新的元素与堆顶元素（堆中频率最小的元素）进行比较 如果新的元素的频率比堆顶端的元素大，则弹出堆顶端的元素，将新的元素添加进堆中 最终，堆中的 k 个元素即为前 k个高频元素 时间复杂度 代码 class Solution { p
算法基础学习笔记——⑧堆\哈希表
VLOKL的博客
05-27 1231
算法基础学习笔记——⑧堆\哈希表
哈希表和堆的总结
SeeDoubleU的专栏
05-09 446
文章目录用哈希表和堆处理的问题代码注意事项时间复杂度分析题目汇总 用哈希表和堆处理的问题 查询、插入、删除的操作要远多于其余的操作的情况下使用哈希表。 在动态环境中需要快速获取最值的情况下使用堆。 代码注意事项 哈希表——insert:O(1)，find:O(1)，delete:O(1) closed hashing：一个位置只放一个元素，冲突的元素向后寻找空位放下。 （缺点：由于find时有些元素被当作寻找正确元素的桥梁，所以在元素删除时候不能直接置空，而改为标记为delete，依然充当桥梁，多
C++ 哈希表
最新发布
Han同学
02-26 1954
C++哈希表
【C++】哈希
在平淡的日子里寻找存在的价值
04-05 2773
哈希表的基本概念以及如何分别使用闭散列和开散列来模拟实现哈希表。
C++哈希表
qq_52145272的博客
07-03 6031
哈希表的实现
libsrt是一个C库，用于更快，更快速地编写安全的C代码。 它提供字符串，向量，位集，集，映射，哈希集和哈希映射处理。 适用于软和硬实时。 允许堆和栈分配。 * BETA *（API仍然可以更改：欢迎提出建议）-C/C++开发
05-26
:-) libsrt：C编程语言的安全实时库libsrt是一个C库，提供字符串，向量，位集，集，映射，哈希集和哈希映射处理。 它的设计旨在避免在使用动态大小的数据结构时避免显式的内存管理，从而实现安全且具有表现力
nsrllookup:与NSRL RDS服务器进行检查以查找哈希匹配项
05-08
数字取证对于针头和干草堆有很大的问题。 nsrllookup可以大大减少干草，因此更容易找到针头。 我可以为此获得预构建的x64 Windows二进制文件吗？ 它是如何工作的？ 美国国家标准技术研究院（NIST）维护着国家...
LeetCode:LeetCode 刷题笔记(C++, Python 实现)
04-12
哈希表 2个 加两个数字 链表 3 最长子串，无重复字符 细绳 4 两个排序数组的中位数 大批 5 最长回文子串 细绳 6 之字形转换 细绳 7 反整数 数学 8 字符串到整数 数学 9 回文数 数学 10 正则表达式匹配 细绳 ...
sse4_crc32:基于SSE4.2的硬件加速CRC32计算器，具有软件后备功能
05-17
32C计算轻松回退到基于软件的CRC-32C（基于表的CRC计算） 支持流，字符串和缓冲区表现测试是在运行Intel Core i7处理器的Macbook Air上运行的，该处理器具有16GB的RAM和使用的缓冲区而不是字符串，以防止V8堆上的...
c++ pipeline设计模式的实现
qq_34179431的博客
05-11 3400
pipeline 设计模式的实现， 有几个小问题暂时还懒得解决 getDownStream 每次都重新生成新的对象，可以优化下 pipeline 模式的核心是 downstream 可以方便提供， 目前写死了。 #include <string.h> #include <algorithm> #include <iostream> #include <map> #include <numeric> #include <queue>
c++ 通过函数获得数组的大小
qq_34179431的博客
11-05 2093
#include &lt;iostream&gt; using namespace std; // question ? 怎么样写一个函数返回数组的大小 // 思考： 1. 因为当把一个数组传入函数的时候， 传入的其实是一个首地址的指针， 所以一般方法不能实现 // 2. 但是注意到 c++ 虽然不能通过函数参数得到一个数组对象 ，但是 c++ 可以得到" 一个数组的引用...
c++ sort 函数comparator的注意事项
qq_34179431的博客
12-16 1643
comparator 的签名必须为 bool cmp(const Type1 &a, const Type2 &b) 对于相等的值用于返回 false 对于第二点可能有些难以理解，下面将进行详细解释 c++ sort 的实现非常厉害， 里面包括了插入排序， 堆排序，快排等等各种排序，在快排的实现上 template<typename _RandomAccessIterator, typename _Size> void __introsort_lo.
c++ split 函数
qq_34179431的博客
03-02 1316
split 函数用 string find 函数实现的 split1 用 strtok 函数实现的 void split(const string &s, vector<string> &tokens, const string &delimiters = " ") { string::size_type lastPos = s.find_first_not_of(delimiters, 0); string::size_type pos = s.find
c++数组写文件
qq_34179431的博客
07-26 1308
#include <iostream> #include <utility> #include <string> #include <cstring> #include <vector> #include <map> #include <set> #include <stack> #include <queue> #include <unordered_map> #include <
c++哈希表哈希冲突怎么办
07-28
哈希冲突是指不同的键值对在哈希表中计算出相同的哈希值，导致它们被映射到相同的索引位置。当发生哈希冲突时，可以...在C++中，STL库提供了unordered_map容器，它实现了哈希表，并且默认使用链表法来解决哈希冲突。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值