以空间换时间的查找。
Hash table的构造:
ASCII码-"a"的ASCII码
作为数组下标哈希表又称散列表,其基础知识脉络如下:
参考链接-代码随想录:哈希表
根据关键码的值直接进行访问的数据结构,散列表的实现常常叫做散列(hasing)。散列是一种用于以常数平均时间执行插入、删除和查找的技术。
整个散列过程主要分为两步:
(1)通过散列函数计算记录的散列地址,并按此散列地址存储该记录。
(2) 查找时,我们通过同样的散列函数计算记录的散列地址,按此散列地址访问该记录。
散列函数:
存储位置 = f (关键字)
输入:关键字 输出:存储位置(散列地址)
散列技术是在通过记录的存储位置和它的关键字之间建立一个确定的对应关系 f ,使得每个关键字 key 都对应一个存储位置 f(key)。
散列函数的设计规则:
构建hash table,根据元素信息求解对应的Hash table的下标对应下标处存储需要的相关信息,以空间换时间。
给定两个字符串 s 和 t ,编写一个函数来判断 t 是否是 s 的字母异位词。
题目:
给你两个字符串:ransomNote 和 magazine ,判断 ransomNote 能不能由 magazine 里面的字符构成。
如果可以,返回 true ;否则返回 false 。
magazine 中的每个字符只能在 ransomNote 中使用一次。
利用hash table的解题思想:
(题目中给定字符串中只包含小写字母)
因此定义一个大小为26的数组,存储的是26个小写字母在字符串中出现的次数,
首先对第一个字符串进行遍历,将数组中的对应字符的个数++
然后对第二个字符串进行遍历,将数组中的对应字符的个数–
如果,数组中存在-1的元素,则返回False。
只需要定义一个数组,即可。
class Solution {
public boolean canConstruct(String ransomNote, String magazine) {
//类比242.有效的字母异位词一题,该题目则是需要magazine的字母可以涵盖sansomNote
int len1=ransomNote.length();
int len2=magazine.length();
if(len1>len2) return false;
Map<Character,Integer> map=new HashMap<>();
for(int i=0;i<len2;i++){
char c=magazine.charAt(i);
map.put(c,map.getOrDefault(c,0)+1);
}
for(int i=0;i<len1;i++){
char c=ransomNote.charAt(i);
if(!map.containsKey(c)) return false;
if(map.get(c)==1){
map.remove(c);
}else{
map.put(c,map.get(c)-1);
}
}
return true;
}
}
Python中可以使用collections包中的Counter类和defaultdict类实现。这两个类都是dict类的子类但是相比dict使用起来更加方便。
class Solution(object):
def isAnagram(self, s, t):
"""
:type s: str
:type t: str
:rtype: bool
"""
# 使用Counter
# from collections import Counter
# scount=Counter(s)
# tcount=Counter(t)
# return scount==tcount:
# 使用defaultdict
from collections import defaultdict
sdict=defaultdict(int)
tdict=defaultdict(int)
for i in s:
sdict[i]+=1
for j in t:
tdict[j]+=1
return sdict==tdict
题目描述:
给定两个字符串 s 和 p,找到 s 中所有 p 的 异位词 的子串,返回这些子串的起始索引。不考虑答案输出的顺序。
异位词 指由相同字母重排列形成的字符串(包括相同的字符串)。
解题思想:
class Solution {
public List<Integer> findAnagrams(String s, String p) {
List<Integer> res=new ArrayList<>();
if(s.length()<p.length()) return res;
Map<Character,Integer> map=new HashMap<>();
Map<Character,Integer> temp=new HashMap<>();
for(int i=0;i<p.length();i++){
char c=p.charAt(i);
map.put(c,map.getOrDefault(c,0)+1);
}
int r=p.length()-1;
int l=0;
//初始化temp
for(int i=0;i<=r;i++){
char c=s.charAt(i);
temp.put(c,temp.getOrDefault(c,0)+1);
}
while(r<s.length()){
if(temp.equals(map)){
res.add(l);
}
r++;
if(r==s.length()) break;
temp.put(s.charAt(r),temp.getOrDefault(s.charAt(r),0)+1);
char lc=s.charAt(l);
if(temp.get(s.charAt(l))==1){
temp.remove(s.charAt(l));
}else{
temp.put(s.charAt(l),temp.getOrDefault(s.charAt(l),0)-1);
}
l++;
}
return res;
}
}
题目描述:
给你一个字符串数组,请你将 字母异位词 组合在一起。可以按任意顺序返回结果列表。
字母异位词 是由重新排列源单词的字母得到的一个新单词,所有源单词中的字母通常恰好只用一次。
解题思想:
构造Hash table:
最终返回hash table的values即可。
class Solution {
public List<List<String>> groupAnagrams(String[] strs) {
//Map
Map<Map<Character,Integer>,List<String>> map=new HashMap<>();
for(String str:strs){
Map<Character,Integer> temp=new HashMap<>();
for(int i=0;i<str.length();i++){
char c=str.charAt(i);
temp.put(c,temp.getOrDefault(c,0)+1);
}
if(map.containsKey(temp)){
List<String> list=map.get(temp);
list.add(str);
}else{
List<String> list=new ArrayList<>();
list.add(str);
map.put(temp,list);
}
}
return new ArrayList<List<String>>(map.values());
}
}
题目描述:
编写一个算法来判断一个数 n 是不是快乐数。
「快乐数」 定义为:
对于一个正整数,每一次将该数替换为它每个位置上的数字的平方和。
然后重复这个过程直到这个数变为 1,也可能是** 无限循环** 但始终变不到 1。
如果这个过程 结果为 1,那么这个数就是快乐数。
如果 n 是 快乐数 就返回 true ;不是,则返回 false 。
解题思想:
可以直观感觉这个题就是一个循环求解的数学问题,但是题目中说,可能存在“无限循环”。那么对于循环的情况如何跳出循环结束计算呢?
循环——顾名思义就是出现了之前出现过得数字。
因此可以使用hash table。
class Solution {
public boolean isHappy(int n) {
//需要定义一个set用来存储历史值
Set<Integer> set=new HashSet<>();
while(n!=1){
//计算当前n的每个位置数字的平方和
int res=0;
while(n!=0){
int val=n%10;
res+=val*val;
n/=10;
}
if(set.contains(res)) return false;
set.add(res);
n=res;
}
return true;
}
}
题目描述:
在字符串中找出第一个只出现一次的字符,
如,输入“abaccdeff”,则输出“b”
解题思想:
题目关键点在于:
如何解决?:
题目描述:
给定一个整数数组 nums 和一个整数目标值 target,请你在该数组中找出 和为目标值 target 的那 两个 整数,并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是,数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。
解题思想:
在数组中找出和为目标值的唯一一对元素。(注意一个元素不可在结果中重复使用)
class Solution(object):
def twoSum(self, nums, target):
"""
:type nums: List[int]
:type target: int
:rtype: List[int]
"""
# 最直接的思想:两层循环,时间复杂度O(n^2)
# 优化:使用hash table,时间复杂度O(n)
# 实现:定义一个dict,对nums进行遍历,然后
adddict=dict()
for i,x in enumerate(nums):
if target-x in adddict:
return [adddict[target-x],i]
adddict[x]=i
return []
题目描述:
给你四个整数数组 nums1、nums2、nums3 和 nums4 ,数组长度都是 n ,请你计算有多少个元组 (i, j, k, l) 能满足:
0 <= i, j, k, l < n
nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0
解题思想:
hash table可以解决寻找数组中对应加数的题目:给定一个数组,找出数组中和为目标值的两个元素。
其思想:对数组进行一次遍历,对每个元素寻找数组中是否存在其对应加数。
寻找加数,即定义一个dict存储未配对的元素以及其数组中的下标。
该题目变成了四个数相加:
因此采用:分组+Hash table 的思想
具体实现:
class Solution(object):
def fourSumCount(self, nums1, nums2, nums3, nums4):
"""
:type nums1: List[int]
:type nums2: List[int]
:type nums3: List[int]
:type nums4: List[int]
:rtype: int
"""
# 四数相加:分组+hash table
# 分组:先将四个元素转成两个元素,即两两分组,先求和。
# 和的存储不是简单的使用一个list,而是存储,和及其出现的次数
from collections import defaultdict
sums1,sums2=defaultdict(int),defaultdict(int)
for i in nums1:
for j in nums2:
sums1[i+j]+=1
for i in nums3:
for j in nums4:
sums2[i+j]+=1
adddict=dict()
res=0
for add,num in sums1.items():
if 0-add in sums2:
res+=sums2[0-add]*num
return res
如何设计一个不会(概率尽可能小)冲突的hash函数?
题目描述:
给你两棵二叉树 root 和 subRoot 。检验 root 中是否包含和 subRoot 具有相同结构和节点值的子树。如果存在,返回 true ;否则,返回 false 。
二叉树 tree 的一棵子树包括 tree 的某个节点和这个节点的所有后代节点。tree 也可以看做它自身的一棵子树。
解法一:构造节点的hash表,比较subRoot 节点的hash值是否与root所在树的某个节点的hash值一样
在这个哈希函数中考虑到每个点的 val、子树哈希值、子树大小以及左右子树的不同权值,所以这些因素共同影响一个点的哈希值,所以出现冲突的几率较小,一般我们可以忽略。
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
//首先要构造素数表
static constexpr int MAX_N=2000;
bool isPrime[MAX_N];
int prime[MAX_N];
void getPrime(){
isPrime[0]=true;
isPrime[1]= true;
int i=2;
int n=0;
prime[n++]=2;
while(i<MAX_N){
for(int j=1;j<MAX_N/i;j++){
isPrime[i*j]= true;
}
for(i=i+1;i<MAX_N;i++){
if(!isPrime[i]){
prime[n++]=i;
break;
}
}
}
}
//计算每个节点作为根对应的子树的大小以及每个节点的hash值
//pair->first:子树大小;pair->second:节点hash值
unordered_map<TreeNode*,pair<int,int>> subNode1;
unordered_map<TreeNode*,pair<int,int>> subNode2;
static constexpr int MOD = int(1E9) + 7;
void traverse(TreeNode* root,unordered_map<TreeNode*,pair<int,int>> &subNode){
if(root==NULL) return;
subNode[root].first=1;
subNode[root].second=root->val;
if(root->left==NULL && root->right==NULL) return;
if(root->left){
traverse(root->left,subNode);
subNode[root].first+=subNode[root->left].first;
subNode[root].second=(subNode[root].second+(31LL*subNode[root->left].second*prime[subNode[root->left].first])%MOD)%MOD;
}
if(root->right){
traverse(root->right,subNode);
subNode[root].first+=subNode[root->right].first;
subNode[root].second=(subNode[root].second+(79LL*subNode[root->right].second*prime[subNode[root->right].first])%MOD)%MOD;
}
}
bool isSubtree(TreeNode* root, TreeNode* subRoot) {
//深度优先遍历+KMP算法
getPrime();
traverse(root,subNode1);
traverse(subRoot,subNode2);
cout<<subNode2[subRoot].second<<endl;
cout<<subNode2[subRoot].first<<endl;
for(unordered_map<TreeNode*,pair<int,int>>::iterator it=subNode1.begin();it!=subNode1.end();it++){
if(it->second.second==subNode2[subRoot].second) return true;
}
return false;
}
};
解法二:普通做法
如果一个树是另一个树的子树,则进行先序遍历之后,得到的序列结果,应该是一个是另一个的子集。
因此:
/**
* Definition for a binary tree node.n
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public boolean isSubtree(TreeNode root, TreeNode subRoot) {
//对两棵树进行先序遍历,将结果保存在数组中
//然后看arr1中是否存在arr2子集即可
List<String> arr1=new ArrayList<>();
List<String> arr2=new ArrayList<>();
preorder(root,arr1);
preorder(subRoot,arr2);
//判断arr2是否为arr1的子集
int i=0;
while(i<arr1.size()){
if(!arr1.get(i).equals(arr2.get(0))){
i++;
}else{
int j=1;
for(j=1;j<arr2.size();j++){
if(!arr1.get(i+j).equals(arr2.get(j))){
i++;
break;
}
}
if(j==arr2.size()) return true;
}
}
return false;
}
public void preorder(TreeNode root,List<String> arr){
if(root==null){
arr.add("null");
return;
}
arr.add(root.val+"");
preorder(root.left,arr);
preorder(root.right,arr);
}
}
给你一个字符串 s,请你返回 两个相同字符之间的最长子字符串的长度 ,计算长度时不含这两个字符。如果不存在这样的子字符串,返回 -1 。
子字符串 是字符串中的一个连续字符序列。
示例:
**输入:**s = “abca” **输出:**2 **解释:**最优的子字符串是 “bc” 。
解题思想:
使用hash table。
对数组进行一次遍历,
class Solution {
public:
int maxLengthBetweenEqualCharacters(string s) {
//hashtable方法
int maxlen=-1;
vector<int> hash(26,-1);
for(int i=0;i<s.size();i++){
if(hash[s[i]-'a']==-1){
hash[s[i]-'a']=i;
}
else{
maxlen=max(maxlen,i-hash[s[i]-'a']);
}
}
if(maxlen==-1) return -1;
return maxlen-1;
}
};