判断字母异位词 --- 华为一面（手撕代码）_异位单词华为机试

• 题目

     给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
  
     注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。
  
     示例 1:
  
     输入: s = "anagram", t = "nagaram"
     输出: true
     示例 2:
  
     输入: s = "rat", t = "car"
     输出: false
      
     提示:
  
     1 <= s.length, t.length <= 5 * 104
     s 和 t 仅包含小写字母
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17

• 代码

       //  方法1: 利用Array.sort()将字符串按字母表顺序排列，最后用全等比较即可。
       var isAnagram = function (s, t) {
           let aa = s.split('').sort().join('');
           let bb = t.split('').sort().join('');
  
           if (aa === bb) {
               return true;
           } else {
               return false;
           }
       };
  
       // 方法2: 使用hash表
       /* 
       字符串： 
           1. xx.charCodeAt(0) 获得某个字符的unicode码
           2. String.fromCharCode(xx) 获得unicode码对应的字符
  
       数组方法： 
          1. for in  / for of 遍历值
          2. some 判断数组每一项，只要一个成立，则返回true
          3. every 判断数组每一项，每一项都成立，返回true
          4. Object.keys获得对象的key值数组， Object.values获得对象的值数组。
  
  
        使用数组，初始化hash表
                let a = [];
                for(let i = 0; i < 26 ; i++) {
                   a[lowercaseAlphabet[i]] = 0;  
                }
       */
  
  
       var isAnagram2 = function (s, t) {
           // 获得小写字母数组，建立hash表
           const CHARCODE_A_LC = 97
           const lowercaseAlphabet = new Array(26)
               .fill(null)
               .map((v, i) => String.fromCharCode(CHARCODE_A_LC + i));
  
           // 1. 使用对象，初始化hash表，{'a':0, 'b':0, .....}
           let map = {};
           for (let v of lowercaseAlphabet) {
               map[v] = 0;
           }
  
           // 2. 遍历s，更新hash表
           for (let val of s) {
               if (map[val] >= 0) {
                   map[val]++;
               }
           }
           // 3. 遍历t, 查询hash表
           for (let val of t) {
               if (map[val] >= 1) {
                   map[val]--;
               }
           }
  
           let cc = Object.values(map); // 获得对象的value值数组：都为0则true，否则为false
           let res = cc.some(val => val !== 0); // 查看是否存在一个不为0的
           if (!res) {
               return true;
           } else {
               return false;
           }
       }
  
       let a = "raat";
       let b = "taar";
       console.log(isAnagram2(a, b));
  
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40
  41
  42
  43
  44
  45
  46
  47
  48
  49
  50
  51
  52
  53
  54
  55
  56
  57
  58
  59
  60
  61
  62
  63
  64
  65
  66
  67
  68
  69
  70
  71
  72

• 不用单独建立hash表，直接一个建表，一个查找

  // 判断是否为异位词: 一个建立索引表，一个负责查找
       var isAnagrams = function (s, t) {
           const hash = [];
           for (let val of s) {
               if (!hash[val]) {
                   hash[val] = 1;
               } else {
                   hash[val]++;
               }
           }
  
           for (let val of t) {
               if (!hash[val]) {
                   return false;
               } else {
                   hash[val]--;
               }
           }
  
           return Object.values(hash).every(val => val == 0); // 当数组的索引修改后，此时hash需要用对象的方法获得vaules数组
       }
  
  
       // 判断两个数组是否相同
  
       var isSameArray = function (a, b) {
           if(a.length == b.length) {
               return a.every((val, index) => val == b[index]);
           }
           return false;
       }
  
       let a = [1,2,3];
       let b = [1,2,3];
       console.log(isSameArray(a,b));
  
  
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37

== 和 === 的区别（补充）

“=="：

1. 两边数据类型相同，则进行"==="比较

2. 两遍数据类型不同，则类型转换后比较：

   - 一个是字符串，一个是数字类型，会将字符串转为数字类型
   - ` '12' == 12
   - null == undefined`
   1
   2
   3

"===":

1. 两边数据类型不同，返回false

2. 类型相同，比较：

   - 两边为数值类型且为同一个值，返回true；
   - 两边为字符类型且对应位置字符相同，返回true；
   - 两边为引用类型且**引用同一个对象或函数**，返回true；
   1
   2
   3