LeetCode 177. 第N高的薪水(Nth Highest Salary):MySQL 存储函数 + Pandas 实现精讲(doocs/leetcode 题解)

原创2026-10-16 12:26:511,841 阅读
文章标签:教程示例工程教育

LeetCode 177. 第N高的薪水(Nth Highest Salary):MySQL 存储函数 + Pandas 实现精讲(doocs/leetcode 题解)

导读:本文围绕 LeetCode 177「第N高的薪水」展开,完整解析题目约束(去重、不足 N 个不同工资返回 null)、SQL 中 LIMIT ... OFFSET ... 的定位逻辑、MySQL 存储函数写法,以及 Pandas 数据框实现,并结合 doocs/leetcode 仓库中同系列题目(176、184、185)说明如何把「第 N 高」推广到分组 Top-N 场景。读完本文,你将掌握「第 K 大」类 SQL 查询的通用套路、函数封装与边界处理,可直接迁移到真实报表开发。

一、题目理解:查询第 N 高的「不同」工资

题目给出了一个极简的工资表 Employee:

Column Name Type
id int
salary int

其中 id 是主键(列中的值互不相同),每一行代表一名员工的工资信息。

要解决的问题是:查询 Employee 表中第 n 高的不同工资;如果少于 n 个不同工资,查询结果应为 null。

这里有两个关键限定词值得注意:

  1. 「不同」:工资相同只算一个档次,例如两名员工都拿 100,那么在去重后的序列里 100 只出现一次;
  2. 不足则返回 null:当不同工资的数量小于 n 时,不能报错,也不能返回空结果集,而是要返回一行 null。

示例推演

示例 1:表中存在 100、200、300 三个不同工资,n = 2,第 2 高为 200:

输入:
Employee table:
+----+--------+
| id | salary |
+----+--------+
| 1  | 100    |
| 2  | 200    |
| 3  | 300    |
+----+--------+
n = 2

输出:
+------------------------+
| getNthHighestSalary(2) |
+------------------------+
| 200                    |
+------------------------+

示例 2:表中只有一个不同工资 100,n = 2,不足 2 个不同工资,结果应为 null:

输入:
Employee 表:
+----+--------+
| id | salary |
+----+--------+
| 1  | 100    |
+----+--------+
n = 2

输出:
+------------------------+
| getNthHighestSalary(2) |
+------------------------+
| null                   |
+------------------------+

注意输出列名不是固定的,而是由参数 n 动态拼成的 getNthHighestSalary(n),这在 Pandas 实现中需要用格式化字符串动态构造列名。

二、解题思路:从「第二高」推广到「第 N 高」

本题是经典题 176. 第二高的薪水 的推广。回顾 176 题的思路:去重、降序后取下标为 1(即第二项)的工资。把「第二」推广到「第 N 高」只需要把固定下标 1 换成 N - 1:

  • 去重:DISTINCT salary,保证并列工资只占一个名次;
  • 降序:ORDER BY salary DESC,让最高工资排在最前;
  • 定位:取降序序列中下标为 N - 1 的元素,在 SQL 中即 LIMIT 1 OFFSET N - 1;
  • 兜底:当 N < 1 或不同工资不足 N 个时,返回 null(SQL 中通过外层 SELECT 包裹,把空结果集变成一行 NULL;Pandas 中则显式返回 [None])。

这一思路被 doocs/leetcode 仓库原样沉淀在题解中:解法核心是「排序 + LIMIT」,完整实现在 Solution.sql 与 Solution.py,并在 README.md 中通过 tab 形式同时给出 MySQL 与 Python3 两种实现。

三、MySQL 实现:存储函数封装 + LIMIT OFFSET

由于 LeetCode 要求返回一个可被直接调用的查询,本题在 MySQL 侧用「存储函数」封装。仓库提供的完整代码如下:

CREATE FUNCTION getNthHighestSalary(N INT) RETURNS INT
BEGIN
    SET N = N - 1;
  RETURN (
      # Write your MySQL query statement below.
      SELECT (
          SELECT DISTINCT salary
          FROM Employee
          ORDER BY salary DESC
          LIMIT 1 OFFSET N
      )
  );
END

逐行拆解这段代码:

部分 作用
CREATE FUNCTION getNthHighestSalary(N INT) RETURNS INT 定义接收整数参数 N、返回 INT 的存储函数
SET N = N - 1; 把「第 N 高」的语义转换为 0 起始的下标偏移量,即 OFFSET N - 1
内层 SELECT DISTINCT salary ... ORDER BY salary DESC LIMIT 1 OFFSET N 去重、降序后跳过前 N 行取 1 行,即第 N 高的不同工资
外层 SELECT (...) 关键兜底:当内层查询命中 0 行(不同工资不足 N 个)时,外层会把空结果转换为单个 NULL 值,保证查询始终返回一行

这里有两个 SQL 细节值得展开:

  1. 为什么外层还要包一层 SELECT? 这是本题最容易踩坑的地方。单纯执行 SELECT DISTINCT salary FROM Employee ORDER BY salary DESC LIMIT 1 OFFSET N,当不足 N 个不同工资时会得到空结果集,而不是一行 null。外层再套一层 SELECT (子查询) 后,子查询的标量结果会被自动转换为 NULL,从而满足题目「结果应为 null」的要求。
  2. LIMIT 1 OFFSET N 的语义:LIMIT 限制返回行数,OFFSET 指定跳过的行数(从 0 开始计数)。N = 1 时偏移 0 取最高工资,N = 2 时偏移 1 取第二高,与「去重后第 N 项」的数学下标一一对应。

四、Pandas 实现:用 Python 数据框等价还原

LeetCode 的数据库题目在 Pandas 侧同样需要返回 DataFrame,仓库的 Python 实现如下:

import pandas as pd


def nth_highest_salary(employee: pd.DataFrame, N: int) -> pd.DataFrame:
    if N < 1:
        return pd.DataFrame({"getNthHighestSalary(" + str(N) + ")": [None]})
    unique_salaries = employee.salary.unique()
    if len(unique_salaries) < N:
        return pd.DataFrame([None], columns=[f"getNthHighestSalary({N})"])
    else:
        salary = sorted(unique_salaries, reverse=True)[N - 1]
        return pd.DataFrame([salary], columns=[f"getNthHighestSalary({N})"])

该实现与 SQL 解法一一对应,逻辑分三层:

  1. 参数合法性:N < 1 时直接返回一行 None,列名 getNthHighestSalary(N) 保留原参数值(注意此处拼接的是原始 N 而非 N - 1);
  2. 数量不足判断:employee.salary.unique() 得到去重后的工资数组(等价于 SQL 的 SELECT DISTINCT salary);若去重后数量小于 N,返回 [None],对应 SQL 中外层包裹产生的 NULL;
  3. 取第 N 高:sorted(unique_salaries, reverse=True) 等价于 ORDER BY salary DESC,[N - 1] 下标等价于 LIMIT 1 OFFSET N - 1,最后用 f"getNthHighestSalary({N})" 动态构造输出列名。

两个语言实现的差异点也值得记录:SQL 通过外层 SELECT 隐式把空集变成 NULL;Pandas 则必须显式用 if len(...) < N 判断并返回 [None],否则 sorted(...)[N - 1] 会直接抛出 IndexError。这一差异正是「去重 + 偏移」类查询在两种技术栈下的边界处理范本。

五、边界条件与易错点小结

结合上述实现,整理本题所有边界情况:

场景 SQL 行为 Pandas 行为
N = 1 OFFSET 0,返回最高工资 [N-1] 取下标 0,返回最高工资
N = 2,且有 3 个不同工资 OFFSET 1,返回第二高 [1] 返回第二高
N 大于不同工资数量 内层空集,外层包裹后返回 NULL len(unique_salaries) < N 分支返回 [None]
N < 1 语义上无意义(第 0 高/负数) 单独分支返回 [None],列名保留原 N
存在并列工资 DISTINCT 去重后只计一个名次 unique() 去重后只计一个名次

第 5 点(并列工资)是理解本题「不同工资」的关键:100、100、200 三条记录中,第 2 高是 100 而非空,因为去重后序列为 [200, 100],这正是 DISTINCT / unique() 存在的意义。

六、同系列进阶:把「第 N 高」推广到分组 Top-N

「第 N 高」是数据库排名类问题的最小单元,doocs/leetcode 仓库中紧邻的几道题就是它的直接进阶,可以在掌握本题后一并练习:

  • 176. 第二高的薪水:本题的 N = 2 特例。仓库题解给出了三种思路:LIMIT 1, 1 子查询、MAX() + 小于最高薪的子查询(空集上 MAX 自然为 NULL,无需再包一层)、以及 DENSE_RANK() 窗口函数按薪水降序编号后筛选 rk = 2;
  • 184. 部门工资最高的员工:把「全局第 1 高」推广为「每个部门第 1 高」,涉及等值连接 + 子查询求每组 MAX(salary),或用 RANK() OVER (PARTITION BY ...) 后筛 rk = 1(并列最高会全部保留);
  • 185. 部门工资前三高的所有员工:再进一步到「每个部门 Top 3」,仓库给出两种解法:相关子查询统计「该部门有多少个严格更高的不同薪水」,小于 3 即进入前三;或 DENSE_RANK() OVER (PARTITION BY departmentId ORDER BY salary DESC) 后筛 rk <= 3。DENSE_RANK 与 RANK 的关键区别在于:前者在并列时不跳号(85000、85000 之后是 3 而非 4),语义与「第 N 高」完全一致。

对照这三道题可以看出清晰的进阶路径:LIMIT + OFFSET 解决「全局第 N 高」,PARTITION BY 分组 + 窗口函数解决「分组 Top-N」,而窗口函数版本正是本题解法在数据量更大、查询更复杂时的首选替代方案。

七、仓库配套资源与如何查阅

在 doocs/leetcode 仓库中,本题的资源组织遵循统一的目录规范,方便按题号检索与对比:

仓库的数据库题目全部集中在 solution 目录下(题号 0100-0199 区间含大量 SQL 题),并配有 DATABASE_README.md 汇总索引,适合把「第 N 高」相关的排名问题放在一起系统训练。若需在本地运行上述代码,可直接将 Solution.sql 导入 MySQL 后执行 SELECT getNthHighestSalary(2); 验证;Pandas 实现则可构造包含 id、salary 两列的 DataFrame 后调用 nth_highest_salary(employee, N) 验证边界行为。

登录后查看全文
leetcode