力扣面试经典题之哈希表

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 由小写英文字母组成

bool canConstruct(char* ransomNote, char* magazine) {
int rr=strlen(ransomNote);
int mm=strlen(magazine);
int count=0;
for(int i=0;i<rr;i++){
for(int j=0;j<mm;j++){
if(ransomNote[i]==magazine[j]){
count++;
magazine[j]=' ';
break;
}
}
}
if(count==rr){
return true;
}
return false;
}

205. 同构字符串

简单

给定两个字符串 s 和 t ，判断它们是否是同构的。

如果 s 中的字符可以按某种映射关系替换得到 t ，那么这两个字符串是同构的。

每个出现的字符都应当映射到另一个字符，同时不改变字符的顺序。不同字符不能映射到同一个字符上，相同字符只能映射到同一个字符上，字符可以映射到自己本身。

示例 1:
复制代码
输入：s = "egg", t = "add"
输出：true
示例 2：
复制代码
输入：s = "foo", t = "bar"
输出：false
示例 3：
复制代码
输入：s = "paper", t = "title"
输出：true
提示：
1 <= s.length <= 5 * 104

t.length == s.length
s 和 t 由任意有效的 ASCII 字符组成

bool isIsomorphic(char* s, char* t) {
int a[200],f[200]={0};
for(int i=0;i<200;i++){
a[i]=-1;
}
int ss=strlen(s);
int tt=strlen(t);
if(ss!=tt){
return false;
}
for(int i=0;i<ss;i++){
int p=s[i]-' ';
if(a[p]==-1&&f[t[i]-' ']==0){
a[p]=t[i]-' ';
f[(t[i]-' ')]=1;
}else if(a[p]==-1&&f[t[i]-' ']!=0){
return false;
}else{
if(a[p]!=t[i]-' '){
return false;
}
}
复制代码
  }

  return true;
}
290. 单词规律

简单

给定一种规律 pattern 和一个字符串 s ，判断 s 是否遵循相同的规律。

这里的遵循指完全匹配，例如， pattern 里的每个字母和字符串 s中的每个非空单词之间存在着双向连接的对应规律。

示例1:
复制代码
输入: pattern = "abba", s = "dog cat cat dog"
输出: true
示例 2:
复制代码
输入:pattern = "abba", s = "dog cat cat fish"
输出: false
示例 3:
复制代码
输入: pattern = "aaaa", s = "dog cat cat dog"
输出: false
提示:
1 <= pattern.length <= 300

pattern 只包含小写英文字母

1 <= s.length <= 3000

s 只包含小写英文字母和 ' '

s 不包含 任何前导或尾随对空格
s 中每个单词都被 单个空格分隔

bool wordPattern(char* pattern, char* s) {
char *hashset[26];
for(int i=0;i<26;i++){
hashset[i]=NULL;
}
int pp=strlen(pattern);
const char ff[2]=" ";
char *token=NULL;
for(int i=0;i<pp;i++){
复制代码
      if(token == NULL){
          token = strtok(s, ff);
      }
      else{
           token = strtok(NULL, ff);
           if(token == NULL) {
               return false;
           }
      }
      if(hashset[pattern[i]-'a']==NULL){
          
               hashset[pattern[i]-'a']=token;
     }else{
         if(strcmp(hashset[pattern[i]-'a'],token)!=0){
                 return false;
          }
      }
  }
  token = strtok(NULL, ff);
  if(token != NULL)
  {
      return false;
  }
  for(int i =0; i < 26; i++)
  {
      if(hashset[i]!= NULL)
      {
          for(int j = i+ 1; j < 26; j++)
          {
              if(hashset[j]!= NULL)
              {
                  if(strcmp(hashset[i], hashset[j]) == 0)
                  {
                      return false;
                  }
              }
          }
      }
  }
  return true;
}
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 仅包含小写字母

bool isAnagram(char* s, char* t) {
int snum[26]={0};
int tnum[26]={0};
int ss=strlen(s);
int tt=strlen(t);
for(int i=0;i<ss;i++){
snum[s[i]-'a']++;
}
for(int i=0;i<tt;i++){
tnum[t[i]-'a']++;
}
for(int i=0;i<26;i++){
if(snum[i]!=tnum[i]){
return false;
}
}
return true;
}

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

只会存在一个有效答案

/**

Note: The returned array must be malloced, assume caller calls free().
/
int twoSum(int* nums, int numsSize, int target, int* returnSize) {
int a=(int)malloc(sizeof(int)*2);
for(int i=0;i<numsSize;i++){
for(int j=i+1;j<numsSize;j++){
if(nums[i]+nums[j]==target){
a[0]=i;
a[1]=j;
(*returnSize)=2;
break;
}
}
}
return a;
}