LeetCode 177. 第N高的薪水(Nth Highest Salary):MySQL 存储函数 + Pandas 实现精讲(doocs/leetcode 题解)
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。
这里有两个关键限定词值得注意:
- 「不同」:工资相同只算一个档次,例如两名员工都拿 100,那么在去重后的序列里 100 只出现一次;
- 不足则返回 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 细节值得展开:
- 为什么外层还要包一层
SELECT? 这是本题最容易踩坑的地方。单纯执行SELECT DISTINCT salary FROM Employee ORDER BY salary DESC LIMIT 1 OFFSET N,当不足 N 个不同工资时会得到空结果集,而不是一行null。外层再套一层SELECT (子查询)后,子查询的标量结果会被自动转换为NULL,从而满足题目「结果应为 null」的要求。 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 解法一一对应,逻辑分三层:
- 参数合法性:
N < 1时直接返回一行None,列名getNthHighestSalary(N)保留原参数值(注意此处拼接的是原始N而非N - 1); - 数量不足判断:
employee.salary.unique()得到去重后的工资数组(等价于 SQL 的SELECT DISTINCT salary);若去重后数量小于N,返回[None],对应 SQL 中外层包裹产生的NULL; - 取第 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 仓库中,本题的资源组织遵循统一的目录规范,方便按题号检索与对比:
- 题目中文题解 README:含题目描述、示例、MySQL 与 Python3 双语言解法;
- 题目英文题解 README_EN:英文版题目与解法,便于对照阅读;
- Solution.sql:可直接提交的 MySQL 存储函数;
- Solution.py:可直接运行的 Pandas 实现。
仓库的数据库题目全部集中在 solution 目录下(题号 0100-0199 区间含大量 SQL 题),并配有 DATABASE_README.md 汇总索引,适合把「第 N 高」相关的排名问题放在一起系统训练。若需在本地运行上述代码,可直接将 Solution.sql 导入 MySQL 后执行 SELECT getNthHighestSalary(2); 验证;Pandas 实现则可构造包含 id、salary 两列的 DataFrame 后调用 nth_highest_salary(employee, N) 验证边界行为。