技術標籤：leetcodeleetcode字串演算法資料結構java

題目描述： 給定兩個字串 s 和 t，判斷它們是否是同構的。

如果 s 中的字元可以被替換得到 t ，那麼這兩個字串是同構的。

所有出現的字元都必須用另一個字元替換，同時保留字元的順序。兩個字元不能對映到同一個字元上，但字元可以對映自己本身。

示例 1：

輸入: s = “egg”, t = “add”
輸出: true

示例 2：

輸入: s = “foo”, t = “bar”
輸出: false

示例 3：

輸入: s = “paper”, t = “title”
輸出: true

說明：
你可以假設 s 和 t 具有相同的長度。

來源：LeetCode官網
題目連結

方法1 計算所有索引

思路： 直觀講，對於同構字串，s中任一字元出現的所有索引和t中對應位置字元出現的所有索引相同。以此來判斷，使用雜湊表。
程式碼：

class Solution {
    public boolean isIsomorphic(String s, String t) {
        Map<Character, String> s_ch = new HashMap<>();
        Map<Character, String> t_ch = new HashMap<>();
 

        for(int i = 0; i < s.length(); i ++){
            s_ch.put(s.charAt(i), s_ch.getOrDefault(s.charAt(i), "") + Integer.toString(i));
            t_ch.put(t.charAt(i), t_ch.getOrDefault(t.charAt(i), "") + Integer.toString(i));
        }
        boolean f = true;
        for
 
(int i = 0; i < s.length(); i ++){
            if(!(s_ch.get(s.charAt(i)).equals(t_ch.get(t.charAt(i))))){
                f = false;
                break;
            }
        }

        return f;
    }
}

分析： 方法直接，相當於暴力求解，效率較低。
結果：

方法2 建立對映關係

思路： 該題旨在判斷s和t中每個位置上的字元是否一一對應。建立兩個雜湊表：(1). s2t，s中的字元為鍵，t中字元為值；(2). t2s，t中字元為鍵，s中字元為值。遍歷字串，更新雜湊表，如果出現非對應關係，則為false。
程式碼：

class Solution {
    public boolean isIsomorphic(String s, String t) {
        Map<Character, Character> s2t = new HashMap<>();
        Map<Character, Character> t2s = new HashMap<>();
        for(int i = 0; i < s.length(); i ++){
            char s_i = s.charAt(i);
            char t_i = t.charAt(i);
            if((s2t.containsKey(s_i) && s2t.get(s_i) != t_i) || (t2s.containsKey(t_i) && t2s.get(t_i) != s_i))
                return false;
            s2t.put(s_i, t_i);
            t2s.put(t_i, s_i);
        }
        return true;
    }
}

結果：

方法3 陣列替代Map

思路： 為了提高效率。
程式碼：

class Solution {
    public boolean isIsomorphic(String s, String t) {
        char[] s_ch = s.toCharArray();
        char[] t_ch = t.toCharArray();
        int[] preIndexOfs = new int[256];
        int[] preIndexOft = new int[256];
        for (int i = 0; i < s_ch.length; i++) {
            if (preIndexOfs[s_ch[i]] != preIndexOft[t_ch [i]])
                return false;
            preIndexOfs[s_ch[i]] = i + 1;
            preIndexOft[t_ch [i]] = i + 1;
        }
        return true;
    }
}

分析： 使用陣列，提高了效率哦。
結果：

大牛哥哥們還有更多更優的方法，我們共同學習！！