LeetCode：哈希表（11道经典题目）

已于 2022-11-01 09:01:33 修改
阅读量3.5k 收藏 22
点赞数 6
分类专栏： # LeetCode 文章标签： 算法 c++
于 2022-03-23 15:43:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37085158/article/details/123687623
版权

LeetCode：哈希表（11道经典题目）

本文带来的是以哈希表为主题的一些经典题目，主要实现是C++和Python。

哈希表是根据关键码的值而直接进行访问的数据结构。数组就是一张哈希表。哈希表中关键码就是数组的索引下表，然后通过下表直接访问数组中的元素。

一般哈希表都是用来快速判断一个元素是否出现集合里。

当我们想使用哈希法来解决问题的时候，我们一般会选择如下三种数据结构。

  • 数组
  • set(集合)
  • map(映射)

在C++中，set 和 map 分别提供以下三种数据结构，其底层实现以及优劣如下表所示：

集合底层实现是否有序数值是否可以重复能否更改数值查询效率增删效率
std::set红黑树有序否否 O ( log ⁡ n ) O(\log n) O(logn) O ( log ⁡ n ) O(\log n) O(logn)
std::multiset红黑树有序是否 O ( log ⁡ n ) O(\log n) O(logn) O ( log ⁡ n ) O(\log n) O(logn)
std::unordered_set哈希表无序否否 O ( 1 ) O(1) O(1) O ( 1 ) O(1) O(1)

std::unordered_set底层实现为哈希表，std::set 和std::multiset 的底层实现是红黑树，红黑树是一种平衡二叉搜索树，所以key值是有序的，但key不可以修改，改动key值会导致整棵树的错乱，所以只能删除和增加。

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

std::unordered_map 底层实现为哈希表，std::map 和std::multimap 的底层实现是红黑树。同理，std::map 和std::multimap 的key也是有序的。

当我们要使用集合来解决哈希问题的时候，优先使用unordered_set，因为它的查询和增删效率是最优的，如果需要集合是有序的，那么就用set，如果要求不仅有序还要有重复数据的话，那么就用multiset。

当我们遇到了要快速判断一个元素是否出现集合里的时候，就要考虑哈希法。但是哈希法也是牺牲了空间换取了时间，因为我们要使用额外的数组，set或者是map来存放数据，才能实现快速的查找。

如果在做面试题目的时候遇到需要判断一个元素是否出现过的场景也应该第一时间想到哈希法！

242. 有效的字母异位词

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

C++：

class Solution {
public:
    bool isAnagram(string s, string t) {
        int record[26] = { 0 };
        for (char i : s) {
            record[i - 'a']++;
        }
        for (char j : t) {
            record[j - 'a']--;
        }
        for (int k : record) {
            if (k != 0) {
                return false;
            }
        }
        return true;
    }
};

Python：

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        chord = [0] * 26
        for s_ in s:
            chord[ord(s_) - ord('a')] += 1
        for t_ in t:
            chord[ord(t_) - ord('a')] -= 1
        for i in chord:
            if i != 0:
                return False
        return True

Python里面， ord()返回值是对应的十进制整数

defaultdict用法：

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        from collections import defaultdict

        s_dict = defaultdict(int)
        t_dict = defaultdict(int)

        for x in s: s_dict[x] += 1
        for y in t: t_dict[y] += 1

        return s_dict == t_dict

383. 赎金信

给定一个赎金信 (ransom) 字符串和一个杂志(magazine)字符串，判断第一个字符串 ransom 能不能由第二个字符串 magazines 里面的字符构成。如果可以构成，返回 true ；否则返回 false。
(题目说明：为了不暴露赎金信字迹，要从杂志上搜索各个需要的字母，组成单词来表达意思。杂志字符串中的每个字符只能在赎金信字符串中使用一次。)

C++：

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        int chord[26] = { 0 };
        for (char r : ransomNote) {
            chord[r - 'a']++;
        }
        for (char m : magazine) {
            chord[m - 'a']--;
        }
        for (int i : chord) {
            if (i > 0) {
                return false;
            }
        }
        return true;
    }
};

Python：

class Solution:
    def canConstruct(self, ransomNote: str, magazine: str) -> bool:
        r_chord, m_chord = [0] * 26, [0] * 26
        for s_ in ransomNote:
            r_chord[ord(s_) - ord('a')] += 1
        for t_ in magazine:
            m_chord[ord(t_) - ord('a')] += 1
        for i in range(26):
            if r_chord[i] > m_chord[i]:
                return False
        return True
    
    
class Solution:
    def canConstruct(self, ransomNote: str, magazine: str) -> bool:
        from collections import defaultdict

        hashmap = defaultdict(int)
        for i in magazine:
            hashmap[i] += 1

        for x in ransomNote:
            value = hashmap.get(x)
            if value is None or value == 0:
                return False
            else:
                hashmap[x] -= 1
        return True

49. 字母异位词分组

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

由于互为字母异位词的两个字符串包含的字母相同，因此对两个字符串分别进行排序之后得到的字符串一定是相同的，故可以将排序之后的字符串作为哈希表的键。

class Solution {
public:
	vector<vector<string>> groupAnagrams(vector<string>& strs) {
		unordered_map<string, vector<string>> map;
		for (auto s : strs) {
			string key = s;
			sort(key.begin(), key.end());
			map[key].push_back(s);
		}
		vector<vector<string>> ans;
		for (auto it = map.begin(); it != map.end(); it++) {
			ans.push_back(it->second);
		}
		return ans;
	}
};

由于互为字母异位词的两个字符串包含的字母相同，因此两个字符串中的相同字母出现的次数一定是相同的，故可以将每个字母出现的次数使用字符串表示，作为哈希表的键。由于字符串只包含小写字母，因此对于每个字符串，可以使用长度为 26 的数组记录每个字母出现的次数。

class Solution:
    def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
        mp = collections.defaultdict(list)

        for st in strs:
            counts = [0] * 26
            for ch in st:
                counts[ord(ch) - ord('a')] += 1
            
            mp[tuple(counts)].append(st)
        
        return list(mp.values())

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

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

滑动窗口+双指针+哈希表

C++：

class Solution {
public:
	vector<int> findAnagrams1(string s, string p) {
		if (p.size() > s.size()) return {};
		vector<int> need(26);
		vector<int> chord(26);
		vector<int> ret;
		for (char i : p) {
			need[i - 'a']++;
		}
		int left = 0, right = 0;
		while (right < s.size()) {
			chord[s[right] - 'a']++;
			if (right - left + 1 == p.size()) {
				if (chord == need) {
					ret.push_back(left);
				}
				chord[s[left] - 'a']--;
				left++;
			}
			right++;
		}
		return ret;
	}

	vector<int> findAnagrams(string s, string p) {
		int sLen = s.size(), pLen = p.size();
		if (sLen < pLen) return {};
		vector<int> chord(26);
		for (char i : p) {
			chord[i - 'a']++;
		}
		vector<int> ret;
		for (int left = 0, right = 0; right < sLen; right++) {
			chord[s[right] - 'a']--;
			while (chord[s[right] - 'a'] < 0) { // 如果小于0就收缩左侧边界直到不再小于0
				chord[s[left] - 'a']++;
				left++;
			}
			if (right - left + 1 == pLen) {
				ret.push_back(left);
			}
		}
		return ret;
	}
};

Python：

class Solution:
    def findAnagrams(self, s: str, p: str) -> List[int]:
        low, fast = 0, 0
        ret = []
        window, need = [0] * 26, [0] * 26
        for i in p:
            need[ord(i) - ord('a')] += 1

        while fast < len(s):
            window[ord(s[fast]) - ord('a')] += 1
            if fast - low + 1 == len(p):
                if need == window:
                    ret.append(low)
                window[ord(s[low]) - ord('a')] -= 1
                low += 1
            fast += 1
        return ret

349. 两个数组的交集

给定两个数组，编写一个函数来计算它们的交集。

使用 unordered_set：

class Solution {
public:
	vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
		unordered_set<int> result_set;
		unordered_set<int> num_set(nums1.begin(), nums1.end());
		for (int n : nums2) {
			if (num_set.find(n) != num_set.end()) {
				result_set.insert(n);
			}
		}
		return vector<int>(result_set.begin(), result_set.end());
	}
};

Python：利用集合set()

  • set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。
  • x & y 交集
  • x | y 并集
class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        num1, num2 = set(nums1), set(nums2)
        ret = []
        for i in num1:
            if i in num2:
                ret.append(i)
        return list(set(ret))

    
class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        return list(set(nums1) & set(nums2))  # 求交集

350. 两个数组的交集 II

给定两个数组，编写一个函数来计算它们的交集。(输出结果中每个元素出现的次数，应与元素在两个数组中出现次数的最小值一致。我们可以不考虑输出结果的顺序。)

  • 由于同一个数字在两个数组中都可能出现多次，因此需要用哈希表存储每个数字出现的次数。对于一个数字，其在交集中出现的次数等于该数字在两个数组中出现次数的最小值。
  • 首先遍历第一个数组，并在哈希表中记录第一个数组中的每个数字以及对应出现的次数，然后遍历第二个数组，对于第二个数组中的每个数字，如果在哈希表中存在这个数字，则将该数字添加到答案，并减少哈希表中该数字出现的次数。
  • 为了降低空间复杂度，首先遍历较短的数组并在哈希表中记录每个数字以及对应出现的次数，然后遍历较长的数组得到交集。
class Solution:
    def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]:
        from collections import Counter

        if len(nums1) > len(nums2):
            nums1, nums2 = nums2, nums1
        m = Counter()
        for num in nums1: m[num] += 1

        ret = []
        for num in nums2:
            if m.get(num, 0) > 0:  # 如果dict中没有num,则取i的value为0
                ret.append(num)
                m[num] -= 1
                if m[num] == 0:
                    m.pop(num)
        return ret

class Solution {
public:
	vector<int> intersect1(vector<int>& nums1, vector<int>& nums2) {
		if (nums1.size() > nums2.size()) {
			return intersect(nums2, nums1);
		}
		unordered_map<int, int> m;
		for (int num : nums1) m[num]++;

		vector<int> ret;
		for (int num : nums2) {
			if (m.count(num)) { // count(k)：如果k存在返回1，不存在返回0
				ret.push_back(num);
				m[num]--;
				if (m[num] == 0) {
					m.erase(num);
				}
			}
		}
		return ret;
	}
};

如果两个数组是有序的，则可以使用双指针的方法得到两个数组的交集。首先对两个数组进行排序，然后使用两个指针遍历两个数组。

  • 初始时，两个指针分别指向两个数组的头部。每次比较两个指针指向的两个数组中的数字，如果两个数字不相等，则将指向较小数字的指针右移一位，如果两个数字相等，将该数字添加到答案，并将两个指针都右移一位。当至少有一个指针超出数组范围时，遍历结束。

如果是进阶问题一中已排序的数组，则只需 O(n) 的时间复杂度。

class Solution:
    def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]:
        nums1 = sorted(nums1)
        nums2 = sorted(nums2)
        ret = []
        left, right = 0, 0
        while left < len(nums1) and right < len(nums2):
            if nums1[left] < nums2[right]:
                left += 1
            elif nums1[left] == nums2[right]:
                ret.append(nums1[left])
                left += 1
                right += 1
            else:
                right += 1
        return ret

class Solution {
public:
	vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
		sort(nums1.begin(), nums1.end());
		sort(nums2.begin(), nums2.end());
		int n1 = nums1.size(), n2 = nums2.size();
		int i = 0, j = 0;
		vector<int> ret;
		while (i < n1 and j < n2) {
			if (nums1[i] == nums2[j]) {
				ret.push_back(nums1[1]);
				i++;
				j++;
			}
			else if (nums1[i] < nums2[j]) {
				i++;
			}
			else {
				j++;
			}
		}
		return ret;
	}
};

202. 快乐数

编写一个算法来判断一个数 n 是不是快乐数。「快乐数」定义为：

  1. 对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
  2. 然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。
  3. 如果 可以变为 1，那么这个数就是快乐数。

如果 n 是快乐数就返回 true ；不是，则返回 false 。

使用哈希法来判断这个sum是否重复出现，如果重复了就是return false， 否则一直找到sum为1为止。

快乐数必定会收敛到1,1必须是收敛的，因为1的平方还是1，若生成的一组数中有两个重合（非1）的，那么就会构成一种循环

class Solution {
public:
    bool isHappy(int n) {
        unordered_set<int> set;
        while (1) {
            int sum = getSum(n);
            if (sum == 1) {
                return true;
            }
            // 如果这个sum曾经出现过，说明已经陷入了无限循环了
            if (set.count(sum)) {
                return false;
            }
            else {
                set.insert(sum);
            }
            n = sum;
        }
    }

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

class Solution:
    def isHappy(self, n: int) -> bool:
        def calculate_happy(num):
            sum_ = 0
            while num:
                sum_ += (num % 10) ** 2
                num = num // 10
            return sum_

        record = set()
        while True:
            n = calculate_happy(n)
            if n == 1:
                return True
            if n in record:
                return False
            else:
                record.add(n)

class Solution:
    def isHappy(self, n: int) -> bool:
        num = list(str(n))
        sum_ = 0
        record = set()
        while sum_ != 1:
            sum_ = sum([int(i)**2 for i in num])
            num = list(str(sum_))
            if sum_ in record:
                return False
            record.add(sum_)
        return True

快慢指针：“快指针” 每次走两步，“慢指针” 每次走一步，当二者相等时，即为一个循环周期。此时，判断是不是因为 1 引起的循环，是的话就是快乐数，否则不是快乐数。

class Solution {
public:
   bool isHappy(int n) {
		int slow = n, fast = n;
		do {
			slow = getSum(slow);
			fast = getSum(getSum(fast));
		} while (slow != fast);
		return slow == 1;
	}

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

利用双指针判断循环！！

1. 两数之和

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

暴力搜索时间复杂度较高的原因是寻找 target - x 的时间复杂度过高。因此，我们需要一种更优秀的方法，能够快速寻找数组中是否存在目标元素。如果存在，我们需要找出它的索引。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int, int> m;
        for (int i = 0; i < nums.size(); i++) {
            auto it = m.find(target - nums[i]);
            if (it != m.end()) {
                return { it->second, i };
            }
            m[nums[i]] = i;
        }
        return {};
    }
};

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        records = dict()
        for idx, val in enumerate(nums):
            if target - val not in records:
                records[val] = idx
            else:
                return [records[target - val], idx]

454. 四数相加 II

给定四个包含整数的数组列表 A , B , C , D ,计算有多少个元组 (i, j, k, l) ，使得 A[i] + B[j] + C[k] + D[l] = 0。为了使问题简单化，所有的 A, B, C, D 具有相同的长度 N，且 0 ≤ N ≤ 500 。所有整数的范围在 -2^28 到 2^28 - 1 之间，最终结果不会超过 2^31 - 1 。

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
		unordered_map<int, int> m;
		for (int a : nums1) {
			for (int b : nums2) {
				m[a + b]++;
			}
		}
		int count = 0;
		for (int c : nums3) {
			for (int d : nums4) {
				if (m.count(0 - (c + d))) {
					count += m[-c - d];
				}
			}
		}
		return count;
	}
};

class Solution:
    def fourSumCount(self, nums1: List[int], nums2: List[int], nums3: List[int], nums4: List[int]) -> int:
        hashmap = {}
        for n1 in nums1:
            for n2 in nums2:
                if n1 + n2 in hashmap:
                    hashmap[n1 + n2] += 1  # 记录和相同的组合的对数
                else:
                    hashmap[n1 + n2] = 1
        count = 0
        for n3 in nums3:
            for n4 in nums4:
                key = -n3 - n4
                if key in hashmap:
                    count += hashmap[key]
        return count

15. 三数之和

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有和为 0 且不重复的三元组。
注意：答案中不可以包含重复的三元组。

双指针：难点在去重

class Solution {
public:
	vector<vector<int>> threeSum(vector<int>& nums) {
		sort(nums.begin(), nums.end());
		vector<vector<int>> ans;
		for (int i = 0; i < nums.size(); i++) {
			if (nums[i] > 0) {
				return ans;
			}
			if (i > 0 and nums[i] == nums[i - 1]) continue;  // 去重

			int left = i + 1;
			int right = nums.size() - 1;
			while (left < right) {
				if (nums[i] + nums[left] + nums[right] > 0) right--;
				else if (nums[i] + nums[left] + nums[right] < 0) left++;
				else {
					ans.push_back({ nums[i],nums[left],nums[right] });
					while (left < right and nums[right] == nums[right - 1]) right--;
					while (left < right and nums[left] == nums[left + 1]) left++;
					right--;
					left++;
				}
			}
		}
		return ans;
	}
};

当我们需要枚举数组中的两个元素时，如果我们发现随着第一个元素的递增，第二个元素是递减的，那么就可以使用双指针的方法，将枚举的时间复杂度从 O(N^2)减少至 O(N)。

18. 四数之和

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] ：

  1. 0 <= a, b, c, d < n
  2. a、b、c 和 d 互不相同
  3. nums[a] + nums[b] + nums[c] + nums[d] == target

你可以按 任意顺序 返回答案。

对于15.三数之和 双指针法就是将原本暴力 O ( n 3 ) O(n^3) O(n3)的解法，降为 O ( n 2 ) O(n^2) O(n2)的解法，四数之和的双指针解法就是将原本暴力 O ( n 4 ) O(n^4) O(n4)的解法，降为 O ( n 3 ) O(n^3) O(n3)的解法。

双指针：

class Solution {
public:
	vector<vector<int>> fourSum(vector<int>& nums, int target) {
		sort(nums.begin(), nums.end());
		vector<vector<int>> ret;
		for (int i = 0; i < nums.size(); i++) {
			if (i > 0 and nums[i] == nums[i - 1]) continue;
			for (int j = i + 1; j < nums.size(); j++) {
				if (j > i + 1 and nums[j] == nums[j - 1]) continue;
				int left = j + 1, right = nums.size() - 1;
				while (left < right) {
					if (nums[i] + nums[j] < target - (nums[left] + nums[right])) {
						left++;
					}
					else if (nums[i] + nums[j] > target - (nums[left] + nums[right])) {
						right--;
					}
					else {
						ret.push_back({ nums[i], nums[j], nums[left], nums[right] });
						while (left < right && nums[left] == nums[left + 1]) left++;
						while (left < right && nums[right] == nums[right - 1]) right--;
						left++;
						right--;
					}
				}
			}
		}
		return ret;
	}
};

哈希表：

class Solution:
    def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
        hashmap = {}
        for n in nums:
            if n in hashmap:
                hashmap[n] += 1
            else:
                hashmap[n] = 1
        # good thing about using python is you can use set to drop duplicates.
        ret = set()
        for i in range(len(nums)):
            for j in range(i + 1, len(nums)):
                for k in range(j + 1, len(nums)):
                    val = target - nums[i] - nums[j] - nums[k]
                    if val in hashmap:
                        count = (nums[i] == val) + (nums[j] == val) + (nums[k] == val)
                        if hashmap[val] > count:
                            ret.add(tuple(sorted([nums[i], nums[j], nums[k], val])))
        return list(ret)

Todo:

  • 数组
  • 链表
  • 哈希表
  • 双指针
  • 栈与队列
  • 二叉树
  • 回溯
  • 贪心
  • 动态规划

以上题解大多来自【代码随想录】，在此基础上做了一定总结，并附带一些自己的理解。随缘更新，有错误请指出！

END

奋斗的西瓜瓜
关注
  • 6
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【哈希表】算法例题
QiAn的博客
03-19 1082
每个出现的字符都应当映射到另一个字符，同时不改变字符的顺序。不同字符不能映射到同一个字符上，相同字符只能映射到同一个字符上，字符可以映射到自己本身。因为 nums[0] + nums[1] == 9 ，返回 [0, 1]。，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。是由重新排列源单词的所有字母得到的一个新单词。中的每个非空单词之间存在着双向连接的对应规律。中每个字符出现的次数都相同，则称。，那么这两个字符串是同构的。整数，并返回它们的数组下标。，判断它们是否是同构的。
【数据结构】Leetcode——哈希表 经典题
Bryce-HJ
10-13 1769
hash 英[hæʃ] 美[hæʃ] n. (回锅) 肉丁土豆; (尤指电话上的) #号; v. 反复推敲; 仔细考虑; 把……弄糟（乱）; 斩碎; 斩（肉）; 剁（肉）; 细切（肉）; [例句]The Government made a total hash of things and squandered a small fortune ...
哈希经典题目（C++）
最新发布
lim6ere的博客
06-07 796
哈希表是一个存储数据的容器，我们如果想要快速查找某个元素，就可以用哈希表，时间复杂度为O（1）。以上就是今天要讲的内容。希望对大家的学习有所帮助，仅供参考 如有错误请大佬指点我会尽快去改正 欢迎大家来评论~~ 😘 😘 😘。
C#哈希表经典例题
qq_43533956的博客
03-27 1160
哈希表是用来储存键值（key/value）对的数据结构，它有以下属性与方法 通过键做索引可以得到值，如hash[key]=value 哈希表不能在声明时指定类型，所以调用其中的值必须进行强制转换。 哈希表常用的场景，一是当字符等数据重复多次出现，并且需要记录次数的时候，二是存在关联或者成对的数据需要调用时，比如人名和学号。 寻找重复的子树 给定一棵二叉树root，返回所有重复的子树。对于同一类的重复子树，你只需要返回其中任意一棵的根结点即可。 ...
哈希表题目汇总
Jiana_Feng的博客
06-01 1137
序言 哈希表题目汇总，好好干饭，好好努力，好好加油哦 题目一：检查数组中是否有有两个数相加 等于目标值 给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 的那 两个 整数，并返回它们的数组下标。 你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。 输入：nums = [2,7,11,15], target = 9 输出：[0,1] 解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 哈希表是 组成一个字典 将
哈希表相关习题
weixin_61899680的博客
05-08 347
刷题时遇到的哈希表相关问题
LeetCode哈希表——代码随想录
qq_45568467的博客
05-16 100
这个方法就是我们常说的「双指针」，当我们需要枚举数组中的两个元素时，如果我们发现随着第一个元素的递增，第二个元素是递减的，那么就可以使用双指针的方法，将枚举的时间复杂度从 O(N2) 减少至 O(N)。这是因为在枚举的过程每一步中，「左指针」会向右移动一个位置（也就是题目中的 bbb），而「右指针」会向左移动若干个位置，这个与数组的元素有关，但我们知道它一共会移动的位置数为 O(N)均摊下来，每次也向左移动一个位置，因此时间复杂度为O(N)。时间复杂度O(n^2) ，空间复杂度O(n)。
leetcode中国-LeetCode:LeetCode经典题目分类汇总(JavaScript实现)
06-29
哈希表 ( Hash Table ) 堆 ( Heap ) 图 ( Graph ) 二分查找 ( Binary Search ) 位运算 ( Bit Manipulation ) 分治算法 ( Divide And Conquer ) 排序 ( Sort ) 回溯算法 ( Backtracking ) 双指针 ( Two Pointers ) ...
leetcode分类-leetcode:练习leetcode题目，提高编程能力
06-30
哈希表 堆：最大堆 ／ 最小堆 树与图：最近公共祖先、并查集 字符串：前缀树（字典树） ／ 后缀树 传送门 leetcode 经典题目的解析 这里仅列举具有代表性题目，并不是全部题目 简单难度 中等难度 困难难度 接下来...
leetcode分类-leetcode:Leetcode题目分类总结，附题解及思路
06-30
《LeetCode题目分类总结与解题思路探讨》 LeetCode，作为全球知名的技术学习平台，以其海量的编程挑战题目深受广大程序员喜爱。它涵盖了多种编程语言，如Java、Python、C++等，提供了丰富的算法和数据结构问题，...
leetcode:我的力扣题目仓库
05-05
在LeetCode中，常见的数据结构包括数组（Array）、链表（LinkedList）、栈（Stack）、队列（Queue）、哈希表（HashMap）、树（Tree）等。例如，数组是最基本的数据结构，支持随机访问，常用于实现多种算法；链表则...
哈希表设计 严蔚敏 数据结构习题册
04-17
完全按照严蔚敏的数据结构习题册上的要求写的
leetcode题库-leetcode:leetcode题库
06-29
8. 哈希表：用于快速查找和存储数据，常用于“两数之和”、“有效的括号”等题目。 9. 数组与矩阵：这类问题通常涉及数组操作，如“旋转图像”、“跳跃游戏”。 10. 模拟：根据给定的规则进行程序模拟，如“实现...
数据结构：哈希表平均长度，给定一组查找关键字(19,14,23,1,65,20,84,27,55,11,10,79) 哈希函数为：H(key)=key % 13, 哈希表长为m=15，设每个记录的查找
热门推荐
qq_43813140的博客
05-13 2万+
查找失败平均查找长度例题 请回答采用线性探测再散列和链地址法处理冲突构建的哈希表中，查找失败时的平均查找长度如何计算？ 例：已知一组关键字(19,14,23,1,68,20,84,27,55,11,10,79) 哈希函数为：H(key)=keyMOD13,哈希表长为m=15， 设每个记录的查找概率相等，采用以上两种方法处理冲突，查找失败时的平均查找长度各是多少 这题可真得是出到点子上去啦，看视频，找资料，网上有得解释真的是有点误人子弟，随后加上问了老师一番才有了确定的...
数据结构实验15-哈希查找
weixin_65113709的博客
06-02 849
如果位置冲突，key取：value % 11 + （-1²），如果key超过hash表的长度m，key取key-m，如果key的值为负，key取key+m。如果位置冲突，key取：value % 11 + （-2²），如果key超过hash表的长度m，key取key-m，如果key的值为负，key取key+m。如果位置冲突，key取：value % 11 + （2²），如果key超过hash表的长度m，key取key-m，如果key的值为负，key取key+m。兄弟节点按词典序排序。因为7+1² = 8。
数据结构期末复习——哈希表
qq_39561693的博客
06-17 291
哈希表 哈希表通过哈希函数为各个值重新分配物理索引，哈希函数通常与取模密切相关。例如，给定哈希函数index=key mod max_sizeindex= key \space mod\space max\_sizeindex=key mod max_size，其中max_sizemax\_sizemax_size为哈希表的存储容量。 假若容量为15，则哈希函数为f(x)=x mod 15f(x)=x \space mod \space 15f(
算法学习随笔 4_哈希表有关算法题
P_in_k的博客
04-03 572
本章记录一些有关数组的一些较为经典或者自己第一次做印象比较深刻的算法以及题型，包含自己作为初学者第一次碰到题目时想到的思路以及网上其他更优秀的思路，本章持续更新中......
其他类常见错题
JAVA成长之路
08-12 7228
二、JAVA语言 （2.1）代码 有以下程序 1 2 3 4 5 6 7 8 9 10 11 #include  int fun( char s[ ] ) {     char *p = s ;     while ( *p ! =
哈希表练习题python(数据结构与算法)
qq_33465047的博客
03-02 1315
哈希表主要用在计数，判断是否有重复中，另外，字典、元组是基于哈希表表实现的，故在实际应用过程中，哈希表的应用主要是字典和元组的使用。 练习1 给定一个字符串，统计字符串中出现的最多的字母次数。 思路： 使用字典统计字符串中字母的个数 找出字典中的字母出现最多 def letterCounter(s): freq = {} for piece in s: ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

奋斗的西瓜瓜

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值