【杂乱算法】哈希

最新推荐文章于 2024-09-28 22:05:59 发布
最新推荐文章于 2024-09-28 22:05:59 发布
阅读量808 收藏 24
点赞数 17
分类专栏： 数组 杂乱笔记 文章标签： 哈希算法 算法 散列表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HeaoDng/article/details/141323383
版权

哈希

文章目录

基础定义

哈希函数（Hash Function）

哈希函数是将任意大小的数据映射到固定大小的数据（通常是一个整数）的函数。这个固定大小的数据称为哈希值或哈希码。一个好的哈希函数应该满足以下特性：

  1. 一致性：相同的输入总是产生相同的哈希值。
  2. 高效性：计算哈希值的过程应该快速。
  3. 均匀分布：哈希值应该尽可能均匀地分布在可能的哈希值范围内，以减少冲突。

哈希表（Hash Table）

哈希表是一种数据结构，它使用哈希函数将键（key）映射到数组中的一个位置，以便快速访问记录。哈希表通常支持以下操作：

  • 插入（Insert）：将一个键值对插入到哈希表中。
  • 查找（Search）：根据键查找对应的值。
  • 删除（Delete）：根据键删除对应的键值对。

哈希冲突（Hash Collision）

由于哈希函数的输出范围通常小于输入范围，不同的键可能会映射到同一个位置，这种现象称为哈希冲突。解决哈希冲突的常见方法有：

  1. 链地址法（Chaining）：每个数组位置存储一个链表，所有哈希到该位置的键值对都存储在这个链表中。

    #include <iostream>
#include <list>
#include <vector>

using namespace std;

class HashTable {
private:
    vector<list<int>> table;
    int size;

    int hashFunction(int key) {
        return key % size;
    }

public:
    HashTable(int s) : size(s) {
        table.resize(size);
    }

    void insert(int key) {
        int index = hashFunction(key);
        table[index].push_back(key);
    }

    void remove(int key) {
        int index = hashFunction(key);
        table[index].remove(key);
    }

    bool search(int key) {
        int index = hashFunction(key);
        for (int val : table[index]) {
            if (val == key) {
                return true;
            }
        }
        return false;
    }

    void display() {
        for (int i = 0; i < size; ++i) {
            cout << "Bucket " << i << ": ";
            for (int val : table[i]) {
                cout << val << " ";
            }
            cout << endl;
        }
    }
};

int main() {
    HashTable ht(7);

    ht.insert(10);
    ht.insert(20);
    ht.insert(15);
    ht.insert(7);

    ht.display();

    cout << "Search 15: " << (ht.search(15) ? "Found" : "Not Found") << endl;
    cout << "Search 5: " << (ht.search(5) ? "Found" : "Not Found") << endl;

    ht.remove(15);
    ht.display();

    return 0;
}

  2. 开放地址法（Open Addressing）：当发生冲突时，寻找哈希表中的下一个空闲位置来存储冲突的键值对。常见的开放地址法包括线性探测、二次探测和双重哈希。

    • 线性探测法：

      如果遇到冲突即向后移动，直至能插入为止。

      #include <iostream>
#include <vector>

using namespace std;

class HashTable {
private:
    vector<int> table;
    int size;
    int emptyValue;

    int hashFunction(int key) {
        return key % size;
    }

public:
    HashTable(int s, int emptyVal = -1) : size(s), emptyValue(emptyVal) {
        table.resize(size, emptyValue);
    }

    void insert(int key) {
        int index = hashFunction(key);
        while (table[index] != emptyValue) {
            index = (index + 1) % size;
        }
        table[index] = key;
    }

    void remove(int key) {
        int index = hashFunction(key);
        while (table[index] != emptyValue) {
            if (table[index] == key) {
                table[index] = emptyValue;
                return;
            }
            index = (index + 1) % size;
        }
    }

    bool search(int key) {
        int index = hashFunction(key);
        while (table[index] != emptyValue) {
            if (table[index] == key) {
                return true;
            }
            index = (index + 1) % size;
        }
        return false;
    }

    void display() {
        for (int i = 0; i < size; ++i) {
            if (table[i] != emptyValue) {
                cout << "Index " << i << ": " << table[i] << endl;
            } else {
                cout << "Index " << i << ": " << "Empty" << endl;
            }
        }
    }
};

int main() {
    HashTable ht(7);

    ht.insert(10);
    ht.insert(20);
    ht.insert(15);
    ht.insert(7);

    ht.display();

    cout << "Search 15: " << (ht.search(15) ? "Found" : "Not Found") << endl;
    cout << "Search 5: " << (ht.search(5) ? "Found" : "Not Found") << endl;

    ht.remove(15);
    ht.display();

    return 0;
}

    • 二次探测法：

      遇到冲突即采取平方的方式进行移动。

      #include <iostream>
#include <vector>

using namespace std;

class HashTable {
private:
    vector<int> table;
    int size;
    int emptyValue;

    int hashFunction(int key) {
        return key % size;
    }

public:
    HashTable(int s, int emptyVal = -1) : size(s), emptyValue(emptyVal) {
        table.resize(size, emptyValue);
    }

    void insert(int key) {
        int index = hashFunction(key);
        int i = 0;
        while (table[(index + i * i) % size] != emptyValue) {
            i++;
        }
        table[(index + i * i) % size] = key;
    }

    void remove(int key) {
        int index = hashFunction(key);
        int i = 0;
        while (table[(index + i * i) % size] != emptyValue) {
            if (table[(index + i * i) % size] == key) {
                table[(index + i * i) % size] = emptyValue;
                return;
            }
            i++;
        }
    }

    bool search(int key) {
        int index = hashFunction(key);
        int i = 0;
        while (table[(index + i * i) % size] != emptyValue) {
            if (table[(index + i * i) % size] == key) {
                return true;
            }
            i++;
        }
        return false;
    }

    void display() {
        for (int i = 0; i < size; ++i) {
            if (table[i] != emptyValue) {
                cout << "Index " << i << ": " << table[i] << endl;
            } else {
                cout << "Index " << i << ": " << "Empty" << endl;
            }
        }
    }
};

int main() {
    HashTable ht(7);

    ht.insert(10);
    ht.insert(20);
    ht.insert(15);
    ht.insert(7);

    ht.display();

    cout << "Search 15: " << (ht.search(15) ? "Found" : "Not Found") << endl;
    cout << "Search 5: " << (ht.search(5) ? "Found" : "Not Found") << endl;

    ht.remove(15);
    ht.display();

    return 0;
}

    • 双重哈希：

      采用两个哈希函数，一个函数计算初始哈希值，另外一个函数计算哈希步长，遇到冲突就在初始值上加哈希步长。

      #include <iostream>
#include <vector>

using namespace std;

class HashTable {
private:
    vector<int> table;
    int size;
    int emptyValue;

    int hashFunction1(int key) {
        return key % size;
    }

    int hashFunction2(int key) {
        return 1 + (key % (size - 1));
    }

public:
    HashTable(int s, int emptyVal = -1) : size(s), emptyValue(emptyVal) {
        table.resize(size, emptyValue);
    }

    void insert(int key) {
        int index = hashFunction1(key);
        int stepSize = hashFunction2(key);
        while (table[index] != emptyValue) {
            index = (index + stepSize) % size;
        }
        table[index] = key;
    }

    void remove(int key) {
        int index = hashFunction1(key);
        int stepSize = hashFunction2(key);
        while (table[index] != emptyValue) {
            if (table[index] == key) {
                table[index] = emptyValue;
                return;
            }
            index = (index + stepSize) % size;
        }
    }

    bool search(int key) {
        int index = hashFunction1(key);
        int stepSize = hashFunction2(key);
        while (table[index] != emptyValue) {
            if (table[index] == key) {
                return true;
            }
            index = (index + stepSize) % size;
        }
        return false;
    }

    void display() {
        for (int i = 0; i < size; ++i) {
            if (table[i] != emptyValue) {
                cout << "Index " << i << ": " << table[i] << endl;
            } else {
                cout << "Index " << i << ": " << "Empty" << endl;
            }
        }
    }
};

int main() {
    HashTable ht(7);

    ht.insert(10);
    ht.insert(20);
    ht.insert(15);
    ht.insert(7);

    ht.display();

    cout << "Search 15: " << (ht.search(15) ? "Found" : "Not Found") << endl;
    cout << "Search 5: " << (ht.search(5) ? "Found" : "Not Found") << endl;

    ht.remove(15);
    ht.display();

    return 0;
}

[!NOTE]

哈希只是一种算法，能实践哈希算法的载体有很多，但不变的都是数据映射，例如我们可以将数据映射在数组、map等等。

哈希的应用

1、重复查询（哈希集合）

  • 哈希集合 是 集合 数据结构的实现之一，用于存储 非重复值。
#include <iostream>
#include <unordered_set>

using namespace std;

int main() {
    // 创建一个无序集合
    unordered_set<int> elements;

    // 插入一些元素
    elements.insert(10);
    elements.insert(20);
    elements.insert(30);

    // 查询元素是否在集合中
    int queryElement = 20;
    if (elements.find(queryElement) != elements.end()) {
        cout << queryElement << " 在集合中。" << endl;
    } else {
        cout << queryElement << " 不在集合中。" << endl;
    }

    queryElement = 40;
    if (elements.find(queryElement) != elements.end()) {
        cout << queryElement << " 在集合中。" << endl;
    } else {
        cout << queryElement << " 不在集合中。" << endl;
    }

    return 0;
}
映射底层实现是否有序数值是否可以重复能否更改数值查询效率增删效率
map红黑树key有序key不可重复key不可修改O(log n)O(log n)
multimap红黑树key有序key可重复key不可修改O(log n)O(log n)
unordered_map哈希表key无序key不可重复key不可修改O(1)O(1)

  • 数独中的哈希判断是否符合

    重要公式：idx=(i/3)*3+(j/3);判断是位于哪个九宫格（下标从0开始）

    #include <iostream>
#include <vector>
#include <unordered_set>

using namespace std;

class Solution {
public:
    bool isValidSudoku(vector<vector<char>>& board) {
        vector<unordered_set<int>> row(9), col(9), area(9);

        for (int i = 0; i < 9; i++) {
            for (int j = 0; j < 9; j++) {
                char c = board[i][j];
                if (c == '.') continue;
                int u = c - '0';
                int idx = (i / 3) * 3 + (j / 3);

                if (row[i].count(u) || col[j].count(u) || area[idx].count(u)) 
                    return false;

                row[i].insert(u);
                col[j].insert(u);
                area[idx].insert(u);
            }
        }
        return true;
    }
};

int main() {
    Solution solution;
    vector<vector<char>> board = {
        {'5', '3', '.', '.', '7', '.', '.', '.', '.'},
        {'6', '.', '.', '1', '9', '5', '.', '.', '.'},
        {'.', '9', '8', '.', '.', '.', '.', '6', '.'},
        {'8', '.', '.', '.', '6', '.', '.', '.', '3'},
        {'4', '.', '.', '8', '.', '3', '.', '.', '1'},
        {'7', '.', '.', '.', '2', '.', '.', '.', '6'},
        {'.', '6', '.', '.', '.', '.', '2', '8', '.'},
        {'.', '.', '.', '4', '1', '9', '.', '.', '5'},
        {'.', '.', '.', '.', '8', '.', '.', '7', '9'}
    };

    if (solution.isValidSudoku(board)) {
        cout << "The Sudoku board is valid." << endl;
    } else {
        cout << "The Sudoku board is invalid." << endl;
    }

    return 0;
}

2、字符串哈希

采用两个大质数对哈希值进行取模能有效降低哈希碰撞。

typedef unsigned long long ull;
ull base = 131;
ull mod1 = 212370440130137957, mod2 = 1e9 + 7;

ull get_hash1(std::string s) {
  int len = s.size();
  ull ans = 0;
  for (int i = 0; i < len; i++) ans = (ans * base + (ull)s[i]) % mod1;
  return ans;
}

ull get_hash2(std::string s) {
  int len = s.size();
  ull ans = 0;
  for (int i = 0; i < len; i++) ans = (ans * base + (ull)s[i]) % mod2;
  return ans;
}

bool cmp(const std::string s, const std::string t) {
  bool f1 = get_hash1(s) != get_hash1(t);
  bool f2 = get_hash2(s) != get_hash2(t);
  return f1 || f2;
}
HeaoDng144
关注
专栏目录
查找算法之哈希查找
青萍之末的博客
06-11 7548
  哈希也称散列，哈希表是一种与数组、链表等不同的数据结构，与他们需要不断的遍历比较来查找的办法，哈希表设计了一个映射关系f(key)= address，根据key来计算存储地址address，这样可以1次查找，f既是存储数据过程中用来指引数据存储到什么位置的函数，也是将来查找这个位置的算法，叫做哈希算法。 1、相关名词 1. 桶：哈希表中存储数据的位置，每一个位置对应唯一的一个地址，桶就好...
哈希算法-Top K
Harris的博客
12-22 449
作者：July、wuliming、pkuoliver   出处：http://blog.csdn.net/v_JULY_v。   说明：本文分为三部分内容，     第一部分为一道百度面试题Top K算法的详解；第二部分为关于Hash表算法的详细阐述；第三部分为打造一个最快的Hash表算法。 ------------------------------------   第一部分
最快的哈希算法
热门推荐
u010456460的博客
01-19 1万+
作者：July、wuliming、pkuoliver 　　说明：本文分为三部分内容， 第一部分为一道百度面试题Top K算法的详解；第二部分为关于Hash表算法的详细阐述；第三部分为打造一个最快的Hash表算法。 　　第一部分：Top K 算法详解 　　问题描述（百度面试题）： 　　搜索引擎会通过日志文件把用户每次检索使用的所有检索串都记录下来，每个查询串的长度为1-255字节。假设目前有
【杂乱算法】前缀和与差分
HeaoDng的博客
08-19 373
、、
Hash查找算法
weichun1121的博客
04-01 649
哈希查找，也称为散列查找(本文以哈希称呼)。提起哈希，我的第一印象就是C#中的Hashtable类，它是由一组key/value的键值对组成的集合，它就是应用了散列技术。那么，什么是哈希查找呢？在弄清楚什么是哈希查找之前，我们要弄清楚哈希技术，哈希技术是在记录的存储位置和记录的关键字之间建立一个确定的对应关系f，使得每个关键字key对应一个存储位置f(key)。查找时，根据这个确定的对应关系找到给...
哈希表算法实现
吾尝终日而思矣，不如须臾之所学也
05-17 440
1、什么是Hash?Hash，一般翻译做“散列”，也有直接音译为“哈希”的，就是把任意长度的输入（又叫做预映射， pre-image），通过散列算法，变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，而不可能从散列值来唯一的确定输入值。简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。HASH
【数据结构与算法篇】 哈希表原理、底层实现剖析
m0_64231944的博客
09-19 3027
哈希表，哈希表原理，hash函数，散列函数，hash底层实现；
哈希Hash 算法
《我是你的正能量》
12-13 2236
注意文章详解（http://blog.csdn.net/v_july_v/article/details/6256463）哈希由来： 数组的特点是：寻址容易，插入和删除困难 链表的特点是：寻址困难，插入和删除容易 做出一种寻址容易，插入删除也容易哈希特点： 通过散列算法，变换成固定长度的输出; 散列值的空间通常远小于输入的空间， 不同的输入可能会散列成相同的输出， 而不可能从散列值来唯一的确定输
算法学习———哈希表（Java版）
Sencq的博客
11-06 742
哈希：又称散列，一般用于将一个分散的、杂乱的数据通过某个函数，映射到一个新的数据，而新数据往往更容易处理，比如新数据可能具有统一的长度，或者具有更小的范围，或者更紧凑，或者更方便比较等等，在java中体现为以下API： HashMap：键不重复，值可重复；允许key和value为空； HashTable：键不重复，值可重复；不允许key和value为空； HashSet：排列无序，不可重复；存取速度快；内部为HashMap； 根哈希算法的思想，最基
基于图像特征的图像哈希算法及实现
06-01
当我们改变相位信息时，图像就会变得杂乱 无章。一般来说，图像的相位信息对外界干扰具有很强的敏感性，由它所得哈希部分正 好可以弥补角点的缺陷，即角点对几何操作鲁棒性良好，而对 JPEG 压缩，滤波等操作
数据结构——哈希表（散列）原理与代码应用
流楚丶格念的博客
10-24 5352
文章目录什么是哈希表？Hash的应用Hash复杂度散列表的查找步骤散列函数（哈希函数）——散列地址哈希表优缺点优点：缺点：散列的三种方法1、除法散列法2、平方散列法3、斐波那契（Fibonacci）散列法散列冲突的解决方案：扩展代码应用 什么是哈希表？ 哈希表（Hash table，也叫散列表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。 记录的存储位置=f(关键
哈希（散列，Hash）算法总结-java版
许诗宇的博客
05-08 2331
目录 哈希算法简介 哈希算法的分类 加法Hash 位运算Hash 乘法Hash 除法Hash 查表Hash 混合Hash 常用的哈希算法 直接寻址法 数字分析法 平方取中法 折叠法 随机数法 除留余数法 流行的哈希算法 MD4 MD5 SHA及其他 碰撞性 哈希算法在java中的使用 Object Integer Long String Ha...
哈希表的工作原理
lingshengxiyou的博客
08-15 4880
Hash，一般翻译做“散列”，也有直接音译为“哈希”的，就是把任意长度的输入（又叫做预映射， pre-image），通过散列算法，变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，而不可能从散列值来唯一的确定输入值。简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。......
力扣 困难 154.寻找旋转排序数组中的最小值 II
qq_51352130的博客
09-23 422
153.寻找旋转排序数组中的最小值在此基础上，进行二分之前，单独处理一下左指针和最后一个数相同的情况就好了。left++;} else {
使用Python实现图形学的纹理映射算法
qq_42568323的博客
09-27 1063
纹理映射的基本概念是将二维图像（纹理）应用于三维模型的表面，以便在渲染时提供更多的细节和视觉效果。纹理坐标生成：为每个顶点生成对应的纹理坐标，通常使用归一化的二维坐标系统。纹理采样：根据生成的纹理坐标从纹理图像中获取颜色值。光照计算：结合光照模型，计算最终颜色，产生更真实的效果。图像合成：将计算得到的颜色与其他渲染信息合成，生成最终图像。纹理映射不仅可以用于简单的颜色填充，还可以模拟表面细节、光照变化等，提升渲染效果。
python 实现harmonic series调和级数算法
luthane的博客
09-24 941
Hn∑k1n1kHn​k1∑n​k1​其中，𝑛n 是正整数。这个级数是由调和数列（Harmonic sequence）的各元素相加所得的和。调和级数的名字源于泛音及泛音列，即一条振动的弦的泛音的波长依次是基本波长的12131421​31​41​等。调和级数的性质发散性：调和级数是一个发散的无穷级数，也就是说，它的部分和随着项数的增加而无限增长。
算法分类&自动驾驶主要算法介绍
joanna_xiao的博客
09-28 217
基础算法用于支持在设计程序和编写代码的过程中进行最基本的技术逻辑管理。常用的基础算法有快速排序算法、堆排序算法、归并排序、二分查找算法、BFPRT（线性查找算法）、DFS(深度优先搜索）、BFS(广度优先搜索）、Dijkstra算法、动态规划算法、朴素贝叶斯分类算法等。常见的行业算法如无人驾驶，AI医疗诊断，配送路径规划、工业检测、城市管理中的问题发展与预测、犯罪行为识别与预警等。常用的通用算法有视频处理、图像识别、目标检测、人流统计、行为识别、人脸识别、自然语言处理等。自动驾驶主要算法介绍。
算法宝典——二分查找算法
最新发布
2301_80689220的博客
09-28 97
初识算法之二分查找
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值