LeetCode 176「第二高的薪水」全解析:三种 SQL 解法与 Pandas 实现

原创2026-10-16 12:25:001,762 阅读
文章标签:教程示例工程教育

LeetCode 176「第二高的薪水」全解析:三种 SQL 解法与 Pandas 实现

导读

本文围绕 doocs/leetcode 仓库中 LeetCode 176「第二高的薪水(Second Highest Salary)」一题,完整讲解题目约束、两种边界示例,以及仓库给出的三套 SQL 解法(子查询 + LIMIT、MAX() 聚合、DENSE_RANK() 窗口函数)和一套 Pandas 解法。读完你将掌握「第 k 高」类 SQL 查询的通用套路、NULL 兜底的两种写法,以及去重语义在 SQL 与 Pandas 中的对应实现,并能据此推广到第 N 高薪水、分数排名等同类数据库面试题。

问题背景与表结构

题目定义了一张 Employee 表,结构如下:

列名 类型
id int
salary int

其中 id 是该表的主键(取值唯一),每一行记录一位员工的薪水。

需要完成的任务是:查询并返回 Employee 表中第二高的「不同」薪水。两个关键约束:

  1. 去重:并列的最高薪水只算一个名次,因此「第二高」必须是 distinct 之后的第二个值;
  2. NULL 兜底:如果不同薪水不足两个(例如表里只有一行,或所有薪水都相同),查询结果必须返回 null(Pandas 场景下返回 None),而不是空结果集。

输出结果统一使用单列单行的格式,列名为 SecondHighestSalary。题目配套的完整中文题解位于 0176.Second Highest Salary/README.md,英文版位于 README_EN.md。

边界示例:正确性判定的两个基准

示例 1:存在第二高薪水

Employee 表:
+----+--------+
| id | salary |
+----+--------+
| 1  | 100    |
| 2  | 200    |
| 3  | 300    |
+----+--------+

输出:
+---------------------+
| SecondHighestSalary |
+---------------------+
| 200                 |
+---------------------+

薪水降序去重后为 300, 200, 100,第二个值为 200。

示例 2:不存在第二高薪水

Employee 表:
+----+--------+
| id | salary |
+----+--------+
| 1  | 100    |
+----+--------+

输出:
+---------------------+
| SecondHighestSalary |
+---------------------+
| null                |
+---------------------+

只有一种不同薪水,此时必须输出一行 null。这个示例专门用来考察「空结果如何转成 NULL」的处理,是三种 SQL 解法设计的核心差异点。

方法一:子查询 + LIMIT 排序取第二条

对应仓库文件:Solution.sql。

SELECT
    (
        SELECT DISTINCT salary
        FROM Employee
        ORDER BY salary DESC
        LIMIT 1, 1
    ) AS SecondHighestSalary;

执行过程拆解:

  1. 内层子查询先 SELECT DISTINCT salary 完成去重;
  2. ORDER BY salary DESC 按薪水降序排列,使去重后的序列为 300, 200, 100;
  3. LIMIT 1, 1 是 MySQL 的「偏移量, 行数」简写,含义是跳过 1 行、取 1 行,即取序列中第二项 200。等价的规范写法是 LIMIT 1 OFFSET 1;
  4. 关键点:当不同薪水不足两个时,内层子查询返回空结果集。此时把该子查询放在外层 SELECT 的选择列表中充当标量子查询,SQL 对「无行的标量子查询」会返回 NULL——这正是示例 2 所要求的输出。如果不加这层包裹,直接执行 SELECT DISTINCT ... LIMIT 1, 1,得到的将是空结果集而非一行 NULL,无法通过示例 2。

从仓库 Solution.sql 可以看到该解法被收录为方案一,核心思路即「去重 → 降序 → 偏移取第二条」,本质依赖一次排序,适用于表数据量适中、明确需要「取第 k 项」的场景。

方法二:MAX() 聚合函数 + 子查询

对应仓库文件:Solution2.sql。

SELECT MAX(salary) AS SecondHighestSalary
FROM Employee
WHERE salary < (SELECT MAX(salary) FROM Employee);

执行过程拆解:

  1. 内层 SELECT MAX(salary) 先求出全局最高薪水;
  2. WHERE salary < (全局最高) 过滤出所有严格小于最高薪水的行,去重后这些值中的最大者即第二高薪水;
  3. 关键点:当表里只有一个不同薪水时,WHERE 会把所有行过滤掉,聚合函数 MAX() 作用在空集上返回 NULL——SQL 聚合函数对空输入的默认结果就是 NULL,因此无需 LIMIT、也无需外层包裹,天然满足示例 2 的要求。

与方法一相比,该方法避开排序与偏移,依赖的是「小于全局最大值中的最大值」这一等价定义。两种写法在语义上完全等价,但实现路径不同:方法一显式排序,方法二借助 MAX() 聚合(在有索引时可利用索引快速求最值)。该方案收录于仓库 Solution2.sql。

方法三:CTE + DENSE_RANK() 窗口函数

对应仓库文件:Solution3.sql。

WITH T AS (
    SELECT salary, DENSE_RANK() OVER (ORDER BY salary DESC) AS rk
    FROM Employee
)
SELECT (SELECT DISTINCT salary FROM T WHERE rk = 2) AS SecondHighestSalary;

执行过程拆解:

  1. CTE(公共表表达式)T 用 DENSE_RANK() OVER (ORDER BY salary DESC) 为每行按薪水降序编号;
  2. 从 T 中筛选 rk = 2 的行,得到第二高薪水;
  3. 外层 SELECT DISTINCT 确保当多名员工并列第二时只输出一个值(DISTINCT 在此既完成去重,也让外层标量子查询最多返回一行);
  4. 再次利用「外层标量子查询无行时返回 NULL」的机制兜底:当不存在 rk = 2 时,结果为一行 NULL。

为什么选 DENSE_RANK() 而非 RANK() 或 ROW_NUMBER()?

以薪水序列 300, 300, 200, 100 为例,三种窗口函数的编号差异如下:

薪水 ROW_NUMBER() RANK() DENSE_RANK()
300 1 1 1
300 2 1 1
200 3 3 2
100 4 4 3
  • ROW_NUMBER() 对并列的 300 也分配不同序号,第二行仍可能是 300,语义错误;
  • RANK() 在并列后跳号(1, 1, 3),会把 200 排到第 3 名,同样错位;
  • DENSE_RANK() 不跳号(1, 1, 2),并列最高不会占用第二名,正好契合「第二高的不同薪水」这一去重语义,且与「第 k 高」的通用定义一致,便于推广。

这一写法收录于仓库 Solution3.sql。窗口函数方案在同仓库的「分数排名」一题(0178.Rank Scores/README.md)中有同类应用,两者可对照学习。

Pandas 实现:DataFrame 版本的等价逻辑

对应仓库文件:Solution.py。LeetCode 的 Pandas 环境要求以 pandas.DataFrame 为输入与输出,因此解法需要把 SQL 的「去重 + 排序 + 取第二条 + NULL 兜底」翻译成 DataFrame 操作:

import pandas as pd


def second_highest_salary(employee: pd.DataFrame) -> pd.DataFrame:
    # Drop any duplicate salary values to avoid counting duplicates as separate salary ranks
    unique_salaries = employee["salary"].drop_duplicates()

    # Sort the unique salaries in descending order and get the second highest salary
    second_highest = (
        unique_salaries.nlargest(2).iloc[-1] if len(unique_salaries) >= 2 else None
    )

    # If the second highest salary doesn't exist (e.g., there are fewer than two unique salaries), return None
    if second_highest is None:
        return pd.DataFrame({"SecondHighestSalary": [None]})

    # Create a DataFrame with the second highest salary
    result_df = pd.DataFrame({"SecondHighestSalary": [second_highest]})

    return result_df

逐行要点:

  1. employee["salary"].drop_duplicates():对应 SQL 的 SELECT DISTINCT salary,剔除重复薪水,保证名次按「不同值」计算;
  2. nlargest(2):取前两大值,等价于「降序排序后取前两个」;.iloc[-1] 取其中较小的那个,即第二高薪水;
  3. if len(unique_salaries) >= 2 else None:与 SQL 的兜底逻辑对应——不同薪水不足两个时,第二高不存在,赋值为 None;
  4. 返回值统一构造为单列 SecondHighestSalary、单行的 DataFrame,与题目要求的输出格式一致;不足两个时输出 [None],对应 SQL 的 null。

这段实现与 Solution.py 完全一致,可作为 Pandas 面试题的参考模板。

三种 SQL 方案对比与选型

方案 核心机制 去重方式 空结果兜底 对并列薪水的处理 主要开销 可推广性
方法一:子查询 + LIMIT 去重后降序偏移取第二条 DISTINCT 外层标量子查询返回 NULL 由 DISTINCT 保证 一次排序 可推广到第 N 高(改偏移量)
方法二:MAX() + 子查询 小于全局最大值的最大值 隐式(最大者唯一) MAX() 空集自然为 NULL 天然处理 两次求最值(无排序) 仅适用于第 2 高
方法三:DENSE_RANK() 窗口函数编号后筛 rk = 2 编号 + DISTINCT 输出 外层标量子查询返回 NULL 并列不占名次,语义最准 一次窗口计算 可推广到任意第 k 高

选型建议:追求最简语法选方法二;需要明确「排序取位」语义、便于迁移到其他数据库选方法一;题目若要求「第 k 高」且数据可能大量并列,方法三的 DENSE_RANK() 是最稳妥的通用方案。

延伸:从「第二高」到「第 N 高」

第二高薪水的解法可以自然推广到第 N 高:同仓库的 0177.Nth Highest Salary/README.md 将该思路封装为存储函数 getNthHighestSalary(N),核心是将 LIMIT 的偏移量改为 N - 1:

CREATE FUNCTION getNthHighestSalary(N INT) RETURNS INT
BEGIN
    SET N = N - 1;
  RETURN (
      SELECT (
          SELECT DISTINCT salary
          FROM Employee
          ORDER BY salary DESC
          LIMIT 1 OFFSET N
      )
  );
END

其中 SET N = N - 1 正是把「第 N 个」换算成「偏移 N-1」的偏移量,外层再包一层标量子查询保证不足 N 个不同薪水时输出 NULL——与本题目方法一的兜底思路一脉相承。

仓库文件速查

本专题在 doocs/leetcode 仓库中的相关文件:

小结:第二高薪水这道题虽然代码很短,却同时覆盖了「去重语义」「排序与偏移」「聚合函数空集行为」「窗口函数编号」「标量子查询 NULL 兜底」五个 SQL 高频考点。把三种方案逐一写一遍并理解其等价性,再对照 Pandas 版本体会两种数据处理范式的异同,是掌握数据库面试「第 k 高」类问题的高效路径。

登录后查看全文
leetcode