java字符串同构_LeetCode 205：同构字符串Isomorphic Strings

题目：

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

如果 s 中的字符可以被替换得到 *t* ，那么这两个字符串是同构的。

所有出现的字符都必须用另一个字符替换，同时保留字符的顺序。两个字符不能映射到同一个字符上，但字符可以映射自己本身。

Given two strings *s* and *t*, determine if they are isomorphic.

Two strings are isomorphic if the characters in *s* can be replaced to get *t*.

All occurrences of a character must be replaced with another character while preserving the order of characters. No two characters may map to the same character but a character may map to itself.

示例 1:

输入: s = "egg", t = "add"

输出: true

示例 2:

输入: s = "foo", t = "bar"

输出: false

示例 3:

输入: s = "paper", t = "title"

输出: true

说明:

你可以假设 s 和 *t* 具有相同的长度。

Note:

You may assume both *s* and *t* have the same length.

解题思路：

​在示例 3 中输入: s = "paper", t = "title"，其中字母映射结果：p <==> t , a <==>i , e <==> l , r <==>e 映射的字母可以一一替换得到对应的单词，这便是同构字符串。

非同构字符串无非两种情况 (假设长度相等)：

s = 'aa' , t = 'ab'，在建立过字母映射 a <==> a 后，s 第二个字母 a 其映射 value = a 不等于 t 中第二个字母 b

s = 'ab' , t = 'aa'，在建立过字母映射 a <==> b 后，t 第二个字母 a 其映射 key = a 不等于 s 中第二个字母 b

所以这个可以用两个哈希映射验证上述两种情况，也可以用一个映射加判断是否存在于其 values 中。

​既然是建立映射字符，那么最先想到的就是哈希映射 (map、dict) 了。

​该题为英文单词字符串同构检测，整个 ASCll 码长度才 256，所以这道题也可以用 char[256] 以索引值对应一个字符，其存储值对应一个字符建立映射关系。

还有一个更巧妙的解法，每个字符都与该字符串中第一次出现的索引对比是否相等，判断是否同构。如：

输入：s = 'aa' , t = 'ab'

第一次遍历：

s中第一个字符 a 第一次出现的索引为0，t中第一个字符 a 第一次出现的索引为0，索引相等，继续遍历

第二次遍历：

s中第二个字符 a 第一次出现的索引为0，t中第二个字符 b 第一次出现的索引为1，索引不相等， 返回false

代码：

双哈希映射:

Java:

class Solution {

public boolean isIsomorphic(String s, String t) {

Map s_map = new HashMap<>();

Map t_map = new HashMap<>();

char[] s_chars = s.toCharArray(), t_chars = t.toCharArray(); // 转成 cahr 型数组

for (int i = 0; i < s_chars.length; i++) {

// 两种不成立的情况

if (s_map.containsKey(s_chars[i]) && s_map.get(s_chars[i]) != t_chars[i]) return false;

if (t_map.containsKey(t_chars[i]) && t_map.get(t_chars[i]) != s_chars[i]) return false;

s_map.put(s_chars[i], t_chars[i]);

t_map.put(t_chars[i], s_chars[i]);

}

return true;

}

}

Python:

class Solution:

def isIsomorphic(self, s: str, t: str) -> bool:

s_map, t_map = {}, {} # 双字典

for c1, c2 in zip(s, t):

# 两种不成立的情况

if c1 in s_map and s_map[c1] != c2:

return False

if c2 in t_map and t_map[c2] != c1:

return False

s_map[c1] = c2

t_map[c2] = c1

return True

单哈希映射：

Java:

class Solution {

public boolean isIsomorphic(String s, String t) {

Map map = new HashMap<>();// 一个哈希映射

char[] s_chars = s.toCharArray(), t_chars = t.toCharArray();

for (int i = 0; i < s_chars.length; i++) {

if (map.containsKey(s_chars[i]) && map.get(s_chars[i]) != t_chars[i]) return false;

// 判断t中字符是否存在于映射中的 values 内

if (!map.containsKey(s_chars[i]) && map.containsValue(t_chars[i])) return false;

map.put(s_chars[i], t_chars[i]);

}

return true;

}

}

Python:

class Solution:

def isIsomorphic(self, s: str, t: str) -> bool:

hash_map = {}

for c1, c2 in zip(s, t):

if c1 in hash_map and hash_map[c1] != c2:

return False

# 判断t中字符是否存在于映射中的 values 内

if c1 not in hash_map and c2 in hash_map.values():

return False

hash_map[c1] = c2

return True

字符首次出现的索引对比法：

Java：

class Solution {

public boolean isIsomorphic(String s, String t) {

char[] s_chars = s.toCharArray();

char[] t_chars = t.toCharArray();

for (int i = 0; i < s.length(); i++) {

// 判断该字符首次出现索引值是否相等

if (s.indexOf(s_chars[i]) != t.indexOf(t_chars[i])) {

return false;

}

}

return true;

}

}

Python：

class Solution:

def isIsomorphic(self, s: str, t: str) -> bool:

for c1, c2 in zip(s, t):

# 判断该字符首次出现索引值是否相等

if s.find(c1) != t.find(c2):

return False

return True

256 位字符映射

Java

class Solution {

public boolean isIsomorphic(String s, String t) {

char[] s_chars = s.toCharArray(), t_chars = t.toCharArray();

char[] s_map = new char[256], t_map = new char[256]; //索引与存储值建立映射

for (int i = 0; i < s_chars.length; i++) {

char sc = s_chars[i], tc = t_chars[i];

if (s_map[sc] == 0 && t_map[tc] == 0) {

s_map[sc] = tc;

t_map[tc] = sc;

} else if (s_map[sc] != tc || t_map[tc] != sc) {//索引与元素值的映射是否满足条件

return false;

}

}

return true;

}

}

python 中没有字符这一基础数