# [LeetCode] 242. Valid Anagram 验证变位词

2021年09月15日 阅读数：2

Given two strings s and , write a function to determine if t is an anagram of s.html

Example 1:java

```Input: s = "anagram", t = "nagaram"
Output: true
```

Example 2:python

```Input: s = "rat", t = "car"
Output: false
```

Note:
You may assume the string contains only lowercase alphabets.函数

What if the inputs contain unicode characters? How would you adapt your solution to such case?post

Java：blog

```class Solution {
public boolean isAnagram(String s, String t) {
HashMap<Character, Integer> map = new HashMap<>();

// first time: store each s char and occurrence into map
for(int i=0; i<s.length(); i++) {
char sChar = s.charAt(i);
map.put(sChar, map.getOrDefault(sChar, 0) + 1);
}
// second time: compare t char with map to see match or not
for(int i=0; i<t.length(); i++) {
char tChar = t.charAt(i);

if(!map.containsKey(tChar))
return false;

if(map.get(tChar) == 1)
map.remove(tChar);
else
map.put(tChar, map.get(tChar) - 1);

}

return map.size() == 0 ? true : false;
}
}　```

Java:排序

```public class Solution {
public boolean isAnagram(String s, String t) {
int[] alphabet = new int[26];
for (int i = 0; i < s.length(); i++) alphabet[s.charAt(i) - 'a']++;
for (int i = 0; i < t.length(); i++) alphabet[t.charAt(i) - 'a']--;
for (int i : alphabet) if (i != 0) return false;
return true;
}
}　　```

Python:  T: O(n)  S: O(1)

```class Solution:
def isAnagram(self, s, t):
if len(s) != len(t):
return False

count = {}

for c in s:
if c.lower() in count:
count[c.lower()] += 1
else:
count[c.lower()] = 1

for c in t:
if c.lower() in count:
count[c.lower()] -= 1
else:
count[c.lower()] = -1
if count[c.lower()] < 0:
return False

return True
```

Python: wo

```class Solution(object):
def isAnagram(self, s, t):
"""
:type s: str
:type t: str
:rtype: bool
"""
a = [0] * 256
for i in s:
a[ord(i)] += 1

b = [0] * 256
for j in t:
b[ord(j)] += 1

return  a == b   　　```

Python:  T: O(n)  S: O(1)

```class Solution:
def isAnagram3(self, s, t):
if len(s) != len(t):
return False
count = collections.defaultdict(int)
for c in s:
count[c] += 1
for c in t:
count[c] -= 1
if count[c] < 0:
return False
return True
```

Python:

```def isAnagram1(self, s, t):
dic1, dic2 = {}, {}
for item in s:
dic1[item] = dic1.get(item, 0) + 1
for item in t:
dic2[item] = dic2.get(item, 0) + 1
return dic1 == dic2　　```

Python:  T: O(nlogn)  S: O(n)

```class Solution:
def isAnagram(self, s, t):
return sorted(s) == sorted(t)
```

C++:

```class Solution {
public:
bool isAnagram(string s, string t) {
if (s.size() != t.size()) return false;
int m[26] = {0};
for (int i = 0; i < s.size(); ++i) ++m[s[i] - 'a'];
for (int i = 0; i < t.size(); ++i) {
if (--m[t[i] - 'a'] < 0) return false;
}
return true;
}
};
```