【LeetCode每日一题】——205.同构字符串

文章目录

• 一【题目类别】
• 二【题目难度】
• 三【题目编号】
• 四【题目描述】
• 五【题目示例】
• 六【题目提示】
• 七【解题思路】
• 八【时间频度】
• 九【代码实现】
• 十【提交结果】

一【题目类别】

• 哈希表

二【题目难度】

• 简单

三【题目编号】

• 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 . l e n g t h < = 5 ∗ 1 0 4 1 <= s.length <= 5 * 10^4 1<=s.length<=5∗104
• t . l e n g t h = = s . l e n g t h t.length == s.length t.length==s.length
• s 和 t 由任意有效的 A S C I I 字符组成 s 和 t 由任意有效的 ASCII 字符组成 s和t由任意有效的ASCII字符组成

七【解题思路】

• 利用哈希表的思想，我们应该保证：
  • 对于相同的字母，应该映射到同一个字母
  • 对于不同的字母，不能映射到同一个字母
• 所以我们分别建立两个哈希表来完成上面的要求
• 第一个哈希表来判断相同的字母是否映射到同一个字母，直接比较就可以，如果相同的字母不能映射到同一个字母，那么就返回false
• 第二个哈希表来判断不同的字母是否映射到同一个字母，直接比较就可以，如果不同的字母可以映射到同一个字母，那么就返回false
• 如果在循环中通过以上判断都没有返回false，那么说明两个字符串就是同构字符串，返回true即可

八【时间频度】

• 时间复杂度： O ( n ) O(n) O(n)， n n n为传入的字符串的长度，传入的两个字符串长度相等
• 空间复杂度： O ( ∣ Σ ∣ ) O(|Σ|) O(∣Σ∣)， Σ Σ Σ为传入的字符串的字符集的大小

九【代码实现】

1. Java语言版

class Solution {
    public boolean isIsomorphic(String s, String t) {
        int lenS = s.length();
        int lenT = t.length();
        if(lenS != lenT){
            return false;
        }
        HashMap<Character, Character> map = new HashMap<>();
        for(int i = 0;i < lenS;i++){
            if(map.containsKey(s.charAt(i))){
                if(map.get(s.charAt(i)) != t.charAt(i)){
                    return false;
                }
            }else{
                if(map.containsValue(t.charAt(i))){
                    return false;
                }
                map.put(s.charAt(i), t.charAt(i));
            }
        }
        return true;
    }
}

2. C语言版

struct HashTable
{
    char key;
    char val;
    UT_hash_handle hh;
};

bool isIsomorphic(char * s, char * t)
{
    struct HashTable* mapS = NULL;
    struct HashTable* mapT = NULL;
    int lenS = strlen(s);
    int lenT = strlen(t);
    if(lenS != lenT)
    {
        return false;
    }
    for(int i = 0;i < lenS;i++)
    {
        char tempS = s[i];
        char tempT = t[i];
        struct HashTable* valS;
        struct HashTable* valT;
        HASH_FIND(hh, mapS, &tempS, sizeof(char), valT);
        HASH_FIND(hh, mapT, &tempT, sizeof(char), valS);
        if(valT != NULL)
        {
            if(valT->val != tempT)
            {
                return false;
            }
        }
        else
        {
            valT = malloc(sizeof(struct HashTable));
            valT->key = tempS;
            valT->val = tempT;
            HASH_ADD(hh, mapS, key, sizeof(char), valT);
        }
        if(valS != NULL)
        {
            if(valS->val != tempS)
            {
                return false;
            }
        }
        else
        {
            valS = malloc(sizeof(struct HashTable));
            valS->key = tempT;
            valS->val = tempS;
            HASH_ADD(hh, mapT, key, sizeof(char), valS);
        }
    }
    return true;
}

3. Python语言版

class Solution:
    def isIsomorphic(self, s: str, t: str) -> bool:
        lenS = len(s)
        lenT = len(t)
        if lenS != lenT:
            return False
        mapS = {}
        mapT = {}
        for tempS, tempT in zip(s, t):
            if (tempS in mapS and mapS[tempS] != tempT) or (tempT in mapT and mapT[tempT] != tempS):
                return False
            mapS[tempS] = tempT
            mapT[tempT] = tempS
        return True

4. C++语言版

class Solution {
public:
    bool isIsomorphic(string s, string t) {
        int lenS = s.size();
        int lenT = t.size();
        if(lenS != lenT){
            return false;
        }
        unordered_map<char, char> mapS;
        unordered_map<char, char> mapT;
        for(int i = 0;i < lenS;i++){
            char tempS = s[i];
            char tempT = t[i];
            if((mapS.count(tempS) && mapS[tempS] != tempT) || (mapT.count(tempT) && mapT[tempT] != tempS)){
                return false;
            }
            mapS[tempS] = tempT;
            mapT[tempT] = tempS;
        }
        return true;
    }
};

十【提交结果】

1. Java语言版
   

2. C语言版
   

3. Python语言版
   

4. C++语言版