数据结构与算法--哈希表

哈希表

哈希表是根据关键码的值而直接进行访问的数据结构.
哈希函数:一种映射函数(将源数据转换为需要的格式)
哈希碰撞:原数据中经哈希函数映射至同一位置.
解决哈希碰撞的两种办法:拉链法和线性探测法
拉链法:发生碰撞的元素都存储在对应索引中
线性探测法:要求哈希表的大小一定大于源数据大小,当发生冲突时,将其他元素下放至空位中.
常见的三种哈希结构:
数组\集合\map(映射)
一般来说哈希表都是用来快速判断一个元素是否出现集合里。

有效的字母异位词

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
示例 1: 输入: s = “anagram”, t = “nagaram” 输出: true
示例 2: 输入: s = “rat”, t = “car” 输出: false
说明: 你可以假设字符串只包含小写字母。

def solution(s, t):
	if len(s) != len(t):
		return False
	record = [0] * 26
	for i in range(len(s)):
		record[ord(s[i]) - ord('a')] += 1
	for i in range(len(t)):
		record[ord(t[i]) - ord('a')] -= 1
	sum_num = sum(record)
	return True if sum_num == 0 else False

查找常用字符

给你一个字符串数组 words ，请你找出所有在 words 的每个字符串中都出现的共用字符（ 包括重复字符），并以数组形式返回。你可以按 任意顺序 返回答案。
示例 1：
输入：words = [“bella”,“label”,“roller”] 输出：[“e”,“l”,“l”] 示例 2：
输入：words = [“cool”,“lock”,“cook”] 输出：[“c”,“o”]
提示：
1 <= words.length <= 100 1 <= words[i].length <= 100 words[i] 由小写英文字母组成

def solution(words):
	if not words: return []
	res = []
	hash_map = [0] * 26
	for i, c in enumerate(words[0]):
		hash_map[ord(c) - ord('a')] += 1
	
	for i in range(1, len(words)):
		hashother = [0] * 26
		for j in range(len(words[i])):
			hashother[ord(words[i][j]) - ord('a')] += 1
		for k in range(26):
			hash_map[k] = min(hash_map[k], hashother[k])
	for i in range(26):
		while hash_map[i] != 0:
			res.extend(chr(i + ord('a')))
			hash_map[i] -= 1
	return res

两个数组的交集

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

def solution(nums1, nums2):
	return list(set(nums1) & set(nums2))

快乐数

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

def tmp_f(num):
	sum_num = 0
	while num:
		num, tmp = divmod(num, 10)
		sum_num += tmp
	return sum_num

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

两数之和

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

def solution(nums, target):
	hash_map = {}
	for i, num in enumerate(nums):
		if target - num in hash_map:
			return [i, hash_map[target - num]]
		else:
			hash_map[num] = i

四数相加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 。
例如:
输入: A = [ 1, 2] B = [-2,-1] C = [-1, 2] D = [ 0, 2] 输出: 2 解释: 两个元组如下:
(0, 0, 0, 1) -> A[0] + B[0] + C[0] + D[1] = 1 + (-2) + (-1) + 2 = 0
(1, 1, 0, 0) -> A[1] + B[1] + C[0] + D[0] = 2 + (-1) + (-1) + 0 = 0

def solution(nums1, nums2, nums3, nums4):
	hashmap = {}
	for n1 in nums1:
		for n2 in nums2:
			if n1 + n2 in hasmap:
				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

赎金信

给定一个赎金信 (ransom) 字符串和一个杂志(magazine)字符串，判断第一个字符串 ransom 能不能由第二个字符串 magazines 里面的字符构成。如果可以构成，返回 true ；否则返回 false。
(题目说明：为了不暴露赎金信字迹，要从杂志上搜索各个需要的字母，组成单词来表达意思。杂志字符串中的每个字符只能在赎金信字符串中使用一次。)
注意：
你可以假设两个字符串均只含有小写字母。
canConstruct(“a”, “b”) -> false
canConstruct(“aa”, “ab”) -> false
canConstruct(“aa”, “aab”) -> true

def solution(ransom, magazine):
	arr = [0] * 26
	for x in magazine:
		arr[ord(x) - ord('a')] += 1
	for x in ransom:
		if arr[ord(x) - ord('a')] == 0:
			return False
		else:
			arr[ord(x) - ord('a')] -= 1
	return True

三数之和

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。
注意： 答案中不可以包含重复的三元组。
示例：
给定数组 nums = [-1, 0, 1, 2, -1, -4]，
满足要求的三元组集合为： [ [-1, 0, 1], [-1, -1, 2] ]

class Solution:
    def threeSum(self, nums):
        ans = []
        n = len(nums)
        nums.sort()
        for i in range(n):
            left = i + 1
            right = n - 1
            if nums[i] > 0:
                break
            if i >= 1 and nums[i] == nums[i - 1]:
                continue
            while left < right:
                total = nums[i] + nums[left] + nums[right]
                if total > 0:
                    right -= 1
                elif total < 0:
                    left += 1
                else:
                    ans.append([nums[i], nums[left], nums[right]])
                    while left != right and nums[left] == nums[left + 1]: left += 1
                    while left != right and nums[right] == nums[right - 1]: right -= 1
                    left += 1
                    right -= 1
        return ans

四数之和

题意：给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。
注意：
答案中不可以包含重复的四元组。
示例： 给定数组 nums = [1, 0, -1, 0, -2, 2]，和 target = 0。 满足要求的四元组集合为： [ [-1, 0, 0, 1], [-2, -1, 1, 2], [-2, 0, 0, 2] ]

# 双指针法
class Solution:
    def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
        
        nums.sort()
        n = len(nums)
        res = []
        for i in range(n):
            if i > 0 and nums[i] == nums[i - 1]: continue
            for k in range(i+1, n):
                if k > i + 1 and nums[k] == nums[k-1]: continue
                p = k + 1
                q = n - 1

                while p < q:
                    if nums[i] + nums[k] + nums[p] + nums[q] > target: q -= 1
                    elif nums[i] + nums[k] + nums[p] + nums[q] < target: p += 1
                    else:
                        res.append([nums[i], nums[k], nums[p], nums[q]])
                        while p < q and nums[p] == nums[p + 1]: p += 1
                        while p < q and nums[q] == nums[q - 1]: q -= 1
                        p += 1
                        q -= 1
        return res