242.有效的字母异位

解法1 数组模拟哈希表

下边分别用到了两种新建数组的方法，数组法1的运行时间要更快。

int counts[26] = {0};//26个元素都初始化为0。
int *data = new int[26]();//26个值初始化为0的int

• 数组法1

class Solution {
public:
    bool isAnagram(string s, string t) {
        if (s.length() != t.length()) return false;
        int n = s.length();
        int counts[26] = {0};
        for (int i = 0; i < n; i++) { 
            counts[s[i] - 'a']++;
            counts[t[i] - 'a']--;
        }
        for (int i = 0; i < 26; i++)
            if (counts[i]) return false;
        return true;
    }
};
https://leetcode.com/problems/valid-anagram/discuss/66519/2-C%2B%2B-Solutions-with-Explanations

• 数组法2

思路：此题只需要需要找两个字符串是否字母异构，这个异构是没有任何限制的，意思就是两个字符串只要能找到一种重新排序方法把使得两个字符串相等就好，这意味着，只需要两个字符串中各个字母个数相同即可，顺序无所谓，所以我们只需要一个数组记录一个字符串各个字母的个数，然后再遍历另一个数组，遇到一个字母就把对应字母个数减一，如果为负了就说明字母个数不一样。此题只需要创建一个数组就行了，单数数组必须进行初始化，在c++中单纯创建一个数组内部是没有初始化的，但是 int* data = new int26;这个括号就代表了告诉编译器要初始化，所以是个小技巧，大家可以记住，面试也常考。

class Solution {
public:
    bool isAnagram(string s, string t) {
          int *data = new int[26]();
          int n = s.length();
          int m = t.length();
          int temp;
          if(n!=m) return false;
          for(int i = 0;i<m;i++)
          {
              temp = s.at(i);//均返回指定的下标位置的字符
              data[temp-'a']++;
          }
              
          for(int i = 0;i<n;i++){
              temp = t.at(i);
              data[temp-'a']--;
              if(data[temp-'a']<0) return false;
          }
        return true;
    }
};
作者：heroine-yun
链接：https://leetcode-cn.com/problems/valid-anagram/solution/shu-zu-xiao-ji-qiao-by-vailing/

解法2 哈希表

下边两个代码，运行时间后者优于前者。

class Solution {
public:
    bool isAnagram(string s, string t) {
        if (s.size() != t.size()) {
            return false;
        }
        unordered_map<int, int> umap;
        for (char ch : s) {
            ++umap[ch];
        }
        for (char ch : t) {
            if (umap[ch] > 0) {
                --umap[ch];
            } else {
                return false;
            }
        }
        return true;
    }
};
作者：guohaoding
链接：https://leetcode-cn.com/problems/valid-anagram/solution/242-you-xiao-de-zi-mu-yi-wei-ci-liang-chong-fang-f/

class Solution {
public:
    bool isAnagram(string s, string t) {
        if (s.size() != t.size()) {
            return false;
        }
        unordered_map<char, int> umap;
        for (int i = 0; i < s.size(); ++i) {
            ++umap[s[i]];
            --umap[t[i]];
        }
        for (auto c : umap) {
            if (c.second != 0) {
                return false;
            }
        }
        return true;
    }
};
作者：guohaoding
链接：https://leetcode-cn.com/problems/valid-anagram/solution/242-you-xiao-de-zi-mu-yi-wei-ci-liang-chong-fang-f/

解法3 vector模拟哈希表

class Solution {
public:
    bool isAnagram(string s, string t) {
        if (s.size() != t.size()) {
            return false;
        }
        vector<int> hash(26);//这里不用初始化为零码？？
        int size = s.size();
        for (int i = 0; i < size; ++i) {
            ++hash[s[i] - 'a'];
            --hash[t[i] - 'a'];
        }
        for (int n : hash) {
            if (n != 0) {//遍历hash,如果存在不为零的元素，即失败
                return false;
            }
        }
        return true;
    }
};

作者：guohaoding
链接：https://leetcode-cn.com/problems/valid-anagram/solution/242-you-xiao-de-zi-mu-yi-wei-ci-liang-chong-fang-f/

解法4 暴力法(sort)

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;
    }
};
作者：guohaoding
链接：https://leetcode-cn.com/problems/valid-anagram/solution/242-you-xiao-de-zi-mu-yi-wei-ci-liang-chong-fang-f/

C++知识点

1.新建数组方法

int counts[26] = {0};//26个元素都初始化为0。
int *data = new int[26]();//26个值初始化为0的int

下边区别在于，
int *p1 = new int[10];  //10个未初始化int型元素的数组所占空间，并将该数组的第一个元素的地址赋给int 型指针p。
int *p2 = new int[10](); // 10个值初始化为0的int
int *p3 = new int(10);//分配一个int型变量所占大小的空间，在其中放入十进制数10，并将首地址赋给int 型指针p。
int *p4 = new int;//——分配一个int型变量所占大小的空间，并将首地址赋给int 型指针p。

2.字母变数字
‘a’~'z’变成数字0 ~ 25

s[i] - 'a'

同理，0 ~ 25 也可以变成 ‘a’~‘z’

数字 + 'a'

3.vector新建

vector<int> a(10); //定义了10个整型元素的向量（尖括号中为元素类型名，它可以是任何合法的数据类型），但没有给出初值，其值是不确定的。
vector<int> a(10,1); //定义了10个整型元素的向量,且给出每个元素的初值为1

4.map基本操作

for (auto c : umap) {
	if (c.second != 0) {
		return false;
	}
}

c++ 里面的map容器的迭代器里面 有个first 和 second
例如
map<string, int> m;
m[“one”] = 1;
map<string, int>::iterator p = m.begin();
p->first; // 这个是 string 值是 “one”
p->second; //这个是 int 值是 1
原文链接：https://blog.csdn.net/myachilies/article/details/8872111

4.string获取字符串元素

https://blog.csdn.net/Pizza_Lawson/article/details/86155394

字符串中元素的访问是允许的，一般可使用两种方法访问字符串中的单一字符：下标操作符[] 和 成员函数at()。两者均返回指定的下标位置的字符。第 1 个字符索引（下标）为 0，最后的字符索引为 length()-1。

需要注意的是，这两种访问方法是有区别的：

• 下标操作符 [] 在使用时不检查索引的有效性，如果下标超出字符的长度范围，会示导致未定义行为。对于常量字符串，使用下标操作符时，字符串的最后字符（即 ‘\0’）是有效的。对应 string 类型对象（常量型）最后一个字符的下标是有效的，调用返回字符 ‘\0’。
• 函数 at() 在使用时会检查下标是否有效。如果给定的下标超出字符的长度范围，系统会抛出 out_of_range 异常。