一【题目类别】

哈希表

二【题目难度】

简单

三【题目编号】

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 * 10^4$
$t . l e n g t h == s . l e n g t h$
$s 和 t 由任意有效的 A SC II 字符组成$

七【解题思路】

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

八【时间频度】

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

九【代码实现】

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;
    }
}

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;
}

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

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;
    }
};