关于LeetCode中Valid Anagram一题的理解

题目如下：

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

For example,
s = "anagram", t = "nagaram", return true.
s = "rat", t = "car", return false.

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

    题干的意思是给定两个字符串s和t，判断这两个字符串是不是同字母异序词。

    我最容易想到的方法是利用HashMap存放每个字符串中每个字母和其出现的次数。我们会使用到两个HashMap，一个用来存放原字符串的信息，另一个用来存放用于比较的另一个字符串的信息。非别通过两次循环设置两个HashMap后，再通过比较相同字符出现的次数是否一样，从而对这两个字符串是否是同字母异序词做出判断。思路大致就是这样，代码如下：

<span style="font-size:14px;">public boolean isAnagram(String s, String t) {
        if(s.length()!=t.length()){
            System.out.println("length not right");
            return false;
        }else{
            Map<String, Integer> originMap = new HashMap<String, Integer>();
            Map<String, Integer> compareMap = new HashMap<String, Integer>();
            ArrayList<String> keyValue = new ArrayList<String>();
            for (int i=0;i<s.length();i++){
                String origin = String.valueOf(s.charAt(i));
                if(!originMap.containsKey(origin)){
                    originMap.put(origin, 1);
                    keyValue.add(origin);
                }else{
                    int newValue = originMap.get(origin)+1;
                    originMap.put(origin, newValue);
                }
            }

            for (int j=0;j<t.length();j++){
                String compare = String.valueOf(t.charAt(j));
                if (!originMap.containsKey(compare)){
                    System.out.println("kind not right");
                    return false;
                }else {
                    if (!compareMap.containsKey(compare)) {
                        compareMap.put(compare, 1);
                    } else {
                        int newComapreValue = compareMap.get(compare) + 1;
                        compareMap.put(compare, newComapreValue);
                    }
                }
            }

            for (int k=0;k<keyValue.size();k++){
                String index = keyValue.get(k);
                if (compareMap.get(index) == null || originMap.get(index).intValue() != compareMap.get(index).intValue()){
                    return false ;
                }
            }
            return true;
        }
    }</span>

    这里要注意的一点，就是在获取到HashMap中对应的value值的时候，如果value值是Integer类型的话是不能直接使用"=="或者"!="判断两个Integer的intValue是否相等的，因为Integer本身是对象，此时“==”判断的是这个两个对象的引用是不是相同，而不是判断本身的值是否相同。所以，我们要先使用intValue()方法取出Integer中的intValue值，然后再使用"=="或者“!=”进行比较。再一个需要注意的是，如果HashMap中不存在某个键，那么使用get(key)方法得到的是一个null值，此时如果再调用intValue()方法程序就会抛出空指针异常，因为你是通过null来调用的intValue()，显然会出现空指针异常。

    上面说了一个自己非常low但是也accepted的方法。下面说几个看起来就好棒棒的方法，这些方法都来自该问题的Editoral Solution。

    首先是使用排序的方法，先将字符串s和字符串t都转化成字符数组，然后将数组中这些char类型的元素进行排序，最后比较这两个排序后的数组是否相等，简直机智，代码如下：

<span style="font-size:14px;">public boolean isAnagram(String s, String t) {
    if (s.length() != t.length()) {
        return false;
    }
    char[] str1 = s.toCharArray();
    char[] str2 = t.toCharArray();
    Arrays.sort(str1);
    Arrays.sort(str2);
    return Arrays.equals(str1, str2);
}</span>

    还有一种方法不需要进行比较操作，只需要利用一个数组两次循环就可以实现，代码如下：

<span style="font-size:14px;">public boolean isAnagram(String s, String t) {
    if (s.length() != t.length()) {
        return false;
    }
    int[] counter = new int[26];
    for (int i = 0; i < s.length(); i++) {
        counter[s.charAt(i) - 'a']++;
        counter[t.charAt(i) - 'a']--;
    }
    for (int count : counter) {
        if (count != 0) {
            return false;
        }
    }
    return true;
}</span>

    由于题干已经说了字符串中只考虑小写的英文字母，所以我们可以声明一个大小为26的数组对应a-z这26个英文字母。开始循环后，如果在s中遇到某字母就在该字母对应的数组位置上进行“加一”操作，如果在t中遇到某字母就在该字母对应的数组位置上进行“减一”操作。所以，如果s和t是同字母异构的话，该数组所有位置上的数值最后的结果都是0。这种方法的时间和空间复杂度都很低，时间复杂度为O(n)，空间复杂度为O(1)，空间复杂度是O(1)因为从始至终数组的大小都没有发生过变化，是一个常量。

    最后附上这些Editoral  Solution的链接：https://leetcode.com/articles/valid-anagram/