Sort on Hang Zhang

Sort An Array

Mon, 17 Mar 2025 00:00:00 +0000

912. 排序数组

分析

选取基准：选择当前区间的第一个元素 nums[l] 作为基准 x
双指针划分：
- 使用 i 从左向右找大于等于 x 的元素
- 使用 j 从右向左找小于等于 x 的元素
- 交换 nums[i] 和 nums[j]，直到 i >= j，此时 j 是分界点
递归排序：
- 递归地对 [l, j] 和 [j + 1, r] 两部分继续快速排序，直到 l >= r

时间复杂度

时间复杂度 O(nlogn)

空间复杂度

空间复杂度为 O(logn)

C++代码

/***        quick sort      ***/
class Solution
{
public:
    // 快速排序函数
    void quick_sort(std::vector<int>& nums, int l, int r)
    {
        if (l >= r) // 递归终止条件
            return;

        int x = nums[l], i = l - 1, j = r + 1;

        // 双指针划分
        while (i < j)
        {
            do ++i; while (nums[i] < x); // 找到大于等于 x 的元素
            do --j; while (nums[j] > x); // 找到小于等于 x 的元素
            if (i < j)
                std::swap(nums[i], nums[j]); // 交换不符合位置的元素
        }

        quick_sort(nums, l, j);   // 递归处理左半部分
        quick_sort(nums, j + 1, r); // 递归处理右半部分
    }

    vector<int> sortArray(vector<int>& nums)
    {
        quick_sort(nums, 0, nums.size() - 1);
        return nums;
    }
};

Sort

Mon, 17 Feb 2025 00:00:00 +0000

排序

#include <iostream>
#include <algorithm>
#include <vector>

void quick_sort(std::vector<int>& nums, int l, int r);
void merge_sort(std::vector<int>& nums, int l, int r);
void select_sort(std::vector<int>& nums);
void insert_sort(std::vector<int>& nums);
void binary_sort(std::vector<int>& nums);
void bubble_sort(std::vector<int>& nums);

int main()
{
  int n;
  scanf("%d", &n);

  std::vector<int> nums(n);
  for (int i = 0; i < n; ++ i)
    scanf("%d", &nums[i]);

  quick_sort(nums, 0, n - 1);
  merge_sort(nums, 0, n - 1);
  select_sort(nums);
  insert_sort(nums);
  binary_sort(nums);
  bubble_sort(nums);

  for (int i = 0; i < n; ++ i)
    printf("%d ", nums[i]);

  return 0;
}

快速排序

选取基准值（pivot）：x = nums[(l + r) >> 1]
双指针划分数组：
- i 从左往右，找到第一个 ≥ pivot 的数
- j 从右往左，找到第一个 ≤ pivot 的数
- 交换 nums[i] 和 nums[j]，直到 i >= j
递归处理左右子数组：
- 递归排序 [l, j]（左半部分）
- 递归排序 [j+1, r]（右半部分）

复杂度

时间复杂度
- 最佳情况（每次都均匀划分）：O(nlogn)
- 平均情况（随机数据）：O(nlogn)
- 最坏情况（已排序数组，划分极端不均匀）：O(n²)
空间复杂度
- 最坏情况（单侧划分，递归深度 O(n))）：O(n)
- 平均情况（均匀划分，递归深度 O(logn))）：O(logn)

void quick_sort(std::vector<int>& nums, int l, int r)
{
  if (l >= r) return;  // 递归终止条件

  int i = l - 1, j = r + 1, x = nums[(l + r) >> 1]; // 取中间值作为基准
  while (i < j)
  {
    do ++i; while (nums[i] < x); // 找到左侧大于等于 pivot 的元素
    do --j; while (nums[j] > x); // 找到右侧小于等于 pivot 的元素
    if (i < j)
      std::swap(nums[i], nums[j]); // 交换不符合条件的元素
  }

  quick_sort(nums, l, j);   // 递归排序左半部分
  quick_sort(nums, j + 1, r); // 递归排序右半部分
}

归并排序

递归地将数组划分为左右两部分：
- 直到子数组长度为 1，即 l >= r，终止递归
分别对左右两部分进行排序：
- 递归调用 merge_sort(nums, l, mid)
- 递归调用 merge_sort(nums, mid + 1, r)
合并两个有序数组：
- 使用双指针方法合并 nums[l ~ mid] 和 nums[mid+1 ~ r]
- 额外使用一个 tmp 数组存储排序后的结果，再复制回 nums

复杂度

时间复杂度
- 每次划分数组需要 O(logn) 次递归
- 每次合并两个有序数组需要 O(n) 时间
- 总时间复杂度：O(nlogn)
空间复杂度
- 需要额外 O(n) 的辅助数组 tmp 存储合并结果
- 总空间复杂度：O(n)

void merge_sort(std::vector<int>& nums, int l, int r)
{
  if (l >= r) return;  // 递归终止条件：子数组长度为1

  int mid = (l + r) >> 1;  // 取中间点
  merge_sort(nums, l, mid);  // 递归排序左半部分
  merge_sort(nums, mid + 1, r);  // 递归排序右半部分

  std::vector<int> tmp(nums.size());  // 临时数组用于合并
  int i = l, j = mid + 1, k = 0;  // i 遍历左半部分，j 遍历右半部分

  // 归并两个有序子数组
  while (i <= mid && j <= r)
  {
    if (nums[i] <= nums[j])
      tmp[k++] = nums[i++];  // 选较小的数加入临时数组
    else
      tmp[k++] = nums[j++];
  }

  // 处理剩余元素
  while (i <= mid) tmp[k++] = nums[i++];
  while (j <= r) tmp[k++] = nums[j++];

  // 复制回原数组
  for (int i = l, k = 0; i <= r; ++i, ++k)
    nums[i] = tmp[k];
}

堆排序

建堆：从最后一个非叶子节点 n/2 开始自上而下堆化 down()
- 建立大根堆：
  - 满足大根堆的性质：父节点大于等于子节点
- 建立小根堆：
  - 满足小根堆的性质：父节点小于等于子节点
排序：
- 交换堆顶元素（最大值/最小值）和堆尾元素，然后调整剩余元素继续保持大根堆/小根堆
- 每次取出堆顶元素，最终形成升序/降序排列

复杂度

时间复杂度
- 建堆：O(n)
- 排序调整堆：每次 down() 需要 O(log n)，执行 n 次，总计 O(nlogn)
- 总时间复杂度：O(nlogn)
空间复杂度
- 堆排序在原数组上进行排序，没有额外的数组存储，空间复杂度 O(1)

#include <iostream>
#include <algorithm>
#include <vector>

// 维护小根堆性质 (较大值向下调整)
void big_down(std::vector<int>& nums, int u, int sz)
{
    int t = u;
    if (u * 2 <= sz && nums[t] > nums[u * 2])  // 左子节点较小
        t = u * 2;
    if (u * 2 + 1 <= sz && nums[t] > nums[u * 2 + 1])  // 右子节点较小
        t = u * 2 + 1;

    if (t != u)  // 需要交换
    {
        std::swap(nums[t], nums[u]);
        big_down(nums, t, sz);  // 递归调整
    }
}

// 维护大根堆性质 (较小值向下调整)
void small_down(std::vector<int>& nums, int u, int sz)
{
    int t = u;
    if (u * 2 <= sz && nums[t] < nums[u * 2])  // 左子节点较大
        t = u * 2;
    if (u * 2 + 1 <= sz && nums[t] < nums[u * 2 + 1])  // 右子节点较大
        t = u * 2 + 1;

    if (t != u)  // 需要交换
    {
        std::swap(nums[t], nums[u]);
        small_down(nums, t, sz);  // 递归调整
    }
}

int main()
{
    int n;
    scanf("%d", &n);

    // 下标从1开始存储堆，避免叶子结点边界处理
    std::vector<int> nums(n + 1);
    for (int i = 1; i <= n; ++i)
    {
        scanf("%d", &nums[i]);
    }

    // 建堆 (从最后一个非叶子节点开始)
    for (int i = n / 2; i >= 1; --i)
    {
        big_down(nums, i, n);
    }

    int sz = n;
    // 堆排序
    for (int i = 0; i < n; ++i)
    {
        printf("%d ", nums[1]);  // 输出堆顶元素
        std::swap(nums[1], nums[sz]);  // 交换堆顶和堆尾元素
        -- sz;  // 缩小堆的范围
        big_down(nums, 1, sz);  // 重新调整堆
    }
    printf("\n");

    return 0;
}

选择排序

在第 i 轮中，从 i 到 n - 1 中选择最小值，并将其与 i 位置交换
进行 n - 1 轮排序后，数组有序

复杂度

时间复杂度 O(n^2)
空间复杂度 O(1)

void select_sort(std::vector<int>& nums)
{
  for (int i = 0; i < nums.size() - 1; ++i)
  {
    int min_idx = i;  // 记录当前最小值的索引
    for (int j = i + 1; j < nums.size(); ++j)
      if (nums[min_idx] > nums[j])  // 找到更小的元素
        min_idx = j;

    std::swap(nums[i], nums[min_idx]);  // 交换当前元素与最小值
  }
}

插入排序

从第二个元素开始，假设第一个元素已经是有序的
比较当前元素与已排序部分的元素，找到合适的插入位置
将当前元素插入到合适的位置，并调整数组中元素的位置

复杂度

时间复杂度
- 最佳情况（数组已经有序）：O(n)
  - 只需进行一次比较即可，每个元素都只需插入一次
- 最坏情况（数组逆序）：O(n^2)
  - 每次插入时需要将前面的所有元素都移动一遍
- 平均时间复杂度：O(n^2)
空间复杂度
- 空间复杂度：O(1)，插入排序是原地排序，无需额外空间

void insert_sort(std::vector<int>& nums)
{
  for (int i = 1; i < nums.size(); ++ i)  // 从第二个元素开始
  {
    int x = nums[i], j = i;  // 保存当前元素并从当前位置开始向前检查
    while (j >= 1 && x < nums[j - 1])  // 查找插入位置
    {
      nums[j] = nums[j - 1];  // 向右移动元素
      -- j;  // 移动索引
    }
    nums[j] = x;  // 插入当前元素
  }
}

折半插入排序

从第二个元素开始，假设第一个元素已经是有序的
使用二分查找在已排序部分找到插入的位置
将当前位置之后的元素向后移动一位，并将当前元素插入到找到的位置

复杂度

时间复杂度
- 最佳情况（数组已经有序）：O(n)
  - 每次只需进行一次比较即可，每个元素都只需插入一次
- 最坏情况（数组逆序）：O(n^2)
  - 二分查找将时间复杂度降低为 O(logn)，但每次插入仍然需要将元素移动，整体仍为 O(n^2)
- 平均时间复杂度：O(n^2)
空间复杂度
- 空间复杂度：O(1)，原地排序，不需要额外的空间

void binary_sort(std::vector<int>& nums)
{
  for (int i = 1; i < nums.size(); ++ i)  // 从第二个元素开始
  {
    if (nums[i - 1] < nums[i])  // 如果当前元素比前一个元素大，则跳过
      continue;

    int x = nums[i];  // 保存当前元素
    int l = 0, r = i - 1;  // 设置二分查找的左右边界

    while (l < r)  // 二分查找插入位置
    {
      int mid = (l + r) >> 1;
      if (x < nums[mid])
        r = mid;  // 当前元素小于mid，右边界左移
      else
        l = mid + 1;  // 当前元素大于mid，左边界右移
    }

    for (int j = i - 1; j >= r; -- j)  // 移动元素
      nums[j + 1] = nums[j];
    nums[r] = x;  // 插入当前元素到正确的位置
  }
}

冒泡排序

冒泡排序主要通过重复交换相邻的元素来将较小的元素冒泡到数组的前端，较大的元素则被“推”到数组的末端

比较相邻元素：从数组的第一个元素开始，逐一比较相邻的两个元素。如果它们的顺序不正确（即前一个元素大于后一个元素），则交换它们的位置
冒泡操作：经过一轮遍历后，最小的元素被冒泡到数组的前端
重复遍历：继续对剩余部分进行相同的操作，直到整个数组排序完成
提前终止：如果某一轮遍历中没有发生交换，说明数组已经是有序的，可以提前终止排序

复杂度

时间复杂度分析
- 最坏时间复杂度：O(n^2)，即当数组完全逆序时，每一轮都需要交换，每一对相邻元素都会进行比较和交换
- 最佳时间复杂度：O(n)，即当数组已经是有序时，只需进行一次遍历，不需要交换
- 平均时间复杂度：O(n^2)，适用于随机排列的数组
空间复杂度
- 空间复杂度：O(1)，原地排序，不需要额外的存储空间

void bubble_sort(std::vector<int>& nums)
{
  for (int i = 0; i < nums.size() - 1; ++ i) // 外层循环控制排序的轮数
  {
    bool is_swap = false; // 用于检查是否发生交换
    for (int j = nums.size() - 1; j > i; -- j) // 内层循环进行元素的比较与交换
    {
      if (nums[j] < nums[j - 1]) // 如果前一个元素大于后一个元素
      {
        std::swap(nums[j], nums[j - 1]); // 交换元素
        is_swap = true; // 标记发生了交换
      }
    }

    if (!is_swap) // 如果没有发生交换，说明数组已经有序，可以提前结束
      break;
  }
}

Insertion Sort List

Sun, 19 Jan 2025 00:00:00 +0000

147. 对链表进行插入排序

分析

使用一个虚拟头节点 dummy 来方便构建有序链表
遍历原链表：
- 对于当前节点 p，从虚拟头节点 dummy 开始查找它应插入的位置
- 插入后调整指针以确保链表仍然连接正确
继续处理下一节点，直到原链表遍历结束
返回排序后的链表

时间复杂度

外层遍历链表，每个节点插入有序链表的过程中需查找插入位置。
最坏情况下（链表反序），插入每个节点需要遍历整个有序链表，时间复杂度为 O(n^2)，其中 n 是链表的长度

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    ListNode* insertionSortList(ListNode* head)
    {
        // 创建虚拟头节点
        ListNode* dummy = new ListNode(-1);
        ListNode* p = head;

        // 遍历原链表
        while (p)
        {
            // 找到插入点：从 dummy 开始找到第一个大于当前节点值的位置
            ListNode* cur = dummy;
            while (cur->next && cur->next->val <= p->val)
                cur = cur->next;

            // 插入当前节点到有序链表
            ListNode* next = p->next;  // 保存下一个节点
            p->next = cur->next;      // 当前节点指向插入位置后的节点
            cur->next = p;            // 插入当前节点到有序链表
            p = next;                 // 继续处理下一个节点
        }

        // 返回排序后的链表
        return dummy->next;
    }
};

H Index

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

274. H指数

算法

将引用次数降序排序。排序后，论文的引用次数是递减的，若第 i 篇论文（索引为 i - 1）的引用次数大于等于 i，则前面 i - 1 篇论文的引用次数也大于等于 i，，那么就有至少 i 篇论文的引用次数大于等于 i，即满足 H 指数条件

降序排序：
- 将引用次数从大到小排序，便于直接比较引用次数与当前索引 i
遍历判断：
- 从 i = n ~ 1（n 为论文总数），逐步判断
- 如果第 i 篇论文的引用次数 citations[i - 1] >= i，则满足 H 指数定义
- 返回当前 i 即为最大 H 指数
未找到满足条件的 H 指数：
- 如果遍历结束都没有找到，返回 0

复杂度分析

排序需要 O(nlogn) 时间，遍历一次数组 O(n)，总体时间复杂度为 O(nlogn)
空间复杂度为 O(1)

C++ 代码

class Solution
{
public:
    int hIndex(vector<int>& citations)
    {
        // 1. 将引用次数降序排序
        std::sort(citations.begin(), citations.end(), std::greater<int>());

        // 2. 从大到小遍历，找到满足条件的最大 i
        for (int i = citations.size(); i > 0; -- i)
            if (citations[i - 1] >= i)
                return i;  // 找到最大 i，直接返回

        // 3. 如果没有满足条件的 i，返回 0
        return 0;
    }
};

Python 代码

class Solution:
    def hIndex(self, citations: List[int]) -> int:
      citations.sort(reverse=True)
      n = len(citations)
      for i in range(n, 0, -1):
        if citations[i - 1] >= i:
          return i
      return 0

Go 代码

func hIndex(citations []int) int {
  sort.Slice(citations, func(i, j int) bool {
    return citations[i] > citations[j]
  })
  for i := len(citations); i > 0; i -- {
    if citations[i - 1] >= i {
      return i
    }
  }
  return 0
}

Minimum Number Of Arrows To Burst Balloons

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

452. 用最少数量的箭引爆气球

算法

要保证最少的弓箭数，我们可以采用如下贪心策略：
- 按区间的结束点升序排序：优先处理结束点较小的区间，这样可以最大化覆盖更多的区间
- 每次发射箭时，记录当前箭能够覆盖的结束点 r 。如果后续某个气球的开始点 x_start 大于当前箭的覆盖范围 r，则需要发射一支新的箭

将所有气球的直径区间按照结束点升序排序
初始化箭的数量 res 为 1，并将第一支箭的覆盖范围设为第一个区间的结束点
遍历排序后的区间：
- 如果当前区间的开始点大于箭的覆盖范围，说明需要一支新的箭来覆盖当前气球
- 更新箭的覆盖范围为当前区间的结束点

复杂度分析

排序的时间复杂度为 O(nlogn)，其中 n 是气球的数量；遍历区间的复杂度为 O(n)；总时间复杂度为 O(nlogn)
空间复杂度为 O(1)

C++ 代码

class Solution
{
public:
    int findMinArrowShots(vector<vector<int>>& points)
    {
        // 如果没有气球，返回 0
        if (points.empty())
            return 0;

        // 按区间结束点升序排序
        std::sort(points.begin(), points.end(), [](std::vector<int> a, std::vector<int> b) {
            return a[1] < b[1];
        });

        // 初始化箭的数量和当前箭的覆盖范围
        int res = 1; // 至少需要一支箭
        int r = points[0][1]; // 第一支箭的覆盖范围

        // 遍历剩余的区间
        for (int i = 1; i < points.size(); ++i)
        {
            // 如果当前区间的起始点在当前箭的覆盖范围之外
            if (r < points[i][0])
            {
                ++res; // 增加一支箭
                r = points[i][1]; // 更新箭的覆盖范围
            }
        }

        return res;
    }
};

Python 代码

class Solution:
    def findMinArrowShots(self, points: List[List[int]]) -> int:
      points.sort(key = lambda point: point[1])
      res, r = 1, points[0][1]
      for i in range(1, len(points)):
        if r < points[i][0]:
          r = points[i][1]
          res += 1
      return res

Go 代码

import "sort"

func findMinArrowShots(points [][]int) int {
  sort.Slice(points, func(i, j int) bool {
    return points[i][1] < points[j][1]
  })
  res, r := 1, points[0][1]
  for i := 1; i < len(points); i += 1 {
    if r < points[i][0] {
      r = points[i][1]
      res += 1
    }
  }
  return res
}

Non Overlapping Intervals

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

435. 无重叠区间

分析

要保证最多的不重叠区间数，可以采用如下贪心策略：
- 按区间的结束点升序排序：结束点越早，剩余空间越多，更容易为后续区间预留空间
- 遍历排序后的区间，选择与前一个区间不重叠的区间，将其加入到保留的集合中

先按结束点排序。
初始化计数变量 count，记录当前不wq重叠区间的数量，初始值为 1
遍历排序后的区间：
- 如果当前区间的起始点 start 不小于上一个保留区间的结束点 cur，说明它与前面的区间不重叠，更新 cur 并增加计数
最后，用总区间数减去 count 即为需要移除的区间数

时间复杂度

排序的时间复杂度为 O(nlogn) ，其中 n 是区间的数量
遍历区间的复杂度为 O(n)

总时间复杂度为 O(nlogn)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    int eraseOverlapIntervals(vector<vector<int>>& intervals)
    {
        // 如果没有区间，直接返回 0
        if (intervals.empty())
            return 0;

        // 按区间的结束点升序排序
        std::sort(intervals.begin(), intervals.end(), [](std::vector<int> a, std::vector<int> b) {
            return a[1] < b[1];
        });

        // 初始化计数器和当前区间结束点
        int count = 1; // 至少有一个区间不重叠
        int cur = intervals[0][1];

        // 遍历剩余的区间
        for (int i = 1; i < intervals.size(); ++i)
        {
            // 如果当前区间不重叠，则更新结束点并增加计数
            if (cur <= intervals[i][0])
            {
                ++count;
                cur = intervals[i][1];
            }
        }

        // 总区间数 - 不重叠区间数 = 需要移除的区间数
        return intervals.size() - count;
    }
};

Search Suggestions System

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

1268. 搜索推荐系统

分析

排序产品数组
- 为了能够快速按字典序找到前缀匹配的产品，首先对 products 按字典序排序
前缀匹配
- 对 searchWord 的每个前缀：
  - 使用一个变量 cur 保存当前前缀（即累加输入的字母）
  - 使用一个指针 k 维护当前搜索范围的起点。对于排序后的数组，可以跳过所有小于 cur 的字符串，加速搜索。
  - 遍历从 k 开始的最多三个字符串，检查它们是否以 cur 为前缀，若满足条件则加入推荐结果
提前结束
- 对于排序后的数组，如果某个字符串不再满足当前前缀条件，后续的字符串也不可能满足，可以提前结束内层循环

时间复杂度

排序：O(mlogm)，其中 m 是 products 的长度
前缀匹配：对于 searchWord 的每个字符，我们最多遍历 products 中 3 个字符串，复杂度为 O(n * avgLen)，其中 n 是 searchWord 的长度，avgLen 是产品的平均长度

总复杂度：O(mlogm + n * avgLen

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    vector<vector<string>> suggestedProducts(vector<string>& products, string searchWord)
    {
        // 结果数组
        std::vector<std::vector<std::string>> res;

        // 按字典序排序产品数组
        std::sort(products.begin(), products.end());

        // 当前前缀和产品数组的起点指针
        std::string cur;
        int n = products.size(), k = 0;

        // 遍历 searchWord 的每个字母
        for (char c : searchWord)
        {
            cur += c; // 更新当前前缀

            // 移动指针 k 跳过所有小于当前前缀的字符串
            while (k < n && products[k] < cur)
                ++k;

            // 收集符合条件的最多三个产品
            std::vector<std::string> tmp;
            for (int i = k; i < n && i < k + 3; ++i)
            {
                // 判断当前字符串是否以 cur 为前缀
                if (products[i].substr(0, cur.size()) == cur)
                    tmp.push_back(products[i]);
                else
                    break; // 剪枝：后续字符串不会匹配，提前退出
            }

            // 将当前前缀的推荐结果加入结果数组
            res.push_back(tmp);
        }
        return res;
    }
};

Successful Pairs Of Spells And Potions

Sun, 05 Jan 2025 00:00:00 +0000

2300. 咒语和药水的成功对数

分析

排序药水数组：
- 为了快速确定满足条件的药水，我们对药水数组 potions 进行升序排序
二分查找：
- 对于每个咒语 spells[i]，计算所需药水的最小能量值：target = (success + spells[i] - 1) / spells[i]
- 使用二分查找找到第一个大于等于 target 的药水位置 pos
- 满足条件的药水数量为 m - pos，其中 m 是药水数组的长度
返回结果：
- 对每个咒语计算成功组合的药水数量，并存储在结果数组 res 中

时间复杂度

药水数组排序：O(mlogm)
对每个咒语进行二分查找：O(nlogm)

总时间复杂度：O(mlogm + nlogm)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution {
public:
    // 二分查找：找到第一个大于等于 target 的药水位置
    int search(std::vector<int>& potions, long long target)
    {
        int l = 0, r = potions.size();
        while (l < r)
        {
            int mid = (l + r) >> 1;
            if (potions[mid] >= target)
                r = mid;
            else
                l = mid + 1;
        }
        return r;
    }

    vector<int> successfulPairs(vector<int>& spells, vector<int>& potions, long long success)
    {
        int n = spells.size(), m = potions.size();
        std::sort(potions.begin(), potions.end()); // 排序药水数组
        std::vector<int> res(n);
        for (int i = 0; i < n; ++i)
        {
            // 计算当前咒语的 target 值
            int pos = search(potions, (success + spells[i] - 1) / spells[i]);
            res[i] = m - pos; // 成功组合数量
        }
        return res;
    }
};

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());
};

mergeIntervals

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

56. mergeIntervals

分析

排序：
- 首先将所有区间按照起始值从小到大排序。排序后，若两个区间有重叠，它们一定是相邻的
遍历与合并：
- 用变量 l 和 r 分别表示当前合并区间的起始和结束
- 遍历排序后的区间：
  - 如果当前遍历区间的起始值大于当前合并区间的结束值 r，说明当前区间与前面的合并区间没有重叠，应将前面的合并区间加入结果，并更新 l 和 r
  - 如果有重叠，则将 r 更新为当前区间结束值的较大值
- 遍历结束后，将最后一个合并区间加入结果

时间复杂度

排序：O(nlogn) ，n 是区间的数量
遍历：O(n)，每个区间只会被处理一次

总时间复杂度为 O(nlogn)

空间复杂度

排序所需的额外空间复杂度为 O(logn) （排序算法的递归栈空间）
结果存储的空间复杂度为 O(n)

总空间复杂度为 O(n)

C++代码

class Solution {
public:
    vector<vector<int>> merge(vector<vector<int>>& intervals)
    {
        vector<vector<int>> res; // 用于存储最终结果

        if (intervals.empty()) return res; // 如果输入为空，直接返回空数组

        // 1. 按区间的起始值排序
        sort(intervals.begin(), intervals.end());

        // 2. 初始化合并区间的左右边界
        int l = intervals[0][0], r = intervals[0][1];

        // 3. 遍历剩余区间
        for (int i = 1; i < intervals.size(); ++ i) {
            // 当前区间的起始值 > 当前合并区间的结束值，说明没有重叠
            if (r < intervals[i][0]) {
                res.push_back({l, r});  // 将当前合并区间加入结果
                l = intervals[i][0];   // 更新新的合并区间的起始值
                r = intervals[i][1];   // 更新新的合并区间的结束值
            } else {
                // 如果有重叠，则更新当前合并区间的结束值
                r = max(r, intervals[i][1]);
            }
        }

        // 将最后一个合并区间加入结果
        res.push_back({l, r});

        return res;
    }
};