有效的字母异位词

题目描述

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

示例 1:

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

示例 2:

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

说明:

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

进阶:

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

解法

方法一：排序算法：

通过将 s 的字母重新排列成 t 来生成变位词。因此，如果 T 是 S 的变位词，对两个字符串进行排序将产生两个相同的字符串。此外，如果 s 和 t 的长度不同，t 不能是 s 的变位词，我们可以提前返回。

import java.util.Arrays;
public class ValidLetterEctopic {
    public static void main(String[] args) {
        ValidLetterEctopic1 validLetterEctopic2 = new ValidLetterEctopic1();
        boolean test = validLetterEctopic2.isAnagram("anagram","nagaram");
        System.out.println(test);
    }

    /**
     * 有效的字母异位词(排序)
     * 给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
     *
     * 示例 1:
     * 输入: s = "anagram", t = "nagaram"
     * 输出: true
     *
     * 思路
     * 通过将 ss 的字母重新排列成 tt 来生成变位词。因此，如果 TT 是 SS 的变位词，对两个字符串进行排序将产生两个相同的字符串。
     * 此外，如果 ss 和 tt 的长度不同，tt 不能是 ss 的变位词，我们可以提前返回。
     *  DuanXS
     */
    static class ValidLetterEctopic1{
        public boolean isAnagram(String s,String t){
            //我们要先判断下  如果s和t的长度不一样，说明是错的直接提前返回
            if (s.length() != t.length()){
                return false;
            }
            //如果s和t的变位词，对于两个字符串进行排序将产生两个相同的字符串
            char[] s1 = s.toCharArray();
            char[] t1 = t.toCharArray();
            Arrays.sort(s1);
            Arrays.sort(t1);
            return Arrays.equals(s1,t1);
        }
    }
}

复杂度分析

时间复杂度：O(n \log n)O(nlogn)，假设 nn 是 ss 的长度，排序成本 O(n\log n)O(nlogn) 和比较两个字符串的成本 O(n)O(n)。排序时间占主导地位，总体时间复杂度为 O(n \log n)O(nlogn)。
空间复杂度：O(1)O(1)，空间取决于排序实现，如果使用 heapsort，通常需要 O(1)O(1) 辅助空间。注意，在 Java 中，toCharArray() 制作了一个字符串的拷贝，所以它花费 O(n)O(n) 额外的空间，但是我们忽略了这一复杂性分析，因为：
这依赖于语言的细节。
这取决于函数的设计方式。例如，可以将函数参数类型更改为 char[]。

方法二：哈希表算法：

 1. 为了检查 tt 是否是 ss 的重新排列，我们可以计算两个字符串中每个字母的出现次数并进行比较。因为 SS 和 TT 都只包含
    A-ZA−Z 的字母，所以一个简单的 26 位计数器表就足够了。
 2. 我们需要两个计数器数表进行比较吗？实际上不是，因为我们可以用一个计数器表计算 ss 字母的频率，用 tt
    减少计数器表中的每个字母的计数器，然后检查计数器是否回到零。

 /**
     * 有效的字母异位词(哈希表)
     * 给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
     *
     * 示例 1:
     * 输入: s = "anagram", t = "nagaram"
     * 输出: true
     *
     * 思路
     * 1.为了检查 tt 是否是 ss 的重新排列，我们可以计算两个字符串中每个字母的出现次数并进行比较。因为 SS 和 TT 都只包含 A-ZA−Z 的字母，所以一个简单的 26 位计数器表就足够了。
     * 2.我们需要两个计数器数表进行比较吗？实际上不是，因为我们可以用一个计数器表计算 ss 字母的频率，用 tt 减少计数器表中的每个字母的计数器，然后检查计数器是否回到零。
     *  DuanXS
     */
    static class ValidLetterEctopic1 {
        public boolean isAnagram(String s, String t) {
            //首先还是判断下s和t长度是否相同  不同  直接pas掉
            if (s.length() != t.length()) {
                return false;
            }
            //这里s和t都是在26个字母里的 我们拿s字母在一个26位的计数器出现的频率，用t的字母计算器减去看是否为0，为0 就成了 否则pas掉
            //根据上面对的分析  我要建一个26位的计数器（数组）
            int[] cou = new int[26];
            // 我们拿s字母在一个26位的计数器出现的频率,用t的字母计算器减去看是否为0，为0 就成了 否则pas掉
            for (int i = 0; i < s.length(); i++) {
                cou[s.charAt(i) - 'a']++;
                cou[t.charAt(i) - 'a']--;
            }
            //检查计数器是否回到零。
            for (int count:cou){
                if (count != 0){
                    return false;
                }
            }
            return true;
        }

有效的字母异位词(哈希表)算法第二种方式

    /**
     * 有效的字母异位词(哈希表)第二种方式
     * 给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
     *
     * 示例 1:
     * 输入: s = "anagram", t = "nagaram"
     * 输出: true
     *
     * 思路
     *或者我们可以先用计数器表计算 ss，然后用 tt 减少计数器表中的每个字母的计数器。如果在任何时候计数器低于零，我们知道 tt 包含一个不在 ss 中的额外字母，并立即返回 FALSE。
     *  DuanXS
     */
    static class ValidLetterEctopic1 {
        public boolean isAnagram(String s,String t){
            //哈哈，第一步我们还是先判断下两者的长度
            if (s.length() != t.length()){
                return false;
            }
            //创建一个26的数组（计步器）
            int [] cou = new int[26];
            //我们可以先用计数器表计算 s
            for (int i = 0; i <s.length() ; i++) {
                cou[s.charAt(i)-'a']++;
            }
            //然后用 t 减少计数器表中的每个字母的计数器。
            for (int i = 0; i <t.length() ; i++) {
                cou[t.charAt(i)-'a']--;
                //t 包含一个不在 s 中的额外字母，并立即返回 FALSE
                if (cou[t.charAt(i)-'a'] < 0){
                    return false;
                }
            }
            return false;
        }
    }

复杂度分析

时间复杂度：O(n)O(n)。时间复杂度为 O(n)O(n) 因为访问计数器表是一个固定的时间操作。
空间复杂度：O(1)O(1)。尽管我们使用了额外的空间，但是空间的复杂性是 O(1)O(1)，因为无论 NN 有多大，表的大小都保持不变。

进阶：

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

解答：

使用哈希表而不是固定大小的计数器。想象一下，分配一个大的数组来适应整个 Unicode 字符范围，这个范围可能超过 100万。哈希表是一种更通用的解决方案，可以适应任何字符范围。