哈希表模块学习

最新推荐文章于 2024-10-31 17:28:42 发布
最新推荐文章于 2024-10-31 17:28:42 发布
阅读量1.2k 收藏 10
点赞数 18
文章标签： 学习 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45101231/article/details/139362618
版权

242. 有效的字母异位词

题目介绍：

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。

示例 1:

输入: s = "anagram", t = "nagaram"
输出: true

示例 2:

输入: s = "rat", t = "car"
输出: false

提示：
1 <= s.length, t.length <= 5 * 104
s 和 t 仅包含小写字母

思路：

哈希表主要用于快速查找某一元素是否存在，本题因为都是小写字母，故可以创建一个26位的数组record，随后先将字符串s包含的字母映射至数组（将s[i] - ‘a’ 即可），每个字母出现一次便加一，
再遍历字符串t，每个字母出现一次便减一。若最后数组内的元素都为0，则说明是字母异位词。
具体代码如下：

class Solution {
public:
    bool isAnagram(string s, string t) {
        int record[26] = {0} ;  //定义数组，记录字母出现的次数
        for( int i = 0 ; i < s.size() ; i++ ){
            //与‘a'相减得到ASCII码作为该字母的索引
            record[ s[i] - 'a' ]++ ;
        }
        for( int i = 0 ; i < t.size() ; i++ ){
            record[ t[i] - 'a' ]-- ; 
        }
        for(int i = 0 ; i <26 ; i++){
            //如果存在不为0的元素，说明一定存在一个字符串多了或者少了字符
            if( record[i] != 0 )    return false ; 
        }

        return true ; 
    }
};

383. 赎金信

题目介绍：

给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。
如果可以，返回 true ；否则返回 false 。
magazine 中的每个字符只能在 ransomNote 中使用一次。

示例 1:

输入：ransomNote = "a", magazine = "b"
输出：false

示例 2:

输入：ransomNote = "aa", magazine = "ab"
输出：false

示例 3:

输入：ransomNote = "aa", magazine = "aab"
输出：true

提示：
1 <= ransomNote.length, magazine.length <= 105
ransomNote 和 magazine 由小写英文字母组成

思路：

1、判断ransomNote 的长度是否大于magazine的长度
2、创建record数组，先记录magazine的所有字母及数量，字母每出现一次，数量加一
3、遍历ransomNote ，字母每出现一次数量减一
4、遍历数组是否存在小于0的元素，若小于0则表示magazine中缺少此字母
具体代码如下：

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        //如果 ransomNote 的长度大于magazine的长度直接返回false
        if(ransomNote.size() > magazine.size() )  return false ; 
        int record[26] = {0} ; 
        //记录magazine的所有字母及数量
        for( char mag : magazine ){
            ++record[ mag - 'a' ] ; 
        }
        
        for( char ran : ransomNote){
            --record[ ran - 'a' ] ;
        }
        //若有元素小于0，则代表magazine中缺少此字母
        for( int i =0 ; i < 26 ; i++ ){
            if( record[i] < 0 ) return false ;
        } 

        return true ;
    }   
};

49. 字母异位词分组

题目介绍：

给你一个字符串数组，请你将 字母异位词 组合在一起。可以按任意顺序返回结果列表。
字母异位词 是由重新排列源单词的所有字母得到的一个新单词。

示例 1:

输入: strs = ["eat", "tea", "tan", "ate", "nat", "bat"]
输出: [["bat"],["nat","tan"],["ate","eat","tea"]]

示例 2:

输入: strs = [""]
输出: [[""]]

示例 3:

输入: strs = ["a"]
输出: [["a"]]

提示：
1 <= strs.length <= 104
0 <= strs[i].length <= 100
strs[i] 仅包含小写字母

思路：

1、先创建mapStr用于记录字母及数量，其中key形式为字母+数量，如：a1b2f3，value为key对应的异位词集合
2、遍历strs，创建数组record记录下每个元素的字母及数量
3、遍历数组拼接出key，并存入mapStr中
4、遍历map，将所有map的value值传入result中
具体代码如下：

class Solution {
public:
    vector<vector<string>> groupAnagrams(vector<string>& strs) {
        unordered_map< string , vector<string> > mapStr ;   
        vector<vector<string> > result; 

        for( string str : strs )
        {
            int record[26] = {0} ; 
            //记录下str的字符，及其个数
            for(int i = 0 ; i < str.size() ; i++ ){
                record[ str[i] - 'a' ]++ ; 
            }
            string key = "" ; 
            for(int i = 0 ; i < 26 ; i++){
                //拼接出key
                if( record[i] != 0 ){
                    key += ( i + 'a' ) ;
                    key += to_string( record[i] ) ; 
                }
            }
            mapStr[ key ].push_back( str ) ;
        }
        
        for( auto &it : mapStr)
        {
            result.push_back( it.second ) ; 
        }

        return result ; 
    }
};

438. 找到字符串中所有字母异位词

题目介绍：

给定两个字符串 s 和 p，找到 s 中所有 p 的 异位词 的子串，返回这些子串的起始索引。不考虑答案输出的顺序。
异位词 指由相同字母重排列形成的字符串（包括相同的字符串）。

示例 1:

输入: s = "cbaebabacd", p = "abc"
输出: [0,6]
解释:
起始索引等于 0 的子串是 "cba", 它是 "abc" 的异位词。
起始索引等于 6 的子串是 "bac", 它是 "abc" 的异位词。

示例 2:

输入: s = "abab", p = "ab"
输出: [0,1,2]
解释:
起始索引等于 0 的子串是 "ab", 它是 "ab" 的异位词。
起始索引等于 1 的子串是 "ba", 它是 "ab" 的异位词。
起始索引等于 2 的子串是 "ab", 它是 "ab" 的异位词。

提示：
1 <= s.length, p.length <= 3 * 104
s 和 p 仅包含小写字母

思路：

方法一：
1、判断两个字符串长度，若字符串s的长度小于p的长度，返回空
2、创建vector容器countS ,countP，遍历字符串p，同时也从0开始，长度为p的长度遍历字符串s，获取p各个字母的出现次数，以及s的前lenP各个字母的出现次数
3、判断两个vector是否相等，相等则为异位词
4、建立从0开始，长度为lenP的滑动窗口，每次移动一位，向后移动lenS-lenP位，判断后续是否还存在异位词
具体代码如下：

class Solution {
public:
    vector<int> findAnagrams(string s, string p) {
        //滑动窗口
        //之所以是vector而不是普通数组是因为vector有内置函数，可以直接比较两个容器是否相等
        vector<int> countS(26) ; 
        vector<int> countP(26) ;
        
        int lenS = s.size() ; 
        int lenP = p.size() ; 
        vector<int> result ; 
        
        if( s.size() < p.size() )       return {} ;     //当字符串s的长度小于p的长度时，不存在子串
        //获取p各个字母的出现次数，以及s的前lenP各个字母的出现次数
        for( int i = 0 ; i < p.size() ; i++ )
        {
            ++countP[ p[i] - 'a' ] ;
            ++countS[ s[i] - 'a' ] ;
        }

        if( countP == countS )  result.push_back(0)  ;  //两个数组相等则表明为异位词

        for( int i = 0 ; i < lenS -lenP ; i++)
        {
            //滑动窗口向后移一位
            --countS[ s[i] - 'a' ] ;  
            ++countS[ s[i+lenP] - 'a'] ;
            
            if( countP == countS )  result.push_back( i+1 ) ;
        }

        return result ;
    }
};

方法二：
优化滑动窗口，不需要再每次比较两个数组是否相同，而是通过differ值（滑动窗口内字符串与p的不同字母或者相同字母数量不同的数量）来判断。
滑动窗口优化后具体代码如下：

class Solution {
public:
    vector<int> findAnagrams(string s, string p) {
        //滑动窗口优化
        vector<int> count(26) ; 

        int lenS = s.size() ; 
        int lenP = p.size() ; 
        vector<int> result ; 

        int differ = 0 ;  //滑动窗口内字符串与p的不同字母或者相同字母数量不同的数量
        
        if( s.size() < p.size() )       return {} ;     //当字符串s的长度小于p的长度时，不存在子串
        //获取p各个字母的出现次数，以及s的前lenP各个字母的出现次数
        for( int i = 0 ; i < p.size() ; i++ )
        {
            ++count[ s[i] - 'a' ] ;
            --count[ p[i] - 'a' ] ;
        }
        //判断两者differ值
        for( int i= 0 ; i < 26 ; i++ )
        {
            if( count[i] != 0 ) ++differ ; 
        }
        if( differ == 0 )  result.push_back(0) ;  //当differ等于0时，表示两个字符串为字母异位词

        for( int i = 0 ; i < lenS -lenP ; i++)
        {
            //移除窗口起始元素
            //表示本来窗口内本字母的数量与p相同，但因为窗口后移，此字母数量将变得不同，differ加一
            if( count[ s[i] - 'a'] == 0 )   ++differ ;  
             //表示本来窗口内本字母的数量与不同且正好多一个，但因为窗口后移，此字母数量将变得相同，differ减一
            if( count[ s[i] - 'a'] == 1 )   --differ ; 
            //窗口后移，此字母数量减一
            --count[ s[i] - 'a'] ; 
            
            //窗口新增元素
            //表示本来窗口内本字母的数量与p相同，但因为窗口新增了此字母，此字母数量将变得不同，differ加一
            if( count[ s[i+lenP] -'a' ] == 0 )  ++differ ;
            //表示本来窗口内本字母的数量与不同且正好少一个，但因为窗口新增此字母，此字母数量将变得相同，differ减一
            if( count[ s[i+lenP] -'a' ] == -1 ) --differ ;
            //窗口后移，此字母数量加一
            ++count[ s[i+lenP] -'a' ] ;

            if(differ == 0 )  result.push_back(i+1) ; 
        }

        return result ;
    }
};

349. 两个数组的交集

题目介绍：

给定两个数组 nums1 和 nums2 ，返回 它们的交集。
输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。

示例 1:

输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2]

示例 2:

输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出：[9,4]
解释：[4,9] 也是可通过的

提示：
1 <= nums1.length, nums2.length <= 1000
0 <= nums1[i], nums2[i] <= 1000

思路：

1、创建unordered_set保存nums1的所有元素
2、遍历nums2，每遍历一个元素便判断set中是否包含此元素，若包含则是交集
具体代码如下：

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result ;        //用于存储结果
        unordered_set<int> nums( nums1.begin() , nums1.end() ) ;    //使用nums记录下num1所有不重复的元素

        for( int num : nums2 )
        {
            //若nums中存在此元素，说明此元素是两者的交集
            if( nums.find(num) != nums.end() )     result.insert( num ) ;
        } 
        //转换为vector类型输出
        return vector<int>(result.begin() , result.end() ) ;
    }
};

202. 快乐数

题目介绍：

编写一个算法来判断一个数 n 是不是快乐数。
「快乐数」 定义为：
对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。
如果这个过程 结果为 1，那么这个数就是快乐数。
如果 n 是 快乐数 就返回 true ；不是，则返回 false 。

示例 1:

输入：n = 19
输出：true
解释：
12 + 92 = 82
82 + 22 = 68
62 + 82 = 100
12 + 02 + 02 = 1

示例 2:

输入：n = 2
输出：false

提示：
1 <= n <= 231 - 1

思路：

1、先写一个方法获取每个数的平方之和
2、创建set来记录每次出现的平方之和
3、建立一个死循环，在循环内不断获取各位数的平方之和，直至出现和为1的情况或者出现set中已经记录的数字
具体代码如下：

class Solution {
public:
    int getSum( int n ){
        int sum =0 ; 
        while( n ){
            sum +=  (n%10) * (n%10) ; 
            n = n/10 ;
        }
        return sum ;
    }

    bool isHappy(int n) {
        unordered_set<int> set  ;   //用于保存已经出现过的数
        while(1){
            int sum = getSum(n) ;   //获取各位数平方和
            if(sum == 1 )   return true ;   //若sum为1说明是快乐数，返回true
            if( set.find(sum) != set.end() )    return false ;      //若set中已经存在此数了，说明已经陷入了死循环，不是快乐数
            else set.insert(sum ) ;     //若set中不包含此数，将其添加
            n = sum ; 
        }
    }
};

1. 两数之和

题目介绍：

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。

示例 1:

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

示例 2:

输入：nums = [3,2,4], target = 6
输出：[1,2]

示例 3:

输入：nums = [3,3], target = 6
输出：[0,1]

提示：
2 <= nums.length <= 104
-109 <= nums[i] <= 109
-109 <= target <= 109
只会存在一个有效答案

思路：

1、创建map记录已经遍历过的数字，key为nums中的元素，value为该元素的下标
2、遍历nums，每遍历一个元素便判断map中是否包含target-nums[i]，若存在则返回结果，不存在则向map中添加本次遍历的元素
具体代码如下：

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int ,int> map ;   //创建map记录已经遍历过的数字，key为nums中的元素，value为该元素的下标
        for( int i = 0 ; i < nums.size() ; i++ ){
            auto it = map.find( target - nums[i] ) ; 
            if( it != map.end() )   return { it->second , i } ; //若map中包含另一个数，返回i以及该数的下标
            else map[ nums[i] ] = i ;   //若map中不包含该数，将其添加
        }
        return {} ;
    }
};

454. 四数相加 II

题目介绍：

给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足：
0 <= i, j, k, l < n
nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0

示例 1:

输入：nums1 = [1,2], nums2 = [-2,-1], nums3 = [-1,2], nums4 = [0,2]
输出：2
解释：
两个元组如下：
1. (0, 0, 0, 1) -> nums1[0] + nums2[0] + nums3[0] + nums4[1] = 1 + (-2) + (-1) + 2 = 0
2. (1, 1, 0, 0) -> nums1[1] + nums2[1] + nums3[0] + nums4[0] = 2 + (-1) + (-1) + 0 = 0

示例 2:

输入：nums1 = [0], nums2 = [0], nums3 = [0], nums4 = [0]
输出：1

提示：
n == nums1.length
n == nums2.length
n == nums3.length
n == nums4.length
1 <= n <= 200
-228 <= nums1[i], nums2[i], nums3[i], nums4[i] <= 228

思路：

1、创建map记录nums1+nums2所有的结果，key为和，value为出现过的次数
2、遍历nums1、nums2，记录所有的nums1 + nums2的结果
3、遍历nums3+nums4 ，若umap中存在 0-c-d 这个数，count加该数出现过的次数
具体代码如下：

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        unordered_map<int , int>  umap ; //记录nums1+nums2所有的结果，key为和，value为出现过的次数
        int count = 0  ;    
        //记录所有的nums1 + nums2的结果
        for( int a : nums1){
            for( int b : nums2 ){
                ++umap[ a+b ] ;
            }
        }
        //遍历nums3+nums4
        for( int c : nums3 ){
            for( int d : nums4 ){
                //若umap中存在 0-c-d 这个数，count加该数出现过的次数
                if( umap.find( 0-c-d ) != umap.end() )  count += umap[0-c-d] ; 
            }
        }

        return count ; 
    }
};

15. 三数之和

题目介绍：

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请
你返回所有和为 0 且不重复的三元组。
注意：答案中不可以包含重复的三元组。

示例 1:

输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]
解释：
nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 。
nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 。
nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。
不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。
注意，输出的顺序和三元组的顺序并不重要。

示例 2:

输入：nums = [0,1,1]
输出：[]
解释：唯一可能的三元组和不为 0 。

示例 3:

输入：nums = [0,0,0]
输出：[[0,0,0]]
解释：唯一可能的三元组和为 0 。

提示：
3 <= nums.length <= 3000
-10^5 <= nums[i] <= 10^5

思路：

1、先对nums进行排序
2、遍历nums，判断nums[i] > 0 ，如果第一个元素就大于0，则等式不存在，直接返回空，并对a去重
3、创建左右指针，左指针为i+1，右指针指向nums.size()-1 ， 而后便是双指针的循环，left<right。
4、还需注意对b和c进行去重
具体代码如下：

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        //双指针
        vector<vector<int>> result; 
        sort(nums.begin() , nums.end() ) ;     //先将其排序
        //寻找a+b+c = 0 
        for(int i = 0 ; i < nums.size() ; i++ )
        {
            if( nums[i] > 0 )   return result ; //如果第一个元素就大于0，则等式不存在，返回空
            if( i > 0 && nums[i] == nums[i-1] ) continue ;  //对a去重
            int left = i+1  , right = nums.size() - 1 ; 

            while( left < right )
            {
                //若三数之和大于0，right左移
                if( nums[i] + nums[left] + nums[right] > 0 )    right-- ;
                //若三数之和小于0，left右移
                else if( nums[i] + nums[left] + nums[right] < 0 )  left++ ; 
                else{
                    result.push_back( {nums[i] , nums[left] , nums[right] })    ;
                    //对c去重
                    while (right > left && nums[right] == nums[right - 1]) right--;
                    //对b去重
                    while (right > left && nums[left] == nums[left + 1]) left++;
                    //找到第一组结果，左右指针继续移动
                    right-- ; 
                    left++  ;
                }
            }  
        }
        return result ;
    }
};

18. 四数之和

题目介绍：

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：
0 <= a, b, c, d < n
a、b、c 和 d 互不相同
nums[a] + nums[b] + nums[c] + nums[d] == target
你可以按 任意顺序 返回答案 。

示例 1:

输入：nums = [1,0,-1,0,-2,2], target = 0
输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]

示例 2:

输入：nums = [2,2,2,2,2], target = 8
输出：[[2,2,2,2]]

提示：
1 <= nums.length <= 200
-109 <= nums[i] <= 109
-109 <= target <= 109

思路：

与上题三数之和的思路以及方法都是一样的，只是在剪纸去重时更为复杂，需要注意。
具体代码如下：

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int> >  result ; 
        sort(nums.begin() , nums.end()) ; 
        for( int i = 0 ; i < nums.size() ; i++)
        {
             //若第一个元素就大于target，直接退出此层循环，记得一定要加上条件nums[i] >=0
            if( nums[i] > target && nums[i] >= 0 )  break ;    
            if( i > 0 && nums[i] == nums[i-1] )  continue ; //对a去重
            for( int j = i +1 ; j < nums.size() ; j++ )
            {
                //若两个元素相加就大于target，直接退出此层循环，记得一定要加上条件nums[i] + nums[j] >= 0
                if( nums[i] + nums[j] > target && nums[i] + nums[j] >= 0 )    break ; 
                //对b去重
                if( j > i + 1  && nums[j] == nums[j-1] )   continue ;
                int left = j +1  , right = nums.size() - 1 ;
                while( left < right ){
                    //记得转成long类型，否则会溢出
                    //当和大于target时，右指针左移
                    if( (long)nums[i] + nums[j] + nums[left] + nums[right] > target )     right-- ;
                    //当和小于target时，左指针右移
                    else if( (long)nums[i] + nums[j] + nums[left] + nums[right] < target )    left++ ; 
                    else{
                        result.push_back( { nums[i] , nums[j] , nums[left] , nums[right] }) ;
                        //去重
                        while( right > left && nums[right] == nums[right-1] ) right-- ;     
                        while( right > left && nums[left] == nums[left+1] ) left++ ;
                        //得到一组结果后，左右指针移动
                        right-- ;
                        left++ ; 
                    }
                }
            }
        }
        return result ; 
    }
};
Duang呀
关注
并行哈希表的设计与实现：性能优化与分布式扩展
一键难忘的博客
09-17 3514
本文深入探讨了并行哈希表的设计与实现，结合了多线程编程、锁机制、扩展性、动态调整等关键技术，展示了并行哈希表在大规模数据处理、分布式缓存系统、实时数据流处理、机器学习等领域的广泛应用。通过代码示例，详细说明了如何在实际项目中实现和优化并行哈希表，特别是在处理高并发、数据一致性和扩展性方面的挑战。文章还展望了并行哈希表的未来发展方向，包括硬件加速、无锁数据结构、分布式环境中的容错与一致性，以及自动调优机制。随着硬件技术和编程技术的不断进步，并行哈希表将继续在高性能计算和大规模数据处理领域发挥重要作用。
Python 哈希表的实现与应用
酱橙的博客
09-27 5601
介绍 哈希表一个通过哈希函数来计算数据存储位置的数据结构，通常支持如下操作： insert（key，value）：插入键值对（key，value）。 get（key）： 如果存在键为key的键值对则返回其value，否则返回空值。 delete（key）： 删除键为key的键值对。 在 Python 当中最具代表的数据结构就是 字典 和 集合，底层所使用的都是哈希表这一数据结构。 直接寻址表 在学习哈希表之前，我们先了解直接寻址表的概念。 假如我们当前定义了一个集合 U，这个集合 U 里面包含了所有的
【项目总结】基于哈希表的用户管理系统_模块化&分层思想
weixin_42224114的博客
05-08 1659
项目练习： 1. 哈希表操作 2. 分层、模块化练习
哈希表详解
weixin_36194037的博客
03-05 2331
哈希表： 在前面所学习的线性表和树中，记录在结构中的相对位置是随机的，即存储结构和记录之间不存在确定的关系。因此，在结构中查找某一个记录需要进行一系列和关键字的比较，这类查找方法建立在比较的基础上，查找的效率取决于查找过程中所进行的比较次数。而理想的情况是，需要查找某一个元素记录时，能够根据关键字和存储位置之间的某一种关确定关系直接找到这个存储位置，不需要通过比较，快速高效。这就是我们所要学...
[终篇] 基于哈希表的机器学习特征哈希003
NUDTer的博客
07-09 871
本节利用前两节学习的内容并学习更深的内容（如局部敏感哈希LSH）用以项目的完成。
哈希表（js实现）
weixin_53781355的博客
01-28 3062
一.应用场景 几乎所有的编程语言直接或者简介应用到哈希表这种数据结构，所以哈希表是一种非常重要的数据结构 1.1.引入哈希表的概念 通过前面的学习，数组在增删改查中有非常多的优缺点，但hash表是通过数组实现的，但是hash表和数组相比有非常多的优缺点 1.hash表的删 查找 插入都非常快，无论多少数据，插入和删除的需要接近常量的是时间：o(1)的时间 3.hash表的缺点也比较显著，第一点hash表的内部存储是无序的，而且不能存储同一key值 1.2.在以下二种应用场景...
17_哈希表冲突处理
刘炫320的博客
09-11 412
老鸟：首先，我们来看一下哈希表冲突处理的两种主要方法：开放地址法和链地址法。我们先从链地址法开始。菜鸟：链地址法？是什么意思？老鸟：简单来说，链地址法是为每个哈希表槽位维护一个链表（或其他数据结构），所有映射到同一槽位的元素都存储在这个链表中。老鸟：总结一下，哈希表冲突处理主要有链地址法和开放地址法。链地址法使用链表存储冲突元素，而开放地址法则在哈希表内寻找新的空槽位。每种方法有其优缺点，适用于不同的场景。菜鸟你能推荐一些延伸阅读的资源吗？老鸟：当然可以。《算法导论》——哈希表章节。
图文结合、利于理解的数据结构学习笔记（5）——映射、集合、哈希表和跳跃表
CUE的博客
05-15 1597
机械工业出版社《数据结构与算法——Python语言实现》学习笔记。 画图工具：draw.io（见附件） 映射、哈希表和跳跃表1 映射和字典1.1 映射的 ADT2 哈希表2.1 哈希函数2.2 哈希码2.2.1 将位作为整数处理2.2.2 多项式哈希码2.2.3 循环移位哈希码2.2.4 Python中的哈希码2.3 压缩函数2.3.1 划分方法2.3.2 MAD方法2.4 冲突解决方案2.4.1 分离链表2.4.2 开放寻址2.4.2.1 线性探测2.4.2.2 二次探测2.4.2.3 双哈希策略2.4.
数据结构与算法：哈希表
weixin_73234157的博客
04-08 900
值得注意的是，这里的删除我们只是修改了“状态”和减少了“key”的个数，这个位置上的数据并没有删去，再结合“增”中的逻辑：不为空就可以插入，那么这里的删除只是为了将状态从存在转为删除，是一种伪删除，目的是通过插入来实现覆盖式的插入。我们在上面讲过我们需要控制哈希表中 “空” 位置的数量，一般来说我们通过负载因子来实现，随着数据的插入，num的就会增加，随之空位置数目就减少，负载因子增加，所以哈希表会设定一个负载因子的最大值，当超过这个值时，哈希表会进行扩容！那么到了这里哈希桶我们也实现了！
【C++】模拟实现hash_table(哈希表)
C/C++领域,数据结构,linux,MySQl学习者
10-08 1185
使用C++语言模拟实现开链法哈希表,包括实现HashNode类模板,实现hashTable构造函数,析构函数,插入函数,查找函数,删除等函数详解.
易语言-哈希表模块源码和例程
06-29
通过对“易语言闪电哈希表模块源码”的深入学习和实践，开发者不仅可以掌握哈希表的基本原理和操作，还能提升易语言编程技能，为编写高效的数据处理程序打下坚实的基础。同时，源码的阅读和分析也能培养程序员的代码...
易语言源码闪电哈希表模块源码.rar
07-14
《易语言源码闪电哈希表模块》是一个针对易语言编程环境设计的高效数据结构实现。易语言，作为中国本土的编程语言，以其简洁的语法和面向初学者的友好特性而受到广泛欢迎。闪电哈希表是其中一种优化的数据存储方式，...
易语言例程源码,易语言闪电哈希表模块
08-16
学习和使用易语言的闪电哈希表模块，不仅可以提升易语言编程的技能，还能深入理解哈希表这一数据结构的实现原理，这对于任何编程工作，尤其是涉及大数据处理和高性能计算的领域，都是极其有价值的。在实践中，开发者...
易语言闪电哈希表模块源码.zip易语言项目例子源码下载
03-24
在这个“易语言闪电哈希表模块源码.zip”压缩包中，包含了易语言项目的源代码，是学习和实践易语言编程的好资料。哈希表（Hash Table），又称为散列表，是数据结构中的一个重要概念，它提供了一种快速存取数据的方法...
易语言闪电哈希表模块源码-易语言
06-13
本压缩包包含的“闪电哈希表模块源码”是易语言中的一种高效数据结构实现，特别适用于需要快速查找、插入和删除数据的场景。 哈希表，又称散列表，是一种基于键值对存储的数据结构，通过哈希函数将键转化为存储位置...
地磁传感器（学习笔记下）
Gaorui678的博客
10-26 483
读到后的值，最终传入t_sQMC5883L定义的结构体,注意一下这里面的mag_reg数据变量，定义的时候是16位的3个元素，在读寄存器的时候，强制为8位指针变量，读6个字节。然后我们再写一个计算方位角的函数，使用磁力值计算方位角，最简单的方式，只需要一个公式。咱们接着学习笔记上来学习哈，首先，我们编写读取方位角程序，配置好传感器以后，我们就可以读取磁力值了，我们先定义一个结构体类型，用来存放磁力值以及方位角值。在主函数中，qmc5883l初始化以后，每间隔1秒钟计算1次方位角值，然后通过串口发送到终端。
Flink CDC系列之：学习理解standalone模式
zhengzaifeidelushang的博客
10-28 644
独立模式是 Flink 最简单的部署模式。本简短指南将向您展示如何下载、安装和运行 Flink 的最新稳定版本。您还将运行一个示例 Flink CDC 作业并在 Web UI 中查看它。
人工智能入门要学习多久？
最新发布
cd_farsight的博客
10-31 149
人工智能是一个快速发展的领域，新的技术和算法不断涌现。这可能需要你定期投入时间，比如每月至少花费几个小时来跟踪最新的研究和发展。如果你是计算机科学或相关专业的学生，或者对计算机科学有较深的兴趣，可能能更快地掌握。实践项目的时间可以因项目的复杂性和范围而异，通常需要几个月的时间来完成。学习人工智能所需的时间可以根据个人的学习速度、目标和深度有所不同。这通常需要几个月的时间，具体取决于个人的数学背景。：Python是进行人工智能学习的主要语言，建议从基础开始学习，这也是一个月左右的时间可以掌握。
【我的 PWN 学习手札】setcontext + ROP
Mr_Fmnwon的博客
10-28 800
setcontext的gadget能够“恢复上下文”，即设置寄存器的值。除了可以利用其执行shellcode，还可以实现ROP来getshell。本篇介绍了利用setcontext+ROP的方法，ORW地打印flag信息。
易语言闪电哈希表模块：完整源码及例程解析
通过学习和使用本资源中的哈希表模块源码和例程，易语言的开发者将能够更加高效地处理键值对数据，从而构建出响应速度快、运行效率高的应用程序。这不仅能够提高开发效率，还能够提升最终用户的应用体验。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值