LeetCode_242.有效的字母异位词（哈希表）

题目：

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

示例 1:

输入: s = “anagram”, t = “nagaram”
输出: true

示例 2:

输入: s = “rat”, t = “car”
输出: false
说明:
你可以假设字符串只包含小写字母。

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/valid-anagram
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

总结：
这种比较两个字符串类型的问题，一种方法是先将两个字符串分别“a to z”排序，然后比较整个字符串；另一种方法是使用哈希表统计字符串中每个字符（元素）的出现次数，然后依次比较每个字符（元素）的次数是否都相同。

一个小技巧是 比较两个字符串中的字符时不必使用两趟循环分别统计次数，只需使用一次循环，在循环中对一个字符串中的字符加操作，另一个字符串中的字符减操作。

解法一：排序+字符串比较

时间复杂度： O(n) //排序
空间复杂度： O(1)

class Solution {
public:
    bool isAnagram(string s, string t) {
        if(s.size() != t.size()) return false;
        sort(s.begin(), s.end());
        sort(t.begin(), t.end());
        return s == t; //string类型支持==操作
    }
};

解法二：用数组模拟哈希表

时间复杂度： O(n) //循环
空间复杂度： O(n) //数组

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

解法三：map哈希表

时间复杂度： O(n) //循环
空间复杂度： O(n) //map

class Solution {
public:
    bool isAnagram(string s, string t) {
        if(s.size() != t.size()) return false;
        map<char, int> m;
        for(int i = 0; i < s.size(); ++i) {
            ++m[s[i] - 'a'];
            --m[t[i] - 'a'];
        }
        for(auto iter = m.begin(); iter != m.end(); ++iter) {
            if(iter->second != 0) return false;
        }
        return true;
    }
};

题外话：

哈希表的一些概念：

创造哈希表这种数据结构的目的：

以空间换时间的方式，将查找时间从O(n)降低到O(1)。

什么是哈希碰撞：

不同的元素经过哈希函数的计算后，得到的是哈希表中的一个相同的位置，这个两个元素就发生了哈希碰撞。

如何解决哈希碰撞：

拉链式解决。

在发生碰撞的哈希表元素位置拉出一个链表，用来存储同一位置的不同元素。
当链表很长时，哈希表的查找的时间复杂度就会退化成O(n)。
因此，设计一个好的哈希函数比较关键，尽量将元素都散列到不同的位置上去。

因为现在计算机的内存越来越大， 并且STL等这些优秀的库中选用的哈希函数性能比较好，所以可以近似的认为哈希表的查找时间复杂度就是O(1)。

map、set 与 unordered_map、unordered_set 的区别：

map、set的底层数据结构是二叉搜索树（Binary Search Tree，bst），树具有自动排序的功能，map中的元素有序，树的查找的时间复杂度是 O(logN)，适用于那些对元素顺序有要求的问题，缺点是树的实现占用的内存大（树结构每个结点需要额外保存父结点、子结点、以及每个结点的红黑性质）；

unordered_map、unordered_set的内部实现了一个哈希表，元素是无序的，查找的时间复杂度是O(1)，适用于查找类的问题，优点是查找速度快，缺点是哈希表的建立比较耗时。

map与unordered_map都支持iterator迭代器访问。