每日一恋 - LeetCode 242. Valid Anagram（有效的字母异位词）

题目描述

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

Example 1:

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

Example 2:

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

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

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

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的一个字母异位词。

示例 1:

输入: s = "anagram", t = "nagaram"
输出: true

示例 2:

输入: s = "rat", t = "car"
输出: false

说明:
你可以假设字符串只包含小写字母。

进阶:
如果输入字符串包含 unicode 字符怎么办？你能否调整你的解法来应对这种情况？

解法一（Sorting）：

我们知道，字母异位词是一种重新排列的字母字符串，它们的长度相同，但是顺序可以不同。因此，如果将两者排序，那么排序后的字符串一定是相等的；其次，如果传入的两个字符串的长度不同，就不需要做后续的处理了。

  public boolean isAnagram(String s, String t) {
        if (s.length() != t.length())
            return false;
        char[] sc = s.toCharArray();
        char[] tc = t.toCharArray();
        Arrays.sort(sc);
        Arrays.sort(tc);
        return Arrays.equals(sc, tc);
    }

时间复杂度：$O(nlogn)$，假设 n 是 s 的长度，Arrays.sort() 是一个双路快速排序，时间复杂度是$O(nlogn)$，比较两个字符串是否相等是$O(n)$。
空间复杂度：$O(n)$，空间复杂度基于具体的排序实现方式，如果是堆排序，空间复杂度就是$O(1)$。Java 的 toCharArray()会进行一次字符串的拷贝，此时间复杂度$O(n)$：

• 与具体语言有关。
• 基于函数的参数类型，比如，函数的参数类型为 char[]。

解法二（Hash Table）：

为了确定 t 到底是不是一个 s 重排序后的字符串，我们可以统计每个字符出现的次数，然后比较它们。因为题目说明可以假设只有小写字母，一个 26 大小的统计数组就已经足够了。

那么我们是否需要开辟两个数组来比较呢？当然不用，其实可以只用一个数组即可，只要做一次 s 字符串长度的循环，当 s 中的字符出现一次，就增加 hash 数组中的值，当 t 中的字符出现一次，就减少 hash 数组中的值，最后检查 hash 数组中的元素是否都是 0 即可。

public boolean isAnagram(String s, String t) {
    if (s.length() != t.length())
        return false;
    if (s.length() == 0)
        return true;

    int[] hash = new int[26];
    int n = s.length();
    // hash 最后中每一个字符都是 0，则是异位词。
    for (int i = 0 ; i < n ; i ++) {
        hash[s.charAt(i) - 'a'] ++;
        hash[t.charAt(i) - 'a'] --;
    }
    for (int p : hash)
        if (p != 0)
            return false;
    return true;
}

或者可以先处理 s 字符串，然后处理 t 字符串。如果 hash 数组对应的值小于 0 ，那么说明不匹配，可以直接返回了。

public boolean isAnagram(String s, String t) {
    if (s.length() != t.length())
        return false;
    int[] hash = new int[26];
    for (char c : t.toCharArray())
        hash[c - 'a'] ++;
    for (char c : s.toCharArray())
        if (--hash[c - 'a'] < 0)
            return false;
    return true;
}

时间复杂度：$O(n)$，这里处理 hash 数组是一个常数时间的操作。
空间复杂度：$O(1)$，尽管使用了额外的空间，但是因为 hash 数组的大小与 n 有多大毫无关系。

进阶:

如果输入字符串包含 unicode 字符怎么办？你能否调整你的解法来应对这种情况？

我们知道，unicode 字符将世界上所有的符号都纳入其中。每一个符号都给予一个独一无二的编码，现在的规模可以容纳100多万个符号。因此如果使用固定大小的计数数组，就会造成非常大的空间浪费。因此哈希表是一种更通用的解决方案，可以适应任何范围的字符。

使用 HashMap 的代码

public boolean isAnagram(String s, String t) {
    if (s.length() != t.length())
        return false;
    HashMap<Character, Integer> map = new HashMap<>();
    for (char c : t.toCharArray())
        if (map.get(c) == null)
            map.put(c, 1);
        else
            map.put(c, 1 + map.get(c));
    for (char c : s.toCharArray())
        if (!map.containsKey(c) || map.get(c) == 0)
            return false;
        else
            map.put(c, map.get(c) - 1);
    return true;
}