LeetCode 177:第 N 高的薪水(Nth Highest Salary)——SQL 存储函数与 pandas 双语言实现详解

原创2026-10-16 12:29:151,864 阅读
文章标签:教程示例工程教育

LeetCode 177:第 N 高的薪水(Nth Highest Salary)——SQL 存储函数与 pandas 双语言实现详解

本篇文章基于开源仓库 doocs/leetcode 中 0177.Nth Highest Salary 题解的完整内容展开,讲解如何在 MySQL 中编写存储函数查询第 n 高的不同工资,并用 Python3(pandas)给出等价实现。读完本文,你将掌握「排序 + LIMIT 偏移」这一数据库分页取值的核心套路、存储函数中参数偏移的处理方式,以及 pandas 版本在边界条件下的防御性写法,并能将其直接推广到其他「第 k 高 / 第 k 大」类问题。

题目要求与表结构

题目给出了一张 Employee 表,结构如下:

+-------------+------+
| Column Name | Type |
+-------------+------+
| id          | int  |
| salary      | int  |
+-------------+------+

其中 id 是该表的主键(列中的值互不相同),每一行记录一名员工的工资信息。需要解决的问题是:

编写一个解决方案,查询 Employee 表中第 n 高的不同工资;如果少于 n 个不同工资,查询结果应为 null。

注意两个容易被忽略的关键点:

  1. 去重:题面强调的是「第 n 高的不同工资」,即多个员工拥有相同薪水时,该薪水只占一个名次;
  2. 空值兜底:当不同工资数量不足 n 个,甚至 n 本身小于 1 时,结果必须是 null 而不是空结果集。

示例一:正常命中

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

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

薪水去重后为 100、200、300,降序排列为 300、200、100,第 2 高是 200。

示例二:不足 n 个不同工资

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

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

表中只有一个不同薪水,不足 n = 2 个,因此返回 null。

解题思路:去重、降序、取第 N 项

这道题可以视为「第二高的薪水」(LeetCode 176)的推广:176 题固定取降序序列的第 2 项,本题则将序号推广为变量 n。

整体思路分为三步:

  1. 去重:对 salary 取 DISTINCT,避免并列工资占据多个名次;
  2. 降序:按 salary DESC 排序,得到从高到低的唯一薪水序列;
  3. 定位:取该序列的第 n - 1 个下标(0 基索引)对应的元素,即为第 n 高的不同工资。

对应到 SQL 中,第 n 项可以由 LIMIT 1 OFFSET N-1 精确命中;在 pandas 中则是对去重后的数组排序后按下标 N - 1 取值。此外,原题解(见 README_EN.md 的 thinking 说明)还特别强调:当 N < 1 或不同工资数量不足 N 时,结果应为 NULL。

MySQL 实现:存储函数 + LIMIT 偏移

LeetCode 对本题的 SQL 作答要求在存储函数 getNthHighestSalary 中完成,仓库中的 Solution.sql 给出了完整实现:

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

这段代码里有几个值得拆解的要点:

1. 参数先减一,把「第 n 高」转为 0 基偏移

LIMIT ... OFFSET 的偏移量是从 0 开始的:OFFSET 0 对应第一行,OFFSET 1 对应第二行。因此「第 2 高」对应偏移量 1,推广到一般情形,「第 N 高」对应偏移量 N - 1。函数开头执行 SET N = N - 1;,正是为了完成这一下标换算。

2. 内层子查询负责排序去重与分页

SELECT DISTINCT salary
FROM Employee
ORDER BY salary DESC
LIMIT 1 OFFSET N
  • DISTINCT salary 先消除重复工资;
  • ORDER BY salary DESC 降序排列;
  • LIMIT 1 OFFSET N 跳过前 N 行、取第 1 行,即第 N + 1 高(原始参数)的工资。

3. 外层包裹保证空结果变成 NULL

这是本题最关键也最容易被忽略的设计:如果不同工资数不足 n 个,内层 SELECT 将返回空结果集(0 行),而不是一行 NULL。在 MySQL 中,将子查询作为标量表达式包在外层 SELECT ( ... ) 中时,空结果会被自动转换为 NULL,从而满足题面「返回 null」的要求。

SELECT (
    SELECT DISTINCT salary
    FROM Employee
    ORDER BY salary DESC
    LIMIT 1 OFFSET N
)

这种「子查询 + 外层包裹」的写法与 0176.Second Highest Salary 中「第二高薪水」的解法一脉相承,都是利用外层查询把空结果规范化为 NULL 单行。

关于 N 小于 1 的情况

若传入 N = 0 或负数,SET N = N - 1 后会得到一个负偏移,此时 LIMIT ... OFFSET 的行为在不同数据库版本中并不一致。题目标准测试用例并未覆盖该场景,但如果希望函数足够健壮,可以在函数体内先做一次 IF N < 1 THEN RETURN NULL; END IF; 的守卫判断(仓库内的标准解未包含该分支,属于可自行加固的扩展点)。

Python3 实现:pandas 版本

仓库中的 Solution.py 提供了等价的 pandas 实现,其防御性写法非常值得借鉴:

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})"])

对照 MySQL 版本,可以梳理出三个对称的步骤:

1. 参数守卫:N < 1 直接返回

SQL 版本通过偏移换算隐式处理,pandas 版本则显式写出:当 N < 1 时,直接返回一列 [None],列名按题目要求格式化为 getNthHighestSalary({N})。

2. 去重与数量不足检查

employee.salary.unique() 对应 SQL 的 DISTINCT salary,得到唯一工资数组。随后 len(unique_salaries) < N 对应「不足 n 个不同工资」的边界:与 SQL 中依赖外层包裹把空集转 NULL 不同,pandas 版本主动用 pd.DataFrame([None], columns=[f"getNthHighestSalary({N})"]) 构造一行 None 的结果。

3. 排序取值并构造结果 DataFrame

salary = sorted(unique_salaries, reverse=True)[N - 1]

reverse=True 对应 ORDER BY salary DESC,下标 N - 1 对应 OFFSET N-1 的 0 基索引,两者在语义上完全一致。最后用 pd.DataFrame([salary], columns=[f"getNthHighestSalary({N})"]) 构造单行单列的返回结构,列名与题目要求的输出列保持一致。

复杂度分析

两种实现的核心开销都在「去重 + 排序」上:

  • MySQL:内层子查询对 salary 去重排序,时间开销主要取决于 Employee 表的规模与 salary 列的索引情况;在无索引时,排序复杂度为 O(m log m),其中 m 为表行数。LIMIT 1 OFFSET N 在命中索引时可通过扫描跳过前 N 行高效完成。
  • pandas:unique() 去重与 sorted() 排序均为 O(m log m);空间上需要额外保存去重后的工资数组。

当 n 很小而表很大时,两者都能借助「先取前 n 大」的思路进一步优化(例如 pandas 使用 nlargest(n),SQL 使用 ORDER BY ... LIMIT n),但题目标准答案采用直观的全量排序写法,重在清晰表达核心语义。

延伸阅读:从「第二高」到「第 N 高」再到「分数排名」

本题与同仓库内的两道数据库题形成自然的进阶链路:

  1. 0176. 第二高的薪水:LIMIT 1 OFFSET 1 固定取第二项,是本题在 n = 2 时的特例;
  2. 0177. 第 N 高的薪水(本文主题):把序号参数化,核心难点是存储函数内 N - 1 的偏移换算与空结果转 NULL;
  3. 0178. 分数排名:当需要为所有行同时计算「第几名」而不是只取单个名次时,可改用窗口函数 DENSE_RANK() 实现连续且不跳号的排名。

三者共同覆盖了「排序取值」「分页偏移」「窗口排名」三类高频 SQL 面试考点。本文全部代码与题目原文可在仓库目录 0177.Nth Highest Salary 下查看,其余数据库类题目的完整列表见 数据库专项练习。

登录后查看全文
leetcode