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.

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

對於這道題，想到以下思路：

思路1：//最容易想到的是，兩個循環嵌套，把字符串s拆成一個一個字符拿去和字符串t比較，若t中有，則剔除掉該字符。（時間復雜度為O（n^2））不推薦
思路2：//更簡單的是，使用java內置的排序，然後判斷字符串是否相等，也比較慢
思路3：//想多一步，用桶排序的思想，利用空間換時間，可以使時間復雜度達到O（n）

思路1比較簡單，就不做過多的闡述。

思路2：先利用內置排序，使得字符數組有序，然後合成兩個新的字符串，然後判斷這兩個新的字符串是否相等，即可判斷是否是Anagram

代碼如下：

    public boolean isAnagram(String s, String t) {
        
 
if(s.length()!=t.length()) return false;     
         if(s.length()==0&&t.length()==0) return true;    
        String [] sa=new String[s.length()];
        String [] ta=new String[s.length()];
        for(int i=0;i<s.length();i++)
        {
            sa[i]=s.substring(i,i+1);  
            ta[i]
 
=t.substring(i,i+1);
        }
        Arrays.sort(sa);
        Arrays.sort(ta);
        s=null;
        t=null;
        for(int i=0;i<sa.length;i++)
        {
            s=sa[i]+s;
            t=ta[i]+t;
        }
        if(s.equals(t))
            return true;
        return false;

   }

思路3：

利用桶排序，聲明兩個26個單位的數組，當字母出現的時候，相應數組位置加一，最後判斷相應位置是否等值，即可判斷出結果。

 public boolean isAnagram(String s, String t) {
        if(s.length()!=t.length()) return false;     
        int[] team1=new int[26];
        int[] team2=new int[26];
        char[] cs=s.toCharArray();
        char[] ct=t.toCharArray();
        for(int i=0;i<s.length();i++)
        {
                team1[cs[i]-‘a‘]+=1;
                team2[ct[i]-‘a‘]+=1;
        }
    for(int i=0;i<26;i++)
           if(team1[i]!=team2[i])
               return false;
        return true;
    }

思路3的變體：

在s中出現的字符就在相應的位置加一，在t中出現的字符就在相應的位置減一，最後判斷結果是否為0就可以判斷是否是Anagram，這樣可以省去一個數組的空間。

  public boolean isAnagram(String s, String t) {
        if(s.length()!=t.length()) return false;     
        int[] team=new int[26];
        char[] cs=s.toCharArray();
        char[] ct=t.toCharArray();
        for(int i=0;i<s.length();i++)
                team[cs[i]-‘a‘]+=1;
        for(int i=0;i<s.length();i++)
                team[ct[i]-‘a‘]-=1;
    for(int i=0;i<26;i++)
           if(team[i]!=0)
               return false;
        return true;
    }

242. Valid Anagram(leetcode)