Hash on Hang Zhang

Minimum Distance to the Target Element

Thu, 16 Apr 2026 00:00:00 +0000

1848. Minimum Distance to the Target Element

Algorithm Steps

Iterate nums and store the indices of all elements that satisfy nums[i] == target in pos
Iterate pos, calculate the minimum abs(i - start)

Complexity Analysis

Time complexity: O(n)

Space complexity: O(n)

C++ Code

class Solution {
public:
    int getMinDistance(vector<int>& nums, int target, int start) {
        std::vector<int> pos;

        // record all indices that satisfy nums[i] == target
        for (int i = 0; i < nums.size(); i ++ )
            if (nums[i] == target)
                pos.push_back(i);

        int res = INT_MAX;

        // find minimum distance
        for (int x: pos)
            res = std::min(res, std::abs(x - start));

        return res;
    }
};

Python Code

class Solution:
    def getMinDistance(self, nums: List[int], target: int, start: int) -> int:
        pos = []
        for i, x in enumerate(nums):
            if x == target:
                pos.append(i)

        res = float('inf')
        for x in pos:
            res = min(res, abs(x - start))

        return res

Go Code

func getMinDistance(nums []int, target int, start int) int {
    pos := []int{}
    for i, x := range nums {
        if x == target {
            pos = append(pos, i)
        }
    }

    res := math.MaxInt
    for _, x := range pos {
        t := x - start
        if t < 0 {
            t = -t
        }
        res = min(res, t)
    }

    return res
}

JavaScript Code

/**
 * @param {number[]} nums
 * @param {number} target
 * @param {number} start
 * @return {number}
 */
var getMinDistance = function (nums, target, start) {
  let pos = [];
  for (let i = 0; i < nums.length; i++) {
    if (nums[i] === target) {
      pos.push(i);
    }
  }

  let res = Infinity;
  for (let x of pos) {
    res = Math.min(res, Math.abs(x - start));
  }

  return res;
};

Minimum Distance Between Three Equal Elements I

Sat, 11 Apr 2026 00:00:00 +0000

3740. Minimum Distance Between Three Equal Elements I

Algorithm Steps

Use map<int, vector<int>> to record all the indices of each element
For each index array p
- Enumerate the length >= 3
- Calculate (p[i] - p[i-2]) * 2
Take the minimum value

Complexity Analysis

Time complexity: O(n)

Space complexity: O(n)

Cpp Code

class Solution {
public:
    int minimumDistance(vector<int>& nums) {
        std::unordered_map<int, std::vector<int>> f;
        for (int i = 0; i < nums.size(); ++ i)
            f[nums[i]].push_back(i); // record all the indices of each element

        int res = INT_MAX;
        for (auto [_, p] : f) // iterate each index array
            for (int i = 2; i < p.size(); ++ i)
                res = std::min(res, (p[i] - p[i - 2]) * 2); // calculate minimum distance = 2 * (k - i)

        return res == INT_MAX ? -1 : res;
    }
};

Python Code

class Solution:
    def minimumDistance(self, nums: List[int]) -> int:
        f = {}
        for i, x in enumerate(nums):
            if x not in f:
                f[x] = []
            f[x].append(i)

        res = float('inf')
        for p in f.values():
            for i in range(2, len(p)):
                res = min(res, (p[i] - p[i - 2]) * 2)

        return -1 if res == float('inf') else res

Go Code

func minimumDistance(nums []int) int {
    f := make(map[int][]int)
    for i := 0; i < len(nums); i ++ {
        f[nums[i]] = append(f[nums[i]], i)
    }

    INF := 0x3f3f3f3f
    res := INF
    for _, p := range f {
        for i := 2; i < len(p); i ++ {
            if (p[i] - p[i - 2]) * 2 < res {
                res = (p[i] - p[i - 2]) * 2
            }
        }
    }

    if res == INF {
        return -1
    }

    return res
}

JavaScript Code

/**
 * @param {number[]} nums
 * @return {number}
 */
var minimumDistance = function (nums) {
  let f = new Map();
  for (let i = 0; i < nums.length; i++) {
    if (!f.has(nums[i])) f.set(nums[i], []);
    f.get(nums[i]).push(i);
  }

  let res = Infinity;
  for (let p of f.values()) {
    for (let i = 2; i < p.length; i++) {
      res = Math.min(res, (p[i] - p[i - 2]) * 2);
    }
  }

  return res == Infinity ? -1 : res;
};

Intersection of Two Arrays

Sat, 01 Mar 2025 00:00:00 +0000

349. 两个数组的交集

分析

将 nums1 中的元素插入到哈希集合中
遍历 nums2，对于每一个元素，如果该元素在哈希集合中存在，就表示它是 nums1 和 nums2 的交集中的元素
每次发现交集元素时，将其添加到结果数组 res 中，并从哈希集合中删除该元素，以保证结果中不包含重复元素

时间复杂度

时间复杂度 O(n + m)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2)
    {
        std::unordered_set<int> hash;  // 用于存储 nums1 中的元素
        std::vector<int> res;           // 用于存储交集的结果

        // 将 nums1 中的所有元素插入到哈希集合中
        for (int x : nums1)
            hash.insert(x);

        // 遍历 nums2，如果元素存在于哈希集合中，则表示是交集的一部分
        for (int x : nums2)
            if (hash.count(x))  // 查找 x 是否在哈希集合中
            {
                res.push_back(x);  // 将交集元素添加到结果中
                hash.erase(x);     // 删除该元素，避免重复添加
            }

        return res;  // 返回交集结果
    }
};

Word Ladder

Fri, 31 Jan 2025 00:00:00 +0000

127. 单词接龙

分析

构建字典集合
- 将 wordList 存入哈希集合 S 中，方便快速判断单词是否存在
BFS 初始化
- 用 queue 队列维护当前单词，初始化队列并记录 beginWord 的距离为 0
- 用哈希表 dist 记录每个单词到 beginWord 的最短路径长度
BFS 遍历
- 每次从队列中取出当前单词 cur，尝试修改它的每一位字符
- 对每个字符位置，从 ‘a’ 到 ‘z’ 枚举替换，形成新单词 temp
  - 如果 temp 在字典中且未被访问过：
    - 更新 dist[temp] = dist[cur] + 1，并将其加入队列
    - 如果 temp 等于 endWord，返回转换次数 dist[temp] + 1
终止条件
- 如果 BFS 遍历结束仍未找到 endWord，返回 0

时间复杂度

总时间复杂度 O(L * 26 * N)，L 是单词长度，26 是字母表大小，N 是字典中单词数量

空间复杂度

空间复杂度为 O(N)

C++代码

class Solution
{
public:
    int ladderLength(string beginWord, string endWord, vector<string>& wordList)
    {
        // 存储字典单词集合
        std::unordered_set<std::string> S;
        for (std::string word : wordList)
            S.insert(word);

        // 记录单词到起点的最短路径长度
        std::unordered_map<std::string, int> dist;
        dist[beginWord] = 0;

        std::queue<std::string> q;
        q.push(beginWord);

        while (!q.empty())
        {
            std::string cur = q.front();
            q.pop();

            // 枚举每个字符位置进行替换
            for (int i = 0; i < cur.size(); ++i)
            {
                std::string temp = cur;
                for (char j = 'a'; j <= 'z'; ++j)
                {
                    temp[i] = j; // 修改第 i 位字符
                    if (S.count(temp) && !dist.count(temp))
                    {
                        dist[temp] = dist[cur] + 1;
                        if (temp == endWord)
                            return dist[temp] + 1; // 返回结果
                        q.push(temp);
                    }
                }
            }
        }
        return 0; // 无法转换
    }
};

Minimum Genetic Mutation

Fri, 24 Jan 2025 00:00:00 +0000

433. 最小基因变化

分析

数据准备
- 将基因库 bank 存入一个哈希集合 gene 中，方便快速判断某个基因序列是否有效
- 用哈希表 hash 记录每个基因序列的访问状态及其变化次数
初始化 BFS
- 将起始基因序列 startGene 入队，设初始变化次数为 0
BFS 遍历
- 每次从队列中取出当前基因序列 s，对其进行逐位变换。
- 枚举 8 个字符中的每一位，尝试将其替换为 ‘A’、‘C’、‘G’ 或 ‘T’
- 对于每个生成的新基因序列 t，若它在基因库中且未被访问过
  - 将其加入队列，并记录变化次数 hash[t] = hash[s] + 1
  - 若 t == endGene，则直接返回变化次数
结束条件：
- 如果 BFS 遍历完队列仍未找到 endGene，则返回 -1

时间复杂度

每个基因序列有 8 个字符，每个字符有 4 种变换，最多产生 O(8 * 4 * n) 次尝试，其中 n 是基因库的大小
BFS 遍历每个基因序列一次，复杂度为 O(n)

总时间复杂度为 O(32n) ，即 O(n)

空间复杂度

哈希集合 gene 和 hash 占用 O(n) 空间
队列最多存储 O(n) 个基因序列

总空间复杂度为 O(n)

C++代码

class Solution
{
public:
    int minMutation(string startGene, string endGene, vector<string>& bank)
    {
        // 基因库存入哈希集合
        std::unordered_set<std::string> gene;
        for (std::string& b : bank)
            gene.insert(b);

        // BFS 相关数据结构
        std::unordered_map<std::string, int> hash; // 记录访问状态及变化次数
        std::queue<std::string> q;
        hash[startGene] = 0; // 起始基因变化次数为 0
        q.push(startGene);

        char ge_ch[4] = {'A', 'C', 'G', 'T'}; // 可用字符
        while (!q.empty()) {
            std::string s = q.front();
            q.pop();

            // 对当前基因序列逐位尝试变换
            for (int i = 0; i < s.size(); ++i)
            {
                std::string t = s; // 新的基因序列
                for (char c : ge_ch)
                {
                    t[i] = c; // 修改第 i 位
                    // 若新序列有效且未访问过
                    if (gene.count(t) && hash.count(t) == 0)
                    {
                        hash[t] = hash[s] + 1; // 记录变化次数
                        if (t == endGene) // 找到目标序列
                            return hash[t];
                        q.push(t); // 入队继续搜索
                    }
                }
            }
        }
        return -1; // 无法到达目标序列
    }
};

Clone Graph

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

133. 克隆图

分析

哈希表存储原节点与克隆节点的映射：
- 使用 hash 保存原图节点到克隆节点的映射关系，用于快速找到已克隆的节点，避免重复克隆
DFS 遍历图的所有节点：
- 对每个未访问过的节点，创建其克隆节点并存入 hash
- 遍历当前节点的所有邻居，如果邻居未被克隆，则递归处理
复制邻接关系：
- 遍历所有节点（已在 hash 中），将每个原节点的邻居对应的克隆节点添加到克隆节点的邻居列表中
最终返回起始节点的克隆版本，即为完整的深拷贝图

时间复杂度

图的所有节点和边都会被访问一次，因此时间复杂度为 O(N + E)，其中 N 是节点数，E 是边数

空间复杂度

递归调用栈的深度取决于图的结构，最坏情况下为 O(N)，加上哈希表的存储空间，总体复杂度为 O(N)

C++代码

class Solution
{
public:
    Node* cloneGraph(Node* node)
    {
        if (!node)
            return nullptr;

        std::unordered_map<Node*, Node*> hash; // 哈希表存储节点映射
        dfs(node, hash); // 深度优先搜索创建克隆节点

        // 第二次遍历复制邻接关系
        for (auto& [origin, copy] : hash)
            for (Node* neighbor : origin->neighbors)
                copy->neighbors.push_back(hash[neighbor]); // 将原节点的邻接点的克隆节点添加到克隆节点的邻接表中

        return hash[node]; // 返回克隆图的起点
    }

    void dfs(Node* node, std::unordered_map<Node*, Node*>& hash)
    {
        // 克隆当前节点
        hash[node] = new Node(node->val);

        // 递归克隆邻居节点
        for (Node* neighbor : node->neighbors)
            if (hash.count(neighbor) == 0) // 如果邻居未被克隆
                dfs(neighbor, hash); // 递归处理
    }
};

Construct Binary Tree From Inorder And Postorder Traversal

Mon, 20 Jan 2025 00:00:00 +0000

106. 从中序和后序遍历序列构造二叉树

分析

构建哈希表：
- 遍历 inorder 数组，用哈希表记录每个节点值的位置。
- 这样可以快速查找某个节点在中序遍历中的索引。
递归划分左右子树：
- 后序遍历的最后一个元素是根节点。
- 在中序遍历中找到根节点的位置，从而确定左子树和右子树的范围。
递归构造树：
- 通过子数组的范围递归构造左右子树。
- 递归的边界条件是子数组范围为空。
返回结果：
- 最终返回根节点，即整棵树的构造结果

时间复杂度

构造哈希表需要 O(n)
每次递归通过哈希表查找根节点位置是 O(1)，递归调用总次数为 n，因此递归部分的时间复杂度为 O(n)

总时间复杂度为 O(n)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    std::unordered_map<int, int> hash; // 记录中序遍历中每个节点值的位置

    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder)
    {
        // 构建哈希表，快速查找中序遍历中每个节点的位置
        for (int i = 0; i < inorder.size(); ++i)
            hash[inorder[i]] = i;

        // 调用递归函数构造二叉树
        return build(inorder, postorder, 0, inorder.size() - 1, 0, postorder.size() - 1);
    }

    TreeNode* build(std::vector<int>& inorder, std::vector<int>& postorder, int il, int ir, int pl, int pr)
    {
        // 如果子树范围为空，返回空节点
        if (il > ir)
            return nullptr;

        // 获取当前子树的根节点
        TreeNode* root = new TreeNode(postorder[pr]);
        int mid = hash[root->val]; // 在中序遍历中找到根节点的位置

        // 递归构造左子树
        root->left = build(inorder, postorder, il, mid - 1, pl, pl + mid - 1 - il);

        // 递归构造右子树
        root->right = build(inorder, postorder, mid + 1, ir, pl + mid - 1 - il + 1, pr - 1);

        return root;
    }
};

Contains Duplicate

Thu, 16 Jan 2025 00:00:00 +0000

219. 存在重复元素II

分析

哈希表记录元素索引
- 用一个哈希表来记录每个元素上一次出现的索引。
遍历数组并检查条件
- 每次遍历到当前元素时，检查该元素是否已经存在于哈希表中：
  - 如果存在，比较当前索引和之前索引的差值是否小于等于 k，满足则返回 true
  - 如果不存在，或差值大于 k，则更新该元素的索引为当前索引
遍历结束仍未找到符合条件的元素，则返回 false

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    bool containsNearbyDuplicate(vector<int>& nums, int k)
    {
        std::unordered_map<int, int> hash;  // 用于存储元素及其最后一次出现的索引

        for (int i = 0; i < nums.size(); ++ i)
        {
            // 如果当前元素之前出现过，且索引之差小于等于 k
            if (hash.count(nums[i]) && i - hash[nums[i]] <= k)
                return true;  // 满足条件，直接返回 true

            hash[nums[i]] = i;  // 更新当前元素的索引
        }

        return false;  // 遍历结束未找到符合条件的元素，返回 false
    }
};

Happy Number

Thu, 16 Jan 2025 00:00:00 +0000

202. 快乐数

分析

计算每位数字的平方和
- 创建一个函数 happy(n)，计算整数 n 每位数字的平方和
检测循环
- 使用哈希集合记录每次计算的结果，防止无限循环
- 如果平方和结果重复出现，说明进入了死循环，返回 false
- 如果平方和结果变成 1，返回 true

时间复杂度

时间复杂度 O(logn)

空间复杂度

空间复杂度为 O(logn)

C++代码

class Solution
{
public:
    // 辅助函数：计算一个数的每位数字的平方和
    int happy(int n)
    {
        int sum = 0;
        while (n)
        {
            int t = n % 10;      // 取出最低位数字
            sum += t * t;        // 平方后累加
            n /= 10;             // 去掉最低位
        }
        return sum;
    }

    // 主函数：判断是否为快乐数
    bool isHappy(int n)
    {
        std::unordered_set<int> hash;  // 记录已出现的平方和结果

        while (n != 1)
        {
            n = happy(n);              // 计算平方和
            if (hash.count(n))         // 如果结果重复出现，说明进入循环
                return false;
            hash.insert(n);            // 记录当前结果
        }
        return true;                   // 最终变成 1，返回 true
    }
};

Valid Anagram

Thu, 16 Jan 2025 00:00:00 +0000

242. 有效的字母异位词

分析

使用哈希表统计字符频次
- 分别遍历 s 和 t，统计每个字符的出现次数
- 使用两个哈希表 hashS 和 hashT 存储字符频次
比较两个哈希表是否相等
- 如果两个哈希表相等，说明两个字符串是字母异位词
- 如果不相等，说明字符种类或字符次数不同，返回 false
时间复杂度：O(n)
- 遍历两个字符串各一次
空间复杂度：O(n)
- 使用哈希表存储字符频次

时间复杂度

总时间复杂度 O(n)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    bool isAnagram(string s, string t)
    {
        std::unordered_map<char, int> hashS, hashT;

        // 1. 统计字符串 s 的字符频次
        for (char c : s)
            ++hashS[c];

        // 2. 统计字符串 t 的字符频次
        for (char c : t)
            ++hashT[c];

        // 3. 比较两个哈希表是否相等
        return hashS == hashT;
    }
};

Substr with Concatenation of All Words

Tue, 14 Jan 2025 00:00:00 +0000

30. 串联所有单词的子串

分析

窗口长度固定：
- 每个单词长度相同，假设单词长度为 w，words 长度为 m，则窗口长度为 m * w
哈希表记录单词频次：
- 使用哈希表 total 统计 words 中每个单词出现的次数
- 窗口内部用另一个哈希表 window 统计窗口内单词频次
多起点滑动窗口：
- 从 s 的下标 0 ~ w - 1 依次滑动，确保不会遗漏跨单词边界的情况
窗口内单词匹配：
- 每次从当前位置提取长度为 w 的单词，更新窗口哈希表
- 如果窗口内单词频次超过 words 中的频次，则收缩窗口
- 当窗口内单词频次与 words 完全一致时，记录窗口的起始位置

时间复杂度

外层循环 w 次（单词长度）
内层遍历 n / w 次，每次提取单词和更新哈希表，代价为 O(1)

总时间复杂度 O(n * w)

空间复杂度

空间复杂度为 O(m)

C++代码

class Solution
{
public:
    vector<int> findSubstring(string s, vector<string>& words)
    {
        std::vector<int> res;
        if (words.empty())  // 边界情况：words为空
            return res;

        int n = s.size();             // 字符串 s 的长度
        int m = words.size();         // 单词个数
        int w = words[0].size();      // 单词长度

        // 统计 words 中每个单词出现的次数
        std::unordered_map<std::string, int> total;
        for (std::string& word : words)
            ++ total[word];

        // 遍历所有可能的起始位置（避免跨单词边界）
        for (int i = 0; i < w; ++i)
        {
            std::unordered_map<std::string, int> window;  // 窗口内单词频次
            int cnt = 0;  // 匹配到的单词数

            // 滑动窗口，步长为 w（单词长度）
            for (int j = i; j + w <= n; j += w)
            {
                // 当前窗口右侧加入新单词
                std::string rightWord = s.substr(j, w);
                ++ window[rightWord];
                if (window[rightWord] <= total[rightWord])  // 新单词未超额
                    ++ cnt;

                // 如果窗口超过了大小 m * w，滑动窗口左侧
                if (j >= i + m * w)
                {
                    std::string leftWord = s.substr(j - m * w, w);
                    -- window[leftWord];
                    if (window[leftWord] < total[leftWord])  // 如果减少后不匹配
                        -- cnt;
                }

                // 匹配到所有单词，记录起始索引
                if (cnt == m)
                    res.push_back(j - (m - 1) * w);
            }
        }
        return res;
    }
};

Insert Delete Get Random

Sat, 11 Jan 2025 00:00:00 +0000

380. 时间插入、删除和获取随机元素

插入操作：
- 使用哈希表来存储元素及其索引，在 O(1) 时间内检查元素是否存在，并在数组末尾插入新元素
删除操作：
- 对于删除操作，不直接从哈希表中删除元素，而是用数组末尾的元素替代被删除的元素。这样可以在 O(1) 时间内移除元素，而不需要移动数组中的其它元素
随机访问操作：
- 使用一个数组来存储所有元素，借助数组的随机访问特性，可以在 O(1) 时间内获取一个随机元素

时间复杂度

insert(val)：哈希表的查找和插入操作都是 O(1)，数组的末尾插入也是 O(1)
remove(val)：删除操作中的查找、替换和哈希表更新都是 O(1)，数组末尾删除是 O(1)
getRandom()：通过 rand() 和数组索引的方式随机获取元素是 O(1)

空间复杂度

空间复杂度为 O(n)

C++ 代码

class RandomizedSet
{
public:
    std::unordered_map<int, int> hash;  // 存储元素及其索引
    std::vector<int> nums;  // 存储元素，支持随机访问

    // 初始化 RandomizedSet 对象
    RandomizedSet() {}

    // 插入元素 val
    bool insert(int val)
    {
        if (hash.count(val) == 0)
        {
            nums.push_back(val);  // 将 val 加入 nums 数组
            hash[val] = nums.size() - 1;  // 记录 val 在 nums 数组中的索引
            return true;
        }
        return false;
    }

    // 移除元素 val
    bool remove(int val)
    {
        if (hash.count(val))
        {
            int tail = nums.back();  // 获取数组末尾的元素
            int val_index = hash[val];  // 获取 val 在 nums 数组中的索引
            int tail_index = hash[tail];  // 获取数组末尾元素的索引

            // 将 val 和数组末尾元素交换
            std::swap(nums[val_index], nums[tail_index]);
            std::swap(hash[val], hash[tail]);

            nums.pop_back();  // 移除数组末尾元素
            hash.erase(val);  // 从哈希表中移除 val
            return true;
        }
        return false;
    }

    // 随机返回一个元素
    int getRandom()
    {
        return nums[rand() % nums.size()];  // 随机返回 nums 数组中的一个元素
    }
};

Python 代码

import random

class RandomizedSet:
    def __init__(self):
        self.val_to_idx = {}
        self.nums = []

    def insert(self, val: int) -> bool:
        if val in self.val_to_idx:
            return False
        self.nums.append(val)
        self.val_to_idx[val] = len(self.nums) - 1
        return True

    def remove(self, val: int) -> bool:
        if val not in self.val_to_idx:
            return False
        idx = self.val_to_idx[val]
        last_val = self.nums[-1]
        self.nums[idx] = last_val
        self.val_to_idx[last_val] = idx
        self.nums.pop()
        del self.val_to_idx[val]
        return True

    def getRandom(self) -> int:
        return random.choice(self.nums)

Go 代码

package main

import (
  "math/rand"
)

type RandomizedSet struct {
  valToIdx map[int]int
  nums []int
}

func Constructor() RandomizedSet {
  return RandomizedSet{
    valToIdx: make(map[int]int),
    nums: []int{},
  }
}

func (this *RandomizedSet) Insert(val int) bool {
  if _, exists := this.valToIdx[val]; exists {
    return false
  }
  this.nums = append(this.nums, val)
  this.valToIdx[val] = len(this.nums) - 1
  return true
}


func (this *RandomizedSet) Remove(val int) bool {
  idx, exists := this.valToIdx[val];
  if !exists {
    return false
  }
  last := this.nums[len(this.nums) - 1]
  this.nums[idx] = last
  this.valToIdx[last] = idx
  this.nums = this.nums[:len(this.nums) - 1]
  delete(this.valToIdx, val)
  return true
}

func (this *RandomizedSet) GetRandom() int {
  return this.nums[rand.Intn(len(this.nums))]
}

Smallest Number In Infinite Set

Sat, 04 Jan 2025 00:00:00 +0000

2336. 无限集中的最小数字

分析

使用有序集合 std::set 来维护集合 s，其特性是自动按升序排列元素：
- popSmallest() 可以通过获取集合中的第一个元素*s.begin() 来实现最小值的提取，时间复杂度为 O(log n)
- addBack(num) 通过插入操作，将数字加入集合，同时自动维护顺序，时间复杂度为 O(log n)
由于题目给出 1 <= num <= 1000，因此初始化集合时，可以预先将 s 初始化为 1 ~ 1000

时间复杂度

popSmallest()：
- 获取最小值 *s.begin(): O(1)
- 删除操作 s.erase(): O(\log n)
- 总时间复杂度：O(logn)
addBack(num)：
- 插入操作 s.insert()：O(logn)
初始化操作：插入 n 个初始值：总复杂度为 O(nlogn)

空间复杂度

主要存储集合 s，大小为集合中的元素个数，空间复杂度为 O(n)

C++代码

class SmallestInfiniteSet
{
public:
    std::set<int> s;

    // 构造函数，初始化集合
    SmallestInfiniteSet()
    {
        // 集合的初始值为 [1, 2, ..., 1000]
        for (int i = 1; i <= 1000; ++i)
            s.insert(i);
    }

    // 移除并返回最小值
    int popSmallest()
    {
        // 获取集合中最小值
        int t = *s.begin();
        // 从集合中删除最小值
        s.erase(s.begin());
        return t;
    }

    // 将数字添加回集合
    void addBack(int num)
    {
        // 插入数字，std::set 会自动去重
        s.insert(num);
    }
};

Determine If Two Strings Are Close

Wed, 25 Dec 2024 00:00:00 +0000

1657. 确定两个字符串是否接近

分析

长度检查：
- 如果 word1 和 word2 的长度不同，则它们无法接近，直接返回 false
字符集合一致性检查：
- 两个字符串需要包含相同的字符集合。例如，word1 = "abc" 和 word2 = "bca" 包含的字符都是 {a, b, c}，可以进行字符交换；而 word1 = "abc" 和 word2 = "bcd" 的字符集合不同，不可能接近
频次匹配：
- 统计每个字符串中字符的频次，并将频次排序。若两个字符串的字符频次分布相同，则可以通过变换使其互相接近

时间复杂度

统计字符频次的时间为 O(n)，其中 n 是字符串的长度
排序频次数组的时间为 O(26log26)，常数级别可视为 O(1)

总时间复杂度 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution {
public:
    bool closeStrings(string word1, string word2)
    {
        // 如果长度不同，直接返回 false
        if (word1.size() != word2.size())
            return false;

        // 统计两个字符串中每个字符的频次
        std::vector<int> cnt1(26, 0);
        std::vector<int> cnt2(26, 0);
        for (int i = 0; i < word1.size(); ++i)
        {
            ++cnt1[word1[i] - 'a'];
            ++cnt2[word2[i] - 'a'];
        }

        // 检查两个字符串是否包含相同的字符集合
        for (int i = 0; i < 26; ++i)
        {
            if ((cnt1[i] && !cnt2[i]) || (!cnt1[i] && cnt2[i]))
                return false;
        }

        // 对频次数组排序并检查是否相同
        std::sort(cnt1.begin(), cnt1.end());
        std::sort(cnt2.begin(), cnt2.end());

        return cnt1 == cnt2;
    }
};

Unique Number of Occurrences

Wed, 25 Dec 2024 00:00:00 +0000

1207. 独一无二的出现次数

分析

统计出现次数：
- 使用哈希表 cnt 统计数组中每个元素的出现次数，键为元素值，值为该元素的出现次数
判断次数是否唯一：
- 使用集合 hash 存储所有出现次数。
- 遍历哈希表 cnt，如果发现某次出现次数已存在于集合中，则返回 false
- 如果遍历结束后没有重复次数，返回 true

时间复杂度

统计元素出现次数的时间是 O(n)，其中 n 是数组的长度
检查次数唯一性的时间是 O(m)，其中 m 是数组中不同元素的个数

总时间复杂度为 O(n + m)

空间复杂度

空间复杂度为 O(m)

C++代码

class Solution
{
public:
    bool uniqueOccurrences(vector<int>& arr)
    {
        // 统计元素出现次数
        std::unordered_map<int, int> cnt;
        for (int x : arr)
            ++cnt[x];

        // 检查出现次数是否唯一
        std::unordered_set<int> hash;
        for (auto item : cnt)
        {
            // 如果某个次数已存在，返回 false
            if (hash.count(item.second))
                return false;
            hash.insert(item.second);
        }

        // 如果所有次数都唯一，返回 true
        return true;
    }
};

Find The Difference Of Two Arrays

Tue, 24 Dec 2024 00:00:00 +0000

2215. 找出两数组的不同

分析

使用哈希集合存储唯一元素：
- 为了处理数组中重复的元素，我们使用两个集合 hash1 和 hash2 分别存储 nums1 和 nums2 的唯一值
查找差集：
- 遍历集合 hash1，找出不在 hash2 中的元素，存入 res[0]
- 遍历集合 hash2，找出不在 hash1 中的元素，存入 res[1]
返回结果：
- 返回结果列表 res，包含两个子列表

时间复杂度

遍历数组构建集合的时间是 O(n + m)
遍历集合查找差集的时间是 O(n + m)

总时间复杂度：O(n + m)，其中 n 和 m 分别是 nums1 和 nums2 的长度

空间复杂度

空间复杂度：O(u + v)，其中 u 和 v 是 nums1 和 nums2 中的不同元素个数

C++代码

class Solution {
public:
    vector<vector<int>> findDifference(vector<int>& nums1, vector<int>& nums2)
    {
        // 使用集合存储唯一元素
        std::unordered_set<int> hash1;
        std::unordered_set<int> hash2;

        // 将 nums1 的元素加入 hash1
        for (int num : nums1)
            hash1.insert(num);

        // 将 nums2 的元素加入 hash2
        for (int num : nums2)
            hash2.insert(num);

        std::vector<std::vector<int>> res(2);

        // 找出 nums1 中不在 nums2 中的元素
        for (int num : hash1)
            if (!hash2.count(num))
                res[0].push_back(num);

        // 找出 nums2 中不在 nums1 中的元素
        for (int num : hash2)
            if (!hash1.count(num))
                res[1].push_back(num);

        return res;
    }
};

Max Number of K Sum Pairs

Sun, 22 Dec 2024 00:00:00 +0000

1679. K和数对的最大数目

分析

使用哈希表记录出现次数：
- 用一个哈希表 hash 来记录数组中每个整数出现的次数
查找是否能形成和为 k 的配对：
- 遍历数组中的每个元素 num，计算目标值 target = k - num
- 如果哈希表中存在目标值 target 且次数大于 0，则找到一对符合条件的整数，计数器 res 增加 1，并减少 target 的计数
- 如果目标值 target 不存在，将当前元素 num 的计数加到哈希表中
返回最大操作数：
- 遍历完成后，结果存储在 res 中，表示可以执行的最大操作数

时间复杂度

遍历数组，时间复杂度为 O(n)
每次哈希表的插入与查询时间复杂度为 O(1)，总体复杂度为 O(n)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    int maxOperations(vector<int>& nums, int k)
    {
        std::unordered_map<int, int> hash; // 哈希表记录元素出现次数
        int res = 0; // 记录最大操作数

        for (int num : nums) // 遍历数组
        {
            int target = k - num; // 计算需要配对的目标值
            if (hash[target] > 0) // 如果目标值存在于哈希表中
            {
                --hash[target]; // 配对目标值计数减一
                ++res; // 操作数加一
            }
            else
            {
                ++hash[num]; // 当前元素加入哈希表
            }
        }
        return res;
    }
};

Partition Lables

Sun, 15 Dec 2024 00:00:00 +0000

763. 划分字母区间

分析

记录每个字母的最远出现位置：
- 遍历字符串，记录每个字符最后一次出现的索引，存储在哈希表 hash 中
划分片段：
- 使用变量 start 表示当前片段的起始位置，end 表示当前片段中字符的最远位置
- 遍历字符串时，动态更新当前片段的最远位置 end
- 当当前索引 i 等于 end 时，表示当前片段结束，将片段长度加入结果数组 res
更新起点：
- 划分一个片段后，将 start 更新为 i + 1，准备划分下一个片段

时间复杂度

记录最远位置: O(n)，需要遍历一次字符串记录字符的最远位置
划分片段: O(n)，第二次遍历字符串进行片段划分

总体时间复杂度为 O(n)

空间复杂度

哈希表 hash 的空间复杂度为 O(k)，其中 k 是字符集大小（对于英文字母，k < 26）
结果数组 res 需要额外存储片段长度，空间复杂度为 O(p)，其中 p 是片段数量

总体空间复杂度为 O(k + p)

C++代码

class Solution
{
public:
    vector<int> partitionLabels(string s)
    {
        // 记录每个字符的最远出现位置
        std::unordered_map<char, int> hash;
        for (int i = 0; i < s.size(); ++i)
            hash[s[i]] = i;

        std::vector<int> res; // 存储结果
        int start = 0, end = 0;

        for (int i = 0; i < s.size(); ++i)
        {
            // 更新当前片段的最远边界
            end = std::max(end, hash[s[i]]);

            // 当前片段结束
            if (i == end)
            {
                res.push_back(end - start + 1); // 保存片段长度
                start = end = i + 1;           // 更新起点，准备下一个片段
            }
        }

        return res;
    }
};

Word Break

Wed, 11 Dec 2024 00:00:00 +0000

139. 单词拆分

分析

状态定义：
- 定义 f[i]：表示从第 i 个字符到字符串结尾的子串能否被字典中的单词拼接而成
状态转移：
- 对于子串 s[i:j]，若 s[i:j] 出现在字典中，且 f[j] = true，则可以拼接出 s[i:n]，即 f[i] = true
初始化：
- f[n] = true：空字符串可以被成功拼接
结果：
- 返回 f[0]，即判断整个字符串是否可以被拼接

时间复杂度

外层循环遍历字符串 O(n) ，内层循环遍历每个子串的结尾 O(n) ，检查子串是否在字典中平均耗时 O(k) ，其中 k 是子串的平均长度

总时间复杂度为 O(n^2 * k)

空间复杂度

动态规划数组 f 占用 O(n)
哈希表占用 O(l) ，其中 l 是字典中单词的总长度

总空间复杂度为 O(n + l)

C++代码

class Solution
{
public:
    bool wordBreak(string s, vector<string>& wordDict)
    {
        std::unordered_set<std::string> hash;  // 使用哈希表存储字典中的单词
        for (std::string word : wordDict)
            hash.insert(word);

        int n = s.size();
        std::vector<bool> f(n + 1, false);  // 动态规划数组
        f[n] = true;  // 初始化空字符串为可拼接

        // 从后向前遍历字符串
        for (int i = n - 1; i >= 0; --i)
        {
            std::string str;  // 记录当前子串
            for (int j = i; j < n; ++j)
            {
                str += s[j];  // 扩展子串
                if (hash.count(str) && f[j + 1])  // 检查是否满足条件
                {
                    f[i] = true;
                    break;
                }
            }
        }

        return f[0];  // 返回结果
    }
};

Top K Frequent Elements

Mon, 09 Dec 2024 00:00:00 +0000

347. 前K个高频元素

分析

统计频率：
- 使用哈希表 hash 记录数组中每个元素的出现次数，键为数组元素，值为对应频率
统计频率分布：
- 创建一个计数数组 count，其中 count[i] 表示频率为 i 的元素个数
确定频率阈值：
- 从高频到低频累加 count，直到累计的元素数达到 k ，此时的频率即为筛选阈值 i
筛选元素：
- 再次遍历哈希表 hash，将频率大于阈值 i 的元素加入结果数组 res

时间复杂度

统计频率：O(n) ，遍历数组
统计频率分布：O(m) ，m 为哈希表的大小
筛选元素：O(m)

总复杂度：O(n + m) ，其中 m <= n

空间复杂度

哈希表存储频率： O(m)
频率分布数组：O(n)

总复杂度：O(n + m)

C++代码

class Solution
{
public:
    vector<int> topKFrequent(vector<int>& nums, int k)
    {
        // 1. 统计每个元素的频率
        std::unordered_map<int, int> hash;
        for (int num : nums)
            ++hash[num];

        // 2. 统计每个频率的出现次数
        int n = nums.size();
        std::vector<int> count(n + 1);
        for (std::pair<int, int> item : hash)
            ++count[item.second];

        // 3. 找到频率阈值
        int i = n, sum = 0;
        while (sum < k)
            sum += count[i--];

        // 4. 筛选出符合条件的元素
        std::vector<int> res;
        for (std::pair<int, int> item : hash)
            if (item.second > i)
                res.push_back(item.first);

        return res;
    }
};

Implement Trie Prefix Tree

Tue, 03 Dec 2024 00:00:00 +0000

208. 实现Trie树

分析

定义 Trie 树的节点结构
- 每个节点包含以下信息：
- is_end：标志当前节点是否是某个单词的结束节点
- son[26]：一个数组，用于存储指向 26 个小写英文字母子节点的指针。如果某个字母子节点不存在，则为 nullptr
初始化 Trie 树
- 构造函数中初始化根节点 root
插入单词 insert()
- 从根节点出发，逐字符检查单词：
- 如果当前字符对应的子节点不存在，则创建新节点
- 移动到对应的子节点。
- 最后将当前节点标记为结束节点 is_end = true
搜索单词 search()
- 从根节点出发，逐字符遍历单词：
- 如果某字符对应的子节点不存在，返回 false
- 如果全部字符都匹配且最后节点是结束节点，返回 true
- 否则，返回 false
检查前缀 startsWith()
- 与 search 类似，但不需要检查是否是结束节点。只要能完整遍历到前缀，返回 true；否则返回 false

时间复杂度

insert()：O(n)，其中 n 是单词长度，每次需要逐字符插入
search()：O(n)，需要逐字符查找
startsWith()：O(n)，需要逐字符查找

空间复杂度

每个节点存储 26 个指针，整体空间复杂度取决于插入的单词集合的总字符数

C++代码

class Trie
{
public:
    // 定义 Trie 树节点类型
    struct Node {
        Node() {
            is_end = false;
            for (int i = 0; i < 26; ++i)
                son[i] = nullptr;
        }

        bool is_end;       // 当前节点是否是某个单词的结束
        Node* son[26];     // 指向 26 个子节点的指针数组
    };

    Node* root;           // Trie 树的根节点

    Trie() {
        root = new Node(); // 初始化根节点
    }

    // 插入单词
    void insert(string word) {
        Node* p = root;
        for (char c : word) {
            int u = c - 'a';          // 计算字符对应的子节点索引
            if (!p->son[u])           // 如果不存在该子节点，则创建新节点
                p->son[u] = new Node();
            p = p->son[u];            // 移动到子节点
        }
        p->is_end = true;             // 标记单词结束
    }

    // 搜索单词
    bool search(string word) {
        Node* p = root;
        for (char c : word) {
            int u = c - 'a';          // 计算字符对应的子节点索引
            if (!p->son[u])           // 如果子节点不存在，返回 false
                return false;
            p = p->son[u];            // 移动到子节点
        }
        return p->is_end;             // 如果最后是结束节点，返回 true
    }

    // 检查前缀
    bool startsWith(string prefix) {
        Node* p = root;
        for (char c : prefix) {
            int u = c - 'a';          // 计算字符对应的子节点索引
            if (!p->son[u])           // 如果子节点不存在，返回 false
                return false;
            p = p->son[u];            // 移动到子节点
        }
        return true;                  // 如果能遍历完整前缀，返回 true
    }
};

linkedListCycle

Fri, 29 Nov 2024 00:00:00 +0000

141. 环形链表

分析

初始化指针
- 如果链表为空或只有一个节点，则无法形成环，直接返回 false
- 设置两个指针 slow 和 fast，初始时都指向链表的头节点 head
移动指针
- 慢指针 slow 每次移动一步
- 快指针 fast 每次移动两步
- 每次移动后，检查 slow 和 fast 是否相等。如果相等，说明链表中存在环
终止条件
- 如果 fast 为 nullptr，说明链表没有环，直接返回 false

时间复杂度

慢指针最多遍历链表一次，快指针最多遍历链表两次，因此时间复杂度为 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    bool hasCycle(ListNode *head)
    {
        // 链表为空或只有一个节点，无法形成环
        if (!head || !head->next)
            return false;

        ListNode *slow = head, *fast = head;

        while (fast) // 快指针未到达链表末尾
        {
            slow = slow->next;           // 慢指针走一步
            fast = fast->next;           // 快指针走一步
            if (fast)
                fast = fast->next;       // 快指针再走一步

            if (slow == fast)            // 快慢指针相遇，存在环
                return true;
        }
        return false; // 快指针到达链表末尾，无环
    }
};

linkedListCycleII

Fri, 29 Nov 2024 00:00:00 +0000

142. 环形链表II

分析

判断链表是否有环
- 设置两个指针 slow 和 fast，初始都指向链表头节点 head
- 快指针每次移动两步，慢指针每次移动一步
- 如果快指针追上慢指针，说明链表中有环；否则，如果快指针或其下一节点为空，则链表无环
找到环的起始节点
- 当快慢指针相遇时，将慢指针重置为链表头节点 head
- 快指针保持在相遇位置
- 两个指针每次都向前移动一步，当两者再次相遇时，相遇点即为环的起始节点

数学推导

假设：

链表头到环入口节点的距离为 a
环入口到相遇点的距离为 b
相遇点到环入口的距离为 c

快指针比慢指针速度快一倍，因此：2(a + b) = a + b + n(b + c)（ n 为快指针在环中绕的圈数），化简得：a = c + (n - 1)(b + c)

这表明：

从链表头节点到环入口的距离 a 等于从相遇点沿环走回入口的距离 c
因此，当两个指针一个从链表头开始，一个从相遇点开始，每次移动一步，最终会在环的起始节点相遇

时间复杂度

快慢指针遍历链表一次即可确定是否有环，以及找到环的起始节点，时间复杂度 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    ListNode *detectCycle(ListNode *head)
    {
        // 链表为空或只有一个节点，不可能有环
        if (!head || !head->next)
            return nullptr;

        ListNode *slow = head, *fast = head;

        // 判断链表是否有环
        while (fast)
        {
            slow = slow->next;          // 慢指针走一步
            fast = fast->next;          // 快指针走一步
            if (fast)
                fast = fast->next;      // 快指针再走一步

            if (slow == fast)           // 快慢指针相遇
            {
                // 找到环的起始节点
                slow = head;            // 慢指针回到链表头
                while (slow != fast)    // 两指针相遇即为环入口
                {
                    slow = slow->next;
                    fast = fast->next;
                }
                return fast;
            }
        }

        return nullptr; // 无环
    }
};

firstMissPositive

Wed, 27 Nov 2024 00:00:00 +0000

41. 缺失的第一个正数

分析

原地哈希：
- 对于一个长度为 n 的数组，最小的缺失正整数只能在 1 到 n+1 之间
- 遍历数组，对于每个数字 nums[i]，如果满足条件 1 ≤ nums[i] ≤ n 且 nums[i] != nums[nums[i] - 1]，则将其交换到正确的位置
- 通过循环交换，可以在原地调整数组顺序
检查缺失：
- 调整完成后，遍历数组，检查每个位置是否满足 nums[i] == i + 1
- 如果存在不满足的位置，则返回 i + 1
- 如果所有位置都满足，说明数组包含所有 1 到 n 的正整数，缺失的正整数为 n + 1

时间复杂度

每个数字最多只会被交换一次，因此总操作次数为 O(n)

空间复杂度

原地调整数组，无额外空间开销，空间复杂度为 O(1)

C++代码

class Solution
{
public:
    int firstMissingPositive(vector<int>& nums)
    {
        int n = nums.size();

        // 调整数组顺序
        for (int i = 0; i < n; ++i)
            while (nums[i] >= 1 && nums[i] <= n && nums[i] != nums[nums[i] - 1])
                std::swap(nums[i], nums[nums[i] - 1]);

        // 查找第一个缺失的正整数
        for (int i = 0; i < n; ++i)
            if (nums[i] != i + 1)
                return i + 1;

        // 如果所有正整数都在正确位置，返回 n + 1
        return n + 1;
    }
};

findAnagrams

Tue, 26 Nov 2024 00:00:00 +0000

438. 找到字符串中所有字母异位词

算法

初始化目标频率表：
- 使用哈希表 hash 存储字符串 p 中每个字符的频率
滑动窗口遍历字符串 s：
- 窗口初始范围为 [j, i]，窗口长度不超过 p.size()
- 遍历字符串 s，对窗口内的字符更新哈希表：
  - 窗口右扩（加入字符）：
    - 将当前字符 s[i] 加入窗口，并在 hash 中减少其频率
    - 如果该字符的频率变为 0，说明该字符的频率匹配，增加匹配计数 count
  - 窗口左缩（移除字符）：
    - 如果窗口长度超过 p.size()，将左端字符 s[j] 从窗口移除：
      - 如果 s[j] 在 hash 中频率变为非零，匹配计数 count 减少
      - 更新左指针 j
判断异位词：
- 如果窗口内所有字符频率均匹配（count == total），将当前窗口左端索引 j 加入结果集 res

复杂度分析

时间复杂度

初始化哈希表：O(p)，其中 p 是字符串 p 的长度
滑动窗口遍历：O(s)，其中 s 是字符串 s 的长度
总时间复杂度：O(s + p)

空间复杂度

使用了一个哈希表存储字符频率，空间复杂度为 O(k)，其中 k 是字符集大小

C++ 代码

class Solution
{
public:
    vector<int> findAnagrams(string s, string p)
    {
        std::unordered_map<char, int> hash; // 存储目标字符频率
        for (char c : p)
            ++hash[c];

        std::vector<int> res;
        int total = hash.size(), count = 0;

        for (int i = 0, j = 0; i < s.size(); ++ i)
        {
            // 右扩：加入字符 s[i]
            -- hash[s[i]];
            if (hash[s[i]] == 0)
                ++ count;

            // 左缩：移除字符 s[j]
            if (i - j + 1 > p.size())
            {
                if (hash[s[j]] == 0)
                    -- count;
                ++ hash[s[j]];
                ++ j;
            }

            // 检查是否找到异位词
            if (count == total)
                res.push_back(j);
        }

        return res;
    }
};

Python 代码

class Solution:
  def findAnagrams(self, s: str, p: str) -> List[int]:
    freq = {}

    for ch in p:
      freq[ch] = freq.get(ch, 0) + 1

    total, count = len(freq), 0
    res = []

    j = 0
    for i in range(len(s)):
      freq[s[i]] = freq.get(s[i], 0) - 1
      if freq[s[i]] == 0:
        count += 1
      if i - j + 1 > len(p):
        if freq[s[j]] == 0:
          count -= 1
        freq[s[j]] = freq.get(s[j], 0) + 1
        j += 1
      if total == count:
        res.append(j)

    return res

Go 代码

func findAnagrams(s string, p string) []int {
  freq := make(map[byte]int)
  for i := 0; i < len(p); i ++ {
    freq[p[i]] ++
  }

  total, count := len(freq), 0
  res := []int{}

  for i, j := 0, 0; i < len(s); i ++ {
    freq[s[i]] --
    if freq[s[i]] == 0 {
      count ++
    }
    if i - j + 1 > len(p) {
      if freq[s[j]] == 0 {
        count --
      }
      freq[s[j]] ++
      j ++
    }
    if count == total {
      res = append(res, j)
    }
  }
  return res
}

JavaScript 代码

/**
 * @param {string} s
 * @param {string} p
 * @return {number[]}
 */
var findAnagrams = function (s, p) {
  let freq = new Map();
  for (let i = 0; i < p.length; i++) {
    freq.set(p[i], (freq.get(p[i]) || 0) + 1);
  }

  let total = freq.size,
    count = 0;
  let res = [];

  for (let i = 0, j = 0; i < s.length; i++) {
    freq.set(s[i], (freq.get(s[i]) || 0) - 1);

    if (freq.get(s[i]) == 0) {
      count++;
    }

    if (i - j + 1 > p.length) {
      if (freq.get(s[j]) == 0) {
        count--;
      }
      freq.set(s[j], (freq.get(s[j]) || 0) + 1);
      j++;
    }

    if (total == count) {
      res.push(j);
    }
  }
  return res;
};

Longest Substring Without Repeating Characters

Tue, 26 Nov 2024 00:00:00 +0000

3. 无重复字符的最长子串

算法

维护一个滑动窗口：
- 滑动窗口用两个指针表示，j 为窗口左端，i 为窗口右端
- 窗口内的子串为 [j, i]，保证该窗口内没有重复字符
使用哈希表记录字符出现的次数：
- 哈希表 hash 的 key 为字符，value 为该字符在窗口中的出现次数
移动窗口右端：
- 遍历字符串，右端指针 i 每次右移一格，将字符加入窗口并更新哈希表
处理重复字符：
- 如果窗口中出现重复字符（即当前字符的出现次数大于 1），移动左端指针 j，并在哈希表中移除字符，直到窗口内没有重复字符。
更新结果：
- 每次移动窗口时，计算当前窗口的长度 (i - j + 1)，并更新结果 res

复杂度分析

时间复杂度

每个字符至多被访问两次（右指针扩展时访问一次，左指针收缩时访问一次），时间复杂度为 O(n)

空间复杂度

使用哈希表存储字符出现次数，空间复杂度为 O(k)，其中 k 为字符集大小

C++ 代码

class Solution
{
public:
    int lengthOfLongestSubstring(string s)
    {
        std::unordered_map<char, int> hash; // 记录字符出现次数
        int res = 0; // 最长子串长度

        for (int i = 0, j = 0; i < s.size(); ++ i)
        {
            ++hash[s[i]]; // 将字符加入窗口

            // 如果出现重复字符，移动左指针 j
            while (hash[s[i]] > 1)
            {
                -- hash[s[j]];
                ++ j;
            }

            // 更新最长子串长度
            res = std::max(res, i - j + 1);
        }

        return res;
    }
};

Python 代码

class Solution:
  def lengthOfLongestSubstring(self, s: str) -> int:
    res = 0
    freq = {}
    j = 0
    for i, ch in enumerate(s):
      if ch not in freq:
        freq[ch] = 0
      freq[ch] += 1
      while freq[ch] > 1:
        freq[s[j]] -= 1
        j += 1
      res = max(res, i - j + 1)
    return res

Go 代码

func lengthOfLongestSubstring(s string) int {
  freq := make(map[byte]int)
  res, j := 0, 0
  for i := 0; i < len(s); i ++ {
    freq[s[i]] ++
    for freq[s[i]] > 1 {
      freq[s[j]] --
      j ++
    }
    res = max(res, i - j + 1)
  }
  return res
}

Javascript

/**
 * @param {string} s
 * @return {number}
 */
var lengthOfLongestSubstring = function (s) {
  let res = 0;
  let freq = new Map();
  for (let i = 0, j = 0; i < s.length; i++) {
    freq.set(s[i], (freq.get(s[i]) || 0) + 1);
    while (freq.get(s[i]) > 1) {
      freq.set(s[j], freq.get(s[j]) - 1);
      j++;
    }
    res = Math.max(res, i - j + 1);
  }
  return res;
};

Minimum Window

Tue, 26 Nov 2024 00:00:00 +0000

76. 最小覆盖子串

算法

记录目标字符频率：
- 使用哈希表 hashT 记录字符串 t 中每个字符的频率。
维护当前窗口的字符频率：
- 使用另一个哈希表 hashS 记录当前窗口内字符的频率。
滑动窗口：
- 扩展窗口：从左到右遍历字符串 s，将当前字符加入窗口，并更新 hashS
- 满足条件：当窗口中的字符满足 t 中的所有字符（包括频率要求），记录当前窗口长度
- 收缩窗口：尝试从窗口左端收缩，以找到更小的满足条件的子串
更新结果：
- 如果窗口当前覆盖所有所需字符且长度更短，则更新结果字符串

复杂度分析

时间复杂度

遍历字符串 s：每个字符至多被访问两次（一次扩展窗口，一次收缩窗口），时间复杂度为 O(n)
更新哈希表：更新和查询哈希表的操作时间复杂度为 O(1)
总时间复杂度：O(n)

空间复杂度

使用了两个哈希表存储字符频率，空间复杂度为 O(n)

C++ 代码

class Solution
{
public:
    string minWindow(string s, string t)
    {
        std::unordered_map<char, int> hashS, hashT;
        for (char c : t)
            ++ hashT[c]; // 记录目标字符串 t 的字符频率

        int cnt = 0; // 当前窗口内满足条件的字符个数
        std::string res; // 记录结果子串
        for (int i = 0, j = 0; i < s.size(); ++i)
        {
            ++ hashS[s[i]]; // 扩展窗口
            if (hashS[s[i]] <= hashT[s[i]])
                ++ cnt; // 更新满足条件的字符数

            // 收缩窗口：移除多余的字符
            while (hashS[s[j]] > hashT[s[j]])
            {
                -- hashS[s[j]];
                ++ j;
            }

            // 检查当前窗口是否满足条件
            if (cnt == t.size())
                if (res.empty() || res.size() > i - j + 1)
                    res = s.substr(j, i - j + 1); // 更新结果
        }
        return res;
    }
};

Python 代码

class Solution:
  def minWindow(self, s: str, t: str) -> str:
    freqS, freqT = defaultdict(int), defaultdict(int)
    for c in t:
      freqT[c] += 1

    j, cnt = 0, 0
    res = ""
    for i in range(len(s)):
      freqS[s[i]] += 1
      if freqS[s[i]] <= freqT[s[i]]:
        cnt += 1
      while j < len(s) and freqS[s[j]] > freqT[s[j]]:
        freqS[s[j]] -= 1
        j += 1
      if cnt == len(t):
        if not res or len(res) > i - j + 1:
          res = s[j : i + 1]
    return res

Go 代码

func minWindow(s string, t string) string {
  freqS, freqT := make(map[byte]int), make(map[byte]int)
  for i := 0; i < len(t); i ++ {
    freqT[t[i]] ++ ;
  }

  cnt := 0
  res := ""
  for i, j := 0, 0; i < len(s); i ++ {
    freqS[s[i]] ++
    if freqS[s[i]] <= freqT[s[i]] {
      cnt ++
    }
    for j < len(s) && freqS[s[j]] > freqT[s[j]] {
      freqS[s[j]] --
      j ++
    }
    if (cnt == len(t)) {
      if (res == "" || len(res) > i - j + 1) {
        res = s[j : i + 1]
      }
    }
  }
  return res;
}

JavaScript 代码

/**
 * @param {string} s
 * @param {string} t
 * @return {string}
 */
var minWindow = function (s, t) {
  let freqS = new Map(),
    freqT = new Map();
  for (let c of t) {
    freqT.set(c, (freqT.get(c) || 0) + 1);
  }

  let cnt = 0;
  let res = "";
  for (let i = 0, j = 0; i < s.length; i++) {
    freqS.set(s[i], (freqS.get(s[i]) || 0) + 1);
    if (freqS.get(s[i]) <= freqT.get(s[i])) {
      cnt++;
    }
    while (freqS.get(s[j]) > (freqT.get(s[j]) || 0)) {
      freqS.set(s[j], freqS.get(s[j]) - 1);
      j++;
    }
    if (cnt == t.length) {
      if (res.length == 0 || res.length > i - j + 1) {
        res = s.slice(j, i + 1);
      }
    }
  }
  return res;
};

subarraySum

Tue, 26 Nov 2024 00:00:00 +0000

560. 和为k的子数组

算法

定义前缀和：
- 用 sum 表示从数组起点到当前位置的元素总和
- 任意连续子数组的和可以通过前缀和的差来计算：sum[i] - sum[j] = k => sum[i] - k = sum[j]
使用哈希表存储前缀和出现的次数：
- 哈希表 hash 的键表示前缀和的值，值表示该前缀和出现的次数
- 初始状态下，将前缀和 0 的计数置为 1（代表从起点到当前位置的子数组和可能为 k ）
遍历数组，动态更新结果：
- 遍历数组中的每个元素，将当前值累加到 sum
- 检查 hash 中是否存在键 sum - k：
  - 若存在，说明从某个之前的位置到当前的位置的子数组和为 k ，将其对应的次数累加到结果 res 中
- 更新 hash，增加当前前缀和 sum 的计数
返回结果：
- 遍历结束后，结果 res 即为和为 k 的子数组个数

复杂度分析

时间复杂度

遍历数组：O(n)，其中 n 是数组的长度
哈希表操作：平均时间复杂度为 O(1)
总时间复杂度：O(n)

空间复杂度

使用了哈希表存储前缀和及其次数，空间复杂度为 O(n)，其中 n 是数组的长度

C++ 代码

class Solution
{
public:
    int subarraySum(vector<int>& nums, int k)
    {
        std::unordered_map<int, int> hash; // 存储前缀和及其出现次数
        int res = 0, sum = 0;

        hash[0] = 1; // 初始化前缀和 0 的计数为 1

        for (int num : nums)
        {
            sum += num;            // 更新前缀和
            res += hash[sum - k];  // 检查是否存在前缀和满足条件
            ++ hash[sum];           // 更新当前前缀和的计数
        }

        return res;
    }
};

Python 代码

class Solution:
  def subarraySum(self, nums: List[int], k: int) -> int:
    res, prefix_sum = 0, 0
    freq = {}
    freq[0] = 1
    for x in nums:
      prefix_sum += x

      if prefix_sum - k not in freq:
        freq[prefix_sum - k] = 0

      res += freq[prefix_sum - k]

      if prefix_sum not in freq:
        freq[prefix_sum] = 0

      freq[prefix_sum] += 1
    return res

Go 代码

func subarraySum(nums []int, k int) int {
  res, prefix_sum := 0, 0
  freq := make(map[int]int)
  freq[0] = 1
  for _, x := range nums {
    prefix_sum += x
    res += freq[prefix_sum - k]
    freq[prefix_sum] += 1
  }
  return res
}

JavaScript 代码

/**
 * @param {number[]} nums
 * @param {number} k
 * @return {number}
 */
var subarraySum = function (nums, k) {
  let res = 0,
    prefix_sum = 0;
  let freq = new Map();
  freq.set(0, 1);
  for (let x of nums) {
    prefix_sum += x;
    if (freq.has(prefix_sum - k)) {
      res += freq.get(prefix_sum - k);
    }
    freq.set(prefix_sum, (freq.get(prefix_sum) || 0) + 1);
  }
  return res;
};

longestConsecutiveSequence

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

128. 最长连续序列

算法

使用哈希集合 (unordered_set)：
- 首先将数组中的所有元素存入一个哈希集合 s 中，便于快速判断某个数字是否存在
遍历数组，寻找序列起点：
- 对于每个数字 start，如果 start - 1 不存在于集合中，说明它是某个连续序列的起点
- 从这个起点开始，逐步检查 start + 1, start + 2, … 是否存在于集合中，计算连续序列的长度
优化：删除已访问元素：
- 在遍历过程中，一旦某个数字被处理，可以从集合中删除，避免后续重复处理
更新结果：
- 记录所有连续序列的最大长度

复杂度分析

时间复杂度

构建哈希集合：O(n) ，其中 n 是数组长度
遍历数组：
- 每个元素最多被访问两次（一次作为序列起点，一次作为序列中元素）
- 总复杂度为 O(n)
总时间复杂度为 O(n)

空间复杂度

使用了一个哈希集合存储数组中的所有元素，空间复杂度为 O(n)

C++ 代码

class Solution {
public:
    int longestConsecutive(std::vector<int>& nums)
    {
        std::unordered_set<int> s; // 哈希集合存储所有数字
        for (int num : nums)
            s.insert(num);

        int res = 0; // 记录最长连续序列的长度

        for (int start : nums)
        {
            // 如果 start 是序列的起点（前一个数字不存在）
            if (s.count(start) && !s.count(start - 1))
            {
                int end = start; // 初始化序列的起点
                s.erase(end);    // 移除起点，避免重复处理

                // 找到当前序列的结尾
                while (s.count(end + 1))
                {
                    end += 1;
                    s.erase(end); // 同样移除，优化后续查询
                }

                // 更新最长长度
                res = std::max(res, end - start + 1);
            }
        }

        return res;
    }
};

Python 代码

class Solution:
    def longestConsecutive(self, nums: List[int]) -> int:
      hash_set = set(nums)

      res = 0
      for start in nums:
        if start in hash_set and start - 1 not in hash_set:
          end = start
          while end in hash_set:
            hash_set.remove(end)
            end += 1
          res = max(res, end - start)
      return res

Go 代码

func longestConsecutive(nums []int) int {
  hash_set := make(map[int]bool)
  for _, x := range nums {
    hash_set[x] = true
  }

  res := 0
  for _, start := range nums {
    if hash_set[start] && !hash_set[start - 1] {
      end := start
      for hash_set[end] {
        delete(hash_set, end)
        end ++
      }
      if res < end - start {
        res = end - start
      }
    }
  }

  return res
}

JavaScript 代码

/**
 * @param {number[]} nums
 * @return {number}
 */
var longestConsecutive = function (nums) {
  let hash_set = new Set(nums);
  let res = 0;
  for (let start of nums) {
    if (hash_set.has(start) && !hash_set.has(start - 1)) {
      let end = start;
      while (hash_set.has(end)) {
        hash_set.delete(end);
        end++;
      }
      res = Math.max(res, end - start);
    }
  }
  return res;
};

twoSum

Thu, 21 Nov 2024 00:00:00 +0000

1. 两数之和

算法

利用哈希表存储数组元素及其下标：
- 使用一个哈希表，键为数组元素值，值为对应的下标
- 哈希表可以快速查询某个元素是否已经出现过
遍历数组，寻找目标值对应的数：
- 在遍历数组时，对于当前元素 nums[i]，计算另一个需要的数 x = target - nums[i]；
- 在哈希表中检查是否存在 x：
  - 如果 x 存在，说明找到了两个数，返回它们的下标
  - 如果 x 不存在，将当前数 nums[i] 及其索引存入哈希表，继续遍历

复杂度分析

时间复杂度

哈希表查询和插入：每次操作 O(1)
数组遍历：遍历一次数组，时间复杂度为 O(n)
总时间复杂度 O(n)

空间复杂度

需要一个哈希表存储数组中的元素及其索引，空间复杂度为 O(n)

C++ 代码

class Solution
{
public:
    vector<int> twoSum(vector<int>& nums, int target)
    {
        std::unordered_map<int, int> hash; // 哈希表存储元素值及其索引

        for (int i = 0; i < nums.size(); ++ i)
        {
            int x = target - nums[i]; // 计算需要的数

            // 检查是否在哈希表中
            if (hash.count(x))
                return {hash[x], i}; // 找到目标值，返回下标

            // 将当前数存入哈希表
            hash[nums[i]] = i;
        }

        return {}; // 如果无解，返回空数组（题目保证一定有解）
    }
};

Python 代码

class Solution:
  def twoSum(self, nums: List[int], target: int) -> List[int]:
    hash_map = {}
    for i, num in enumerate(nums):
      x = target - num
      if x in hash_map:
        return [hash_map[x], i]
      hash_map[num] = i
    return []

Go 代码

func twoSum(nums []int, target int) []int {
  hash_map := make(map[int]int)
  for i, num := range nums {
    x := target - num
    if idx, ok := hash_map[x]; ok {
      return []int{idx, i}
    }
    hash_map[num] = i
  }
  return []int{}
}

JavaScript 代码

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number[]}
 */
var twoSum = function (nums, target) {
  let hash_map = new Map();
  for (let i = 0; i < nums.length; i++) {
    let x = target - nums[i];
    if (hash_map.has(x)) {
      return [hash_map.get(x), i];
    }
    hash_map.set(nums[i], i);
  }
  return [];
};