Hash Table on Hang Zhang

Isomorphic Strings

Wed, 15 Jan 2025 00:00:00 +0000

205. 同构字符串

分析

双向映射：
- 用两个哈希表建立双向映射关系。
  - st：记录从 s 到 t 的映射
  - ts：记录从 t 到 s 的映射
逐字符映射检查：
- 遍历字符串，检查每一对字符是否满足映射规则：
  - 如果 s[i] 已经映射到某个字符，但不是 t[i]，则返回 false
  - 如果 t[i] 已经映射到某个字符，但不是 s[i]，则返回 false
合法映射：
- 如果遍历结束都没有冲突，返回 true

时间复杂度

总时间复杂度 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    bool isIsomorphic(string s, string t)
    {
        // 1. 创建两个哈希表：s -> t 和 t -> s
        std::unordered_map<char, char> st, ts;

        // 2. 遍历字符串
        for (int i = 0; i < s.size(); ++i)
        {
            char a = s[i], b = t[i];

            // 3. 检查 s -> t 的映射关系是否冲突
            if (st.count(a) && st[a] != b)
                return false;

            // 4. 建立 s -> t 的映射
            st[a] = b;

            // 5. 检查 t -> s 的映射关系是否冲突
            if (ts.count(b) && ts[b] != a)
                return false;

            // 6. 建立 t -> s 的映射
            ts[b] = a;
        }

        // 7. 映射无冲突，返回 true
        return true;
    }
};

Ransom Note

Wed, 15 Jan 2025 00:00:00 +0000

383. 赎金信

分析

构建字符频率表
- 遍历 magazine，统计每个字符出现的次数。
逐字符匹配
- 如果 hash[c] > 0，说明字符可用，使用后数量减 1
- 如果 hash[c] == 0，说明字符不足，返回 false
全部匹配成功
- 如果遍历完 ransomNote 没有提前返回 false，则说明可以成功构造，返回 true

时间复杂度

时间复杂度 O(n + m)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    bool canConstruct(string ransomNote, string magazine)
    {
        // 1. 统计 magazine 中字符的频率
        std::unordered_map<char, int> hash;
        for (char c : magazine)
            ++ hash[c];  // 每个字符的出现次数

        // 2. 遍历 ransomNote，检查字符是否足够
        for (char c : ransomNote)
        {
            if (hash[c] > 0)
                --hash[c];  // 使用一个字符，数量减少
            else
                return false;  // 不足时，直接返回 false
        }

        // 3. 所有字符都有足够数量，返回 true
        return true;
    }
};

Word Pattern

Wed, 15 Jan 2025 00:00:00 +0000

290. 单词规律

分析

分割字符串：
- 将字符串 s 按空格分割成单词列表 words
长度判断：
- 如果 pattern 的长度 ≠ words 的数量，直接返回 false
建立双向映射：
- 使用两个哈希表：
  - ps：pattern 的字符 → s 的单词
  - sp：s 的单词 → pattern 的字符
遍历检查：
- 遍历 pattern 和 words：
  - 如果 ps 中字符的映射与当前单词不一致，返回 false
  - 如果 sp 中单词的映射与当前字符不一致，返回 false
  - 否则建立新的映射关系。
全部检查通过，返回 true

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    bool wordPattern(string pattern, string s)
    {
        std::vector<std::string> words;

        // 1. 将 s 按空格分割成单词
        for (int i = 0; i < s.size(); ++i)
        {
            int j = i + 1;
            while (j < s.size() && s[j] != ' ')  // 找到单词的结束位置
                ++ j;
            words.push_back(s.substr(i, j - i));  // 提取单词
            i = j;  // 移动到下一个单词
        }

        // 2. 长度不一致，直接返回 false
        if (pattern.size() != words.size())
            return false;

        // 3. 建立双向映射
        std::unordered_map<char, std::string> ps;  // pattern → word
        std::unordered_map<std::string, char> sp;  // word → pattern

        // 4. 遍历 pattern 和 words
        for (int i = 0; i < pattern.size(); ++i)
        {
            char a = pattern[i];
            std::string b = words[i];

            // 5. 检查 pattern → word 映射
            if (ps.count(a) && ps[a] != b)
                return false;
            ps[a] = b;

            // 6. 检查 word → pattern 映射
            if (sp.count(b) && sp[b] != a)
                return false;
            sp[b] = a;
        }

        // 7. 映射关系正确，返回 true
        return true;
    }
};

groupAnagrams

Mon, 25 Nov 2024 00:00:00 +0000

49. 字母异位词分组

算法

核心思想：
- 字母异位词在字母排序后，其排序结果是相同的。例如：
- "eat" 和 "tea" 排序后都为 "aet"
- 因此，可以将排序后的字符串作为键，将所有字母异位词分组存储在一个哈希表中
步骤：
- 遍历字符串数组，对每个字符串进行排序，得到其标准形式
- 将排序后的字符串作为键，将原始字符串加入到对应的哈希表键值中
- 遍历哈希表，提取所有的值（即字母异位词组）

复杂度分析

时间复杂度

排序：
- 每个字符串排序的时间复杂度为 O(klogk) ，其中 k 是字符串的平均长度
- 总的排序复杂度为 O(n * klogk) ，其中 n 是字符串数组的大小
哈希表操作：
- 插入和查找操作的平均复杂度为 O(1)
总时间复杂度为 O(n * klogk)

空间复杂度

哈希表存储：需要存储排序后的字符串和对应的原始字符串列表，空间复杂度为 O(n * k)
额外字符串副本：排序时需要创建字符串副本，额外空间复杂度为 O(k)
总空间复杂度为 O(n * k)

C++ 代码

class Solution {
public:
    std::vector<std::vector<std::string>> groupAnagrams(std::vector<std::string>& strs)
    {
        std::vector<std::vector<std::string>> res;  // 存储最终结果
        std::unordered_map<std::string, std::vector<std::string>> hash; // 哈希表用于分组

        // 遍历字符串数组
        for (string str : strs)
        {
            std::string word = str;          // 创建副本以便排序
            std::sort(word.begin(), word.end()); // 排序字符串
            hash[word].push_back(str);  // 将原始字符串加入对应组
        }

        // 遍历哈希表，将值部分（分组结果）加入结果
        for (auto e : hash)
            res.push_back(e.second);

        return res;  // 返回分组后的结果
    }
};

Python 代码

class Solution:
  def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
    hash_map = {}
    for s in strs:
      key = "".join(sorted(s))
      if key not in hash_map:
        hash_map[key] = []
      hash_map[key].append(s)
    return list(hash_map.values())

Go 代码

func groupAnagrams(strs []string) [][]string {
  res := [][]string{}
  hash_map := make(map[string][]string)

  for _, str := range strs {
    word := []byte(str)
    sort.Slice(word, func(i, j int) bool {
      return word[i] < word[j]
    })
    key := string(word)
    hash_map[key] = append(hash_map[key], str)
  }

  for _, group := range hash_map {
    res = append(res, group)
  }

  return res
}

JavaScript 代码

/**
 * @param {string[]} strs
 * @return {string[][]}
 */
var groupAnagrams = function (strs) {
  let hash = new Map();

  for (let str of strs) {
    let key = str.split("").sort().join("");
    if (!hash.has(key)) {
      hash.set(key, []);
    }
    hash.get(key).push(str);
  }

  return Array.from(hash.values());
};

LRUCache

Sun, 24 Nov 2024 00:00:00 +0000

31. LRUCache

分析

LRU（Least Recently Used）是一种缓存替换策略，淘汰最久未被使用的数据，以保证缓存内存的有效利用率

核心数据结构：
- 双向链表：维护缓存访问顺序，最新使用的数据放在链表头，最久未使用的数据放在链表尾。双向链表的插入和删除操作可以在 O(1) 时间内完成，适用于缓存频繁更新的场景
- 哈希表：通过关键字快速定位链表中的节点
get(key)：
- 若 key 存在，将对应节点移动到链表头，并返回其值
- 若 key 不存在，返回 -1
put(key, value)：
- 若 key 已存在，更新其值并移动到链表头
- 若 key 不存在：
- 如果缓存已满，删除链表尾的节点（最久未使用）
- 将新节点插入到链表头

时间复杂度

get(key)：O(1)
- 哈希表查找节点是 O(1) ，双向链表操作也是 O(1)
put(key, value)：O(1)
- 哈希表插入和删除是 O(1) ，双向链表操作也是 O(1)

空间复杂度

哈希表和双向链表的空间复杂度均为 O(n) ，其中 n 是缓存容量

C++代码

class LRUCache {
public:
    // 定义双向链表节点
    struct Node
    {
      Node(int key, int value)
        : m_key(key), m_value(value)
        , prev(nullptr), next(nullptr)
      {}

      int m_key, m_value;
      Node *prev, *next;
    };

    int n;                                 // 缓存容量
    Node *head, *tail;                     // 双链表的虚拟头节点
    std::unordered_map<int, Node*> hash;   // 哈希表，快速查找节点

    // 初始化 LRU 缓存
    LRUCache(int capacity)
    {
      n = capacity;
      head = new Node(-1, -1);             // 创建虚拟头节点
      tail = new Node(-1, -1);             // 创建虚拟尾节点
      head->next = tail;                   // 初始化双向链表
      tail->prev = head;
    }

    // 从链表中删除指定节点
    void remove(Node* cur)
    {
      cur->next->prev = cur->prev;
      cur->prev->next = cur->next;
    }

    // 在链表头部插入指定节点
    void insert(Node* cur)
    {
      cur->next = head->next;
      cur->prev = head;
      head->next->prev = cur;
      head->next = cur;
    }

    // 获取节点的值
    int get(int key)
    {
      if (!hash.count(key))                 // 节点不存在
        return -1;
      Node* cur = hash[key];                // 定位节点
      remove(cur);                          // 更新节点在链表中的位置
      insert(cur);
      return cur->m_value;
    }

    // 插入或更新节点
    void put(int key, int value)
    {
      if (hash.count(key))                  // 节点已存在
      {
        Node* cur = hash[key];
        cur->m_value = value;               // 更新节点值
        remove(cur);                        // 更新节点位置
        insert(cur);
      }
      else                                  // 节点不存在
      {
        if (hash.size() == n)               // 缓存已满
        {
          Node* cur = tail->prev;           // 取出尾节点
          remove(cur);                      // 从链表中移除
          hash.erase(cur->m_key);           // 从哈希表中删除
        }
        Node* cur = new Node(key, value);   // 创建新节点
        insert(cur);                        // 插入链表头
        hash[key] = cur;                    // 添加到哈希表
      }
    }
};