哈希映射和排序， 用单变量不删除哈希表项目，模拟哈希表长度，字符串转数组，比较数组大小，2 解法求解《面试题 01.02. 判定是否互为字符重排》

var CheckPermutation = function(s1, s2) {
  const n1 = s1.length, n2 = s2.length
  if (n1 !== n2) return false
  const h = new Map
  let diff = 0
  for (let i = 0; i < n1; i++) {
    if ((h.get(s1[i]) || 0) === 0) diff++
    h.set(s1[i], (h.get(s1[i]) || 0) + 1)
    if (h.get(s1[i]) === 0) diff--
    if ((h.get(s2[i]) || 0) === 0) diff++
    h.set(s2[i], (h.get(s2[i]) || 0) - 1)
    if (h.get(s2[i]) === 0) diff--
  }
  return diff == 0
};

var CheckPermutation = function(s1, s2) { // Map 实现
  const n1 = s1.length, n2 = s2.length, h = new Map
  if (n1 !== n2) return false
  for (let i = 0; i < n1; i++) {
    h.set(s1[i], (h.get(s1[i]) || 0) + 1)
    if (h.get(s1[i]) === 0) h.delete(s1[i])
    h.set(s2[i], (h.get(s2[i]) || 0) - 1)
    if (h.get(s2[i]) === 0) h.delete(s2[i])
  }
  return h.size === 0
};

function CheckPermutation(s1: string, s2: string): boolean { // Object 实现
  const n1 = s1.length, n2 = s2.length, h = Object.create(null)
  if (n1 !== n2) return false
  for (let i = 0; i < n1; i++) {
    h[s1[i]] = (h[s1[i]] || 0) + 1
    if (h[s1[i]] === 0) delete h[s1[i]]
    h[s2[i]] = (h[s2[i]] || 0) - 1
    if (h[s2[i]] === 0) delete h[s2[i]]
  }
  return Object.keys(h).length === 0
};

class Solution {
  function CheckPermutation($s1, $s2) {
    $n1 = strlen($s1);
    $n2 = strlen($s2);
    if ($n1 !== $n2) return false;
    $h = [];
    $diff = 0;
    for ($i = 0; $i < $n1; $i++) {
      if ($h[$s1[$i]] == null) $diff++;
      $h[$s1[$i]] = ($h[$s1[$i]] ?? 0) + 1;
      if ($h[$s1[$i]] === 0) $diff--;
      if ($h[$s2[$i]] == null) $diff++;
      $h[$s2[$i]] = ($h[$s2[$i]] ?? 0) - 1;
      if ($h[$s2[$i]] === 0) $diff--;
    }
    return $diff === 0;
  }
}

func CheckPermutation(s1 string, s2 string) bool {
  n1, n2 := len(s1), len(s2)
  if n1 != n2 {
    return false
  }
  h, diff := map[byte]int{}, 0
  for i := 0; i < n1; i++ {
    if h[s1[i]] == 0 {
      diff++
    }
    h[s1[i]]++
    if h[s1[i]] == 0 {
      diff--
    }
    if h[s2[i]] == 0 {
      diff++
    }
    h[s2[i]]--
    if h[s2[i]] == 0 {
      diff--
    }
  }
  return diff == 0 
}

class Solution {
  public boolean CheckPermutation(String s1, String s2) {
    int n1 = s1.length(), n2 = s2.length();
    if (n1 != n2) return false;
    Map<Character, Integer> h = new HashMap<Character, Integer>();
    int diff = 0;
    for (int i = 0; i < n1; i++) {
      if (h.getOrDefault(s1.charAt(i), 0) == 0) diff++;
      h.put(s1.charAt(i), h.getOrDefault(s1.charAt(i), 0) + 1);
      if (h.getOrDefault(s1.charAt(i), 0) == 0) diff--;
      if (h.getOrDefault(s2.charAt(i), 0) == 0) diff++;
      h.put(s2.charAt(i), h.getOrDefault(s2.charAt(i), 0) - 1);
      if (h.getOrDefault(s2.charAt(i), 0) == 0) diff--;
    }
    return diff == 0;
  }
}

public class Solution {
  public bool CheckPermutation(string s1, string s2) {
    int n1 = s1.Length, n2 = s2.Length;
    if (n1 != n2) return false;
    Dictionary<char, int> h = new Dictionary<char, int>();
    int diff = 0;
    for (int i = 0; i < n1; i++) {
      if (h.ContainsKey(s1[i])) {
        if (h[s1[i]] == 0) diff++;
        h[s1[i]]++;
        if (h[s1[i]] == 0) diff--;
      } else {
        h.Add(s1[i], 1);
        diff++;
      }
      if (h.ContainsKey(s2[i])) {
        if (h[s2[i]] == 0) diff++;
        h[s2[i]]--;
        if (h[s2[i]] == 0) diff--;
      } else {
        h.Add(s2[i], -1);
        diff++;
      }
    }
    return diff == 0;
  }
}

typedef struct {
  int key;
  int val;
  UT_hash_handle hh;
} HashItem;
bool CheckPermutation(char* s1, char* s2){
  int n1 = strlen(s1), n2 = strlen(s2);
  if (n1 != n2) return false;
  HashItem* h = NULL;
  int diff = 0;
  for (int i = 0; i < n1; i++) {
    HashItem* pEntry = NULL;
    int i1 = s1[i] - '0';
    HASH_FIND_INT(h, &i1, pEntry);
    if (pEntry == NULL) {
      pEntry = malloc(sizeof(HashItem));
      pEntry->key = i1;
      pEntry->val = 1;
      HASH_ADD_INT(h, key, pEntry);
      diff++;
    } else {
      if (pEntry->val == 0) diff++;
      pEntry->val++;
      if (pEntry->val == 0) diff--;
    }
    int i2 = s2[i] - '0';
    HASH_FIND_INT(h, &i2, pEntry);
    if (pEntry == NULL) {
      pEntry = malloc(sizeof(HashItem));
      pEntry->key = i2;
      pEntry->val = -1;
      HASH_ADD_INT(h, key, pEntry);
      diff++;
    } else {
      if (pEntry->val == 0) diff++;
      pEntry->val--;
      if (pEntry->val == 0) diff--;
    }
  }
  HashItem* cur, *tmp;
  HASH_ITER(hh, h, cur, tmp) {
    HASH_DEL(h, cur);
    free(cur);
  }
  return diff == 0;
}

class Solution {
public:
  bool CheckPermutation(string s1, string s2) {
    int n1 = s1.size(), n2 = s2.size();
    if (n1 != n2) return false;
    unordered_map<char, int> h;
    int diff = 0;
    for (int i = 0; i < n1; i++) {
      if (h[s1[i]] == 0) diff++;
      h[s1[i]]++;
      if (h[s1[i]] == 0) diff--;
      if (h[s2[i]] == 0) diff++;
      h[s2[i]]--;
      if (h[s2[i]] == 0) diff--;
    }
    return diff == 0;
  }
};

class Solution:
  def CheckPermutation(self, s1: str, s2: str) -> bool:
    n1, n2 = len(s1), len(s2)
    if n1 != n2: return False
    h, diff = dict(), 0
    for i in range(0, n1):
      if s1[i] in h:
        if h[s1[i]] == 0: diff += 1
        h[s1[i]] += 1
        if h[s1[i]] == 0: diff -= 1
      else:
        h[s1[i]] = 1
        diff += 1
      if s2[i] in h:
        if h[s2[i]] == 0: diff += 1
        h[s2[i]] -= 1
        if h[s2[i]] == 0: diff -= 1
      else:
        h[s2[i]] = -1
        diff += 1
    return diff == 0

var CheckPermutation = function(s1, s2) { // Split 实现
  const n1 = s1.length, n2 = s2.length
  if (n1 !== n2) return false
  return s1.split('').sort().join('') === s2.split('').sort().join('')
};

function CheckPermutation(s1: string, s2: string): boolean { // 数组实现
  const n1 = s1.length, n2 = s2.length
  if (n1 !== n2) return false
  return Array.from(s1).sort().join('') === Array.from(s2).sort().join('')
};

class Solution {
  function CheckPermutation($s1, $s2) {
    $n1 = strlen($s1);
    $n2 = strlen($s2);
    if ($n1 !== $n2) return false;
    $a1 = str_split($s1);
    $a2 = str_split($s2);
    sort($a1);
    sort($a2);
    return implode('', $a1) === implode('', $a2);
  }
}

func CheckPermutation(s1 string, s2 string) bool {
  n1, n2 := len(s1), len(s2)
  if n1 != n2 {
    return false
  }
  b1, b2 := []byte(s1), []byte(s2)
  sort.SliceStable(b1, func(i, j int) bool {
    return b1[i] < b1[j]
  })
  sort.SliceStable(b2, func(i, j int) bool {
    return b2[i] < b2[j]
  })
  return string(b1) == string(b2)
}

class Solution {
  public boolean CheckPermutation(String s1, String s2) {
    int n1 = s1.length(), n2 = s2.length();
    if (n1 != n2) return false;
    char[] a1 = s1.toCharArray(), a2 = s2.toCharArray();
    Arrays.sort(a1);
    Arrays.sort(a2);
    return Arrays.equals(a1, a2);
  }
}

public class Solution {
  public bool CheckPermutation(string s1, string s2) {
    int n1 = s1.Length, n2 = s2.Length;
    if (n1 != n2) return false;
    char[] a1 = s1.ToCharArray(), a2 = s2.ToCharArray();
    Array.Sort(a1);
    Array.Sort(a2);
    return Enumerable.SequenceEqual(a1, a2);
  }
}

static inline int cmp (const void *pa, const void *pb) {
  return *(char*)pa - *(char*)pb;
}
bool CheckPermutation(char* s1, char* s2){
  int n1 = strlen(s1), n2 = strlen(s2);
  if (n1 != n2) return false;
  qsort(s1, n1, sizeof(char), cmp);
  qsort(s2, n2, sizeof(char), cmp);
  return strcmp(s1, s2) == 0;
}

class Solution {
public:
  bool CheckPermutation(string s1, string s2) {
    int n1 = s1.size(), n2 = s2.size();
    if (n1 != n2) return false;
    sort(s1.begin(), s1.end());
    sort(s2.begin(), s2.end());
    return s1 == s2;
  }
};

class Solution:
  def CheckPermutation(self, s1: str, s2: str) -> bool:
    n1, n2 = len(s1), len(s2)
    if n1 != n2: return False
    return ''.join(sorted(s1)) == ''.join(sorted(s2))