LeetCode 热题 100-----21.搜索二维矩阵 II

一、题目完整解读

大家先不用怕“二维矩阵”“算法”这些听起来高深的词，我们用最通俗的话把题目讲明白，保证完全没接触过编程的人也能懂。

题目给我们一个“表格”（就是二维矩阵），这个表格有两个固定规律，一定要记牢：

• 规律1：每一行的数字，从左到右是逐渐变大的（比如第一行 [1,4,7,11,15]，1<4<7<11<15）；

• 规律2：每一列的数字，从上到下是逐渐变大的（比如第一列 [1,2,3,10,18]，1<2<3<10<18）。

我们的任务很简单：给一个目标数字（target），写一段代码，判断这个数字是不是在这个“表格”里。如果在，就返回“真”（True/true）；如果不在，就返回“假”（False/false）。

举两个具体例子，帮大家理解：

示例1：表格是 [[1,4,7,11,15],[2,5,8,12,19],[3,6,9,16,22],[10,13,14,17,24],[18,21,23,26,30]]，目标数字是5。我们能在表格第二行第二列找到5，所以返回True。

示例2：还是同一个表格，目标数字是20。整个表格里没有20，所以返回False。

题目额外说明（不用死记，了解即可）：表格的行数（m）和列数（n）都是1到300之间，数字的范围很大（-10⁹到10⁹），但我们不用关心这个，代码会自动处理。

二、前置知识

在看代码之前，必须先掌握3个核心基础知识点，每一个都讲得明明白白，不会跳过任何一个细节，放心看！

知识点1：什么是二维矩阵（表格）？如何访问表格里的数字？

我们生活中常见的Excel表格、课堂上的座位表，都是“二维矩阵”。在编程里，它就是“列表套列表”（Python）或“向量套向量”（C++），可以理解成“一行一行的列表，拼在一起组成一个大列表”。

举个例子（和题目示例一致）：

Python里的二维矩阵：matrix = [[1,4,7,11,15], [2,5,8,12,19], [3,6,9,16,22]]

C++里的二维矩阵：vector<vector<int>> matrix = {{1,4,7,11,15}, {2,5,8,12,19}, {3,6,9,16,22}};

怎么访问表格里的某个数字？—— 用“行号+列号”定位，记为 matrix[行号][列号]（重点！）

注意：编程里的“行号”“列号”都是从0开始算的（不是从1开始！），比如：

• matrix[0][0]：第0行（第一行）、第0列（第一列），数字是1；

• matrix[1][1]：第1行（第二行）、第1列（第二列），数字是5；

• matrix[2][3]：第2行（第三行）、第3列（第四列），数字是16。

补充：如何获取表格的行数和列数？

• Python：行数 = len(matrix)（大列表的长度，就是有多少个小列表）；列数 = len(matrix[0])（第一个小列表的长度，就是一行有多少个数字）；

• C++：行数 = matrix.size()（向量的size()方法，获取大向量里有多少个小向量）；列数 = matrix[0].size()（第一个小向量的size()，获取一行有多少个数字）。

知识点2：循环遍历（如何“挨个查看”表格里的所有数字）

我们要判断目标数字在不在表格里，最直接的方式就是“挨个看”，这就需要用到“循环”—— 重复做一件事（查看数字），直到所有数字都看完。

因为是二维表格（行+列），所以需要“嵌套循环”：先遍历每一行，再遍历当前行的每一个数字（每一列）。

举个通俗例子：像老师查座位表，先查第一行（从左到右查每个学生），再查第二行，直到所有行查完。

两种语言的循环写法（先有个印象，后面代码里会详细讲）：

• Python：用for循环，先遍历每一行（for row in matrix），再遍历当前行的每一个数字（for num in row）；

• C++：用for循环，先定义行号i（从0到行数-1），再定义列号j（从0到列数-1），通过matrix[i][j]访问每个数字。

知识点3：条件判断（如何判断“当前数字是不是目标值”）

遍历到一个数字后，我们需要判断它是不是我们要找的目标值（target），这就需要用到“条件判断”—— if-else语句。

核心逻辑（非常简单）：

• 如果 当前数字 == 目标值 → 找到目标，直接返回“真”（True/true），不用再继续查看；

• 如果 当前数字 != 目标值 → 继续查看下一个数字；

• 如果所有数字都查完了，还是没有找到 → 返回“假”（False/false）。

补充：边界判断（避免出错的关键）

如果表格是空的（比如没有任何行，或者只有一行但没有任何数字），直接返回False，因为里面不可能有目标值—— 这一步很重要，能避免代码报错。

知识点4：补充（Python/C++ 基础语法，必备）

为了让大家看懂代码，再补充几个基础语法，不用死记，跟着代码对照看即可：

• Python：

  • from typing import List：导入列表类型，刷题时必须写，用来声明函数参数的类型（告诉代码，matrix是“列表套列表”，target是整数）；

  • class Solution: 定义一个“解决方案类”，刷题时固定写法，所有解题函数都放在这个类里面；

  • def searchMatrix(self, matrix: List[List[int]], target: int) -> bool: 定义解题函数，self是类的固定参数，后面两个是输入（matrix和target），-> bool表示函数返回值是“真/假”。

• C++：

  • #include <vector>：导入向量（vector）库，因为二维矩阵用vector实现，必须写；

  • using namespace std;：简化代码写法，不用每次都写“std::vector”，直接写“vector”即可；

  • class Solution: 定义解决方案类，固定写法；

  • bool searchMatrix(vector<vector<int>>& matrix, int target)：定义解题函数，返回值是bool（真/假），参数matrix是“vector套vector”，&表示“引用传递”（不用复制整个矩阵，更高效），target是目标值。

三、解法一：暴力遍历法

1. 核心思路（能直接理解）

完全不利用题目中“每行、每列升序”的规律，就是“挨个查看”表格里的每一个数字，直到找到目标值，或者查完所有数字。

步骤拆解：

优点：代码最简单，不用思考任何规律，零基础能快速写出来；

缺点：效率低，最坏情况下要查完所有数字（比如目标值在最后一个位置，或者不在表格里），时间复杂度是O(m×n)（m是行数，n是列数）。

2. Python 暴力解法（逐句注释，每句都讲清含义）

# 导入列表类型声明（刷题必备，告诉代码“List”是什么，避免报错）
from typing import List

# 定义解决方案类（刷题固定写法，所有解题函数都放在这个类里）
class Solution:
# 定义解题函数：searchMatrix是函数名，self是类的固定参数
# matrix: List[List[int]] → 声明输入的matrix是“列表套列表”（二维矩阵），里面的元素是整数
# target: int → 声明输入的target是整数
# -> bool → 声明函数的返回值是“真/假”（True/False）
def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:
# 边界判断1：如果矩阵是空的（没有任何行），直接返回False（里面不可能有目标值）
if not matrix:
return False
# 边界判断2：如果矩阵有行，但第一行是空的（没有任何列），也返回False
if not matrix[0]:
return False

# 遍历矩阵的每一行：row代表当前行（比如第一次循环，row是[1,4,7,11,15]）
for row in matrix:
# 遍历当前行的每一个数字：num代表当前行的某个数字（比如第一次循环，num是1，然后是4、7…）
for num in row:
# 条件判断：如果当前数字等于目标值，说明找到了，直接返回True
if num == target:
return True
# 循环结束：所有行、所有数字都遍历完了，还是没找到目标值，返回False
return False

# 主函数（测试用，可以直接运行，查看结果）
# 主函数的作用：定义测试数据，调用上面的解题函数，输出结果
if __name__ == "__main__":
# 实例化Solution类（创建一个“解题工具”，才能调用里面的searchMatrix函数）
sol = Solution()

# 测试用例1（题目给定的示例1）
matrix1 = [
[1,4,7,11,15],
[2,5,8,12,19],
[3,6,9,16,22],
[10,13,14,17,24],
[18,21,23,26,30]
]
target1 = 5
# 调用解题函数，传入测试数据，获取结果
result1 = sol.searchMatrix(matrix1, target1)
# 输出结果：打印“测试用例1”和对应的结果，让我们能看到是否正确
print(f"测试用例1：matrix={matrix1}, target={target1}")
print(f"测试结果1：{result1}（正确结果应为True）\\n")

# 测试用例2（题目给定的示例2）
matrix2 = [
[1,4,7,11,15],
[2,5,8,12,19],
[3,6,9,16,22],
[10,13,14,17,24],
[18,21,23,26,30]
]
target2 = 20
result2 = sol.searchMatrix(matrix2, target2)
print(f"测试用例2：matrix={matrix2}, target={target2}")
print(f"测试结果2：{result2}（正确结果应为False）\\n")

# 自定义测试用例3（空矩阵，测试边界）
matrix3 = [] # 没有任何行的空矩阵
target3 = 10
result3 = sol.searchMatrix(matrix3, target3)
print(f"自定义测试用例3：matrix={matrix3}, target={target3}")
print(f"测试结果3：{result3}（正确结果应为False）\\n")

# 自定义测试用例4（只有一行一列的矩阵）
matrix4 = [[7]] # 只有一行、一列，数字是7
target4 = 7
result4 = sol.searchMatrix(matrix4, target4)
print(f"自定义测试用例4：matrix={matrix4}, target={target4}")
print(f"测试结果4：{result4}（正确结果应为True）\\n")

# 自定义测试用例5（目标值比所有数字都小）
matrix5 = [[2,4,6],[3,5,7]]
target5 = 1
result5 = sol.searchMatrix(matrix5, target5)
print(f"自定义测试用例5：matrix={matrix5}, target={target5}")
print(f"测试结果5：{result5}（正确结果应为False）\\n")

# 自定义测试用例6（目标值比所有数字都大）
matrix6 = [[2,4,6],[3,5,7]]
target6 = 8
result6 = sol.searchMatrix(matrix6, target6)
print(f"自定义测试用例6：matrix={matrix6}, target={target6}")
print(f"测试结果6：{result6}（正确结果应为False）")

3. Python 代码调用流程 & 运行过程（逐步看懂）

（1）调用流程（怎么用这个代码）

（2）运行过程（以测试用例1为例，逐步看代码怎么执行）

测试用例1：matrix1是5行5列的矩阵，target1=5

补充：如果测试用例2（target=20），代码会遍历完所有5行5列的数字（共25个），都没找到20，最后返回False。

4. C++ 暴力解法（逐句注释，每句都讲清含义）

#include <vector> // 导入向量库，因为二维矩阵用vector（向量）实现，必须写
using namespace std; // 简化语法，不用每次写“std::vector”，直接写“vector”

// 定义解决方案类（刷题固定写法）
class Solution {
public:
// 定义解题函数：返回值是bool（真/假）
// vector<vector<int>>& matrix → 输入的二维矩阵，&表示“引用传递”（高效，不复制整个矩阵）
// int target → 输入的目标值（整数）
bool searchMatrix(vector<vector<int>>& matrix, int target) {
// 边界判断1：如果矩阵是空的（没有任何行），返回False
if (matrix.empty()) {
return false;
}
// 边界判断2：如果矩阵有行，但第一行是空的（没有任何列），返回False
if (matrix[0].empty()) {
return false;
}

// 获取矩阵的行数m：matrix.size() → 大向量的长度（有多少个小向量，就是多少行）
int m = matrix.size();
// 获取矩阵的列数n：matrix[0].size() → 第一个小向量的长度（一行有多少个数字，就是多少列）
int n = matrix[0].size();

// 外层for循环：遍历每一行，i是行号（从0到m-1，因为行号从0开始）
for (int i = 0; i < m; i++) {
// 内层for循环：遍历当前行的每一列，j是列号（从0到n-1）
for (int j = 0; j < n; j++) {
// 访问当前行、当前列的数字：matrix[i][j]
// 条件判断：如果当前数字等于目标值，返回true
if (matrix[i][j] == target) {
return true;
}
}
}
// 所有数字都遍历完，没找到目标值，返回false
return false;
}
};

// 主函数（测试用，可以直接复制运行，查看结果）
// 主函数是程序的入口，代码从这里开始执行
int main() {
// 实例化Solution类，创建解题对象sol（相当于“打开解题工具”）
Solution sol;

// 测试用例1（题目给定的示例1）
vector<vector<int>> matrix1 = {
{1,4,7,11,15},
{2,5,8,12,19},
{3,6,9,16,22},
{10,13,14,17,24},
{18,21,23,26,30}
};
int target1 = 5;
// 调用解题函数，传入测试数据，获取结果（result1是bool类型，true/false）
bool result1 = sol.searchMatrix(matrix1, target1);
// 输出结果：cout是C++的打印语句，endl是换行
cout << "测试用例1：" << endl;
cout << "matrix：" << endl;
// 打印矩阵（方便查看测试数据）
for (auto row : matrix1) {
for (auto num : row) {
cout << num << " ";
}
cout << endl;
}
cout << "target：" << target1 << endl;
cout << "测试结果1：" << (result1 ? "true" : "false") << "（正确结果应为true）" << endl << endl;

// 测试用例2（题目给定的示例2）
vector<vector<int>> matrix2 = {
{1,4,7,11,15},
{2,5,8,12,19},
{3,6,9,16,22},
{10,13,14,17,24},
{18,21,23,26,30}
};
int target2 = 20;
bool result2 = sol.searchMatrix(matrix2, target2);
cout << "测试用例2：" << endl;
cout << "matrix：" << endl;
for (auto row : matrix2) {
for (auto num : row) {
cout << num << " ";
}
cout << endl;
}
cout << "target：" << target2 << endl;
cout << "测试结果2：" << (result2 ? "true" : "false") << "（正确结果应为false）" << endl << endl;

// 自定义测试用例3（空矩阵）
vector<vector<int>> matrix3; // 空矩阵（没有任何行）
int target3 = 10;
bool result3 = sol.searchMatrix(matrix3, target3);
cout << "自定义测试用例3：" << endl;
cout << "matrix：空矩阵" << endl;
cout << "target：" << target3 << endl;
cout << "测试结果3：" << (result3 ? "true" : "false") << "（正确结果应为false）" << endl << endl;

// 自定义测试用例4（只有一行一列的矩阵）
vector<vector<int>> matrix4 = {{7}};
int target4 = 7;
bool result4 = sol.searchMatrix(matrix4, target4);
cout << "自定义测试用例4：" << endl;
cout << "matrix：" << endl;
for (auto row : matrix4) {
for (auto num : row) {
cout << num << " ";
}
cout << endl;
}
cout << "target：" << target4 << endl;
cout << "测试结果4：" << (result4 ? "true" : "false") << "（正确结果应为true）" << endl << endl;

// 自定义测试用例5（目标值比所有数字都小）
vector<vector<int>> matrix5 = {{2,4,6},{3,5,7}};
int target5 = 1;
bool result5 = sol.searchMatrix(matrix5, target5);
cout << "自定义测试用例5：" << endl;
cout << "matrix：" << endl;
for (auto row : matrix5) {
for (auto num : row) {
cout << num << " ";
}
cout << endl;
}
cout << "target：" << target5 << endl;
cout << "测试结果5：" << (result5 ? "true" : "false") << "（正确结果应为false）" << endl << endl;

// 自定义测试用例6（目标值比所有数字都大）
vector<vector<int>> matrix6 = {{2,4,6},{3,5,7}};
int target6 = 8;
bool result6 = sol.searchMatrix(matrix6, target6);
cout << "自定义测试用例6：" << endl;
cout << "matrix：" << endl;
for (auto row : matrix6) {
for (auto num : row) {
cout << num << " ";
}
cout << endl;
}
cout << "target：" << target6 << endl;
cout << "测试结果6：" << (result6 ? "true" : "false") << "（正确结果应为false）" << endl;

return 0; // 主函数结束，返回0表示程序正常运行
}

5. C++ 代码调用流程 & 运行过程（逐步看懂）

（1）调用流程（怎么用这个代码）

（2）运行过程（以测试用例1为例，逐步看代码怎么执行）

测试用例1：matrix1是5行5列的矩阵，target1=5

四、解法二：高效查找法

1. 核心思路（利用矩阵规律，大幅提速）

这是这道题的最优解法，核心是“利用题目中‘每行升序、每列升序’的规律，每次排除一行或一列，不用遍历所有数字”，效率大幅提升。

关键技巧：选择「矩阵右上角的数字」作为查找的起点（为什么选这里？因为这个数字有个天然优势）：

👉 右上角的数字 = 当前行的最大值（因为行是升序，最右边最大） + 当前列的最小值（因为列是升序，最上边最小）

基于这个优势，我们可以每次排除一行或一列，快速缩小查找范围，步骤拆解（必看，结合例子理解）：

举个通俗例子（测试用例1，target=5）：

矩阵右上角是matrix[0][4] =15 → 15>5 → 列号减1（col=3），排除第4列；

当前数字是matrix[0][3]=11 →11>5 → 列号减1（col=2），排除第3列；

当前数字是matrix[0][2]=7 →7>5 → 列号减1（col=1），排除第2列；

当前数字是matrix[0][1]=4 →4<5 → 行号加1（row=1），排除第0行；

当前数字是matrix[1][1]=5 →5==5 → 返回True。

优点：效率极高，时间复杂度是O(m+n)（最多走m+n步，比如从右上角走到左下角），是面试时的首选解法；

缺点：需要理解“右上角起点”的逻辑，比暴力解法稍难一点，但只要记住“大左移、小下移”，就能轻松写出来。

2. Python 最优解法（逐句注释，每句都讲清含义）

# 导入列表类型声明（刷题必备）
from typing import List

# 定义解决方案类（固定写法）
class Solution:
def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:
# 边界判断1：如果矩阵是空的（没有任何行），返回False
if not matrix:
return False
# 边界判断2：如果矩阵有行，但第一行是空的（没有任何列），返回False
if not matrix[0]:
return False

# 初始化起点：右上角（第0行，最后一列）
row = 0 # 行号，从第一行（0行）开始
col = len(matrix[0]) – 1 # 列号，从最后一列开始（len(matrix[0])是列数，减1是因为列号从0开始）
rows = len(matrix) # 总行数，用来判断行号是否越界

# 循环条件：行号row < 总行数（没越界），列号col >=0（没越界）
while row < rows and col >= 0:
# 获取当前起点的数字（右上角开始，每次更新）
current = matrix[row][col]

# 情况1：当前数字等于目标值，找到目标，返回True
if current == target:
return True
# 情况2：当前数字大于目标值 → 目标值在左边，列号减1（向左移一列）
elif current > target:
col -= 1
# 情况3：当前数字小于目标值 → 目标值在下边，行号加1（向下移一行）
else:
row += 1

# 循环结束：行或列越界，没找到目标值，返回False
return False

# 主函数（测试用，和暴力解法的主函数结构一致，测试所有案例）
if __name__ == "__main__":
sol = Solution()

# 测试用例1（题目示例1）
matrix1 = [
[1,4,7,11,15],
[2,5,8,12,19],
[3,6,9,16,22],
[10,13,14,17,24],
[18,21,23,26,30]
]
target1 = 5
result1 = sol.searchMatrix(matrix1, target1)
print(f"测试用例1：matrix={matrix1}, target={target1}")
print(f"测试结果1：{result1}（正确结果应为True）\\n")

# 测试用例2（题目示例2）
matrix2 = [
[1,4,7,11,15],
[2,5,8,12,19],
[3,6,9,16,22],
[10,13,14,17,24],
[18,21,23,26,30]
]
target2 = 20
result2 = sol.searchMatrix(matrix2, target2)
print(f"测试用例2：matrix={matrix2}, target={target2}")
print(f"测试结果2：{result2}（正确结果应为False）\\n")

# 自定义测试用例3（空矩阵）
matrix3 = []
target3 = 10
result3 = sol.searchMatrix(matrix3, target3)
print(f"自定义测试用例3：matrix={matrix3}, target={target3}")
print(f"测试结果3：{result3}（正确结果应为False）\\n")

# 自定义测试用例4（只有一行一列）
matrix4 = [[7]]
target4 = 7
result4 = sol.searchMatrix(matrix4, target4)
print(f"自定义测试用例4：matrix={matrix4}, target={target4}")
print(f"测试结果4：{result4}（正确结果应为True）\\n")

# 自定义测试用例5（目标值在左上角）
matrix5 = [[1,2,3],[4,5,6],[7,8,9]]
target5 = 1
result5 = sol.searchMatrix(matrix5, target5)
print(f"自定义测试用例5：matrix={matrix5}, target={target5}")
print(f"测试结果5：{result5}（正确结果应为True）\\n")

# 自定义测试用例6（目标值在右下角）
matrix6 = [[1,2,3],[4,5,6],[7,8,9]]
target6 = 9
result6 = sol.searchMatrix(matrix6, target6)
print(f"自定义测试用例6：matrix={matrix6}, target={target6}")
print(f"测试结果6：{result6}（正确结果应为True）")

3. Python 最优解法 调用流程 & 运行过程（逐步看懂）

（1）调用流程

和暴力解法的调用流程完全一致：导入List → 定义Solution类 → 主函数创建实例 → 定义测试用例 → 调用函数 → 打印结果。

（2）运行过程（以测试用例1为例，逐步拆解）

测试用例1：matrix1=5行5列，target1=5

补充（测试用例2，target=20）：

从右上角15开始，逐步左移、下移，最后row=5（超过总行数4），循环结束，返回False，全程只走了8步（比暴力解法的25步少很多）。

4. C++ 最优解法（逐句注释，每句都讲清含义）

#include <vector>
using namespace std;

class Solution {
public:
bool searchMatrix(vector<vector<int>>& matrix, int target) {
// 边界判断1：矩阵为空（没有任何行），返回false
if (matrix.empty()) {
return false;
}
// 边界判断2：第一行为空（没有任何列），返回false
if (matrix[0].empty()) {
return false;
}

// 初始化起点：右上角（第0行，最后一列）
int row = 0; // 行号，从第0行开始
int col = matrix[0].size() – 1; // 列号，从最后一列开始（size()-1是因为列号从0开始）
int rows = matrix.size(); // 总行数，用于判断行号是否越界

// 循环条件：行号不越界（row < rows），列号不越界（col >= 0）
while (row < rows && col >= 0) {
// 获取当前起点的数字
int current = matrix[row][col];

// 情况1：找到目标值，返回true
if (current == target) {
return true;
}
// 情况2：当前数字大于目标值 → 向左移一列（col减1），排除当前列
else if (current > target) {
col–;
}
// 情况3：当前数字小于目标值 → 向下移一行（row加1），排除当前行
else {
row++;
}
}

// 循环结束，没找到目标值，返回false
return false;
}
};

// 主函数（测试用，和暴力解法主函数结构一致，可直接复制运行）
int main() {
// 实例化Solution类，创建解题对象sol（打开解题工具）
Solution sol;

// 测试用例1（题目给定的示例1）
vector<vector<int>> matrix1 = {
{1,4,7,11,15},
{2,5,8,12,19},
{3,6,9,16,22},
{10,13,14,17,24},
{18,21,23,26,30}
};
int target1 = 5;
// 调用最优解法的解题函数，传入测试数据，获取结果
bool result1 = sol.searchMatrix(matrix1, target1);
// 打印测试数据和结果，方便查看
cout << "测试用例1：" << endl;
cout << "matrix：" << endl;
for (auto row : matrix1) {
for (auto num : row) {
cout << num << " ";
}
cout << endl;
}
cout << "target：" << target1 << endl;
cout << "测试结果1：" << (result1 ? "true" : "false") << "（正确结果应为true）" << endl << endl;

// 测试用例2（题目给定的示例2）
vector<vector<int>> matrix2 = {
{1,4,7,11,15},
{2,5,8,12,19},
{3,6,9,16,22},
{10,13,14,17,24},
{18,21,23,26,30}
};
int target2 = 20;
bool result2 = sol.searchMatrix(matrix2, target2);
cout << "测试用例2：" << endl;
cout << "matrix：" << endl;
for (auto row : matrix2) {
for (auto num : row) {
cout << num << " ";
}
cout << endl;
}
cout << "target：" << target2 << endl;
cout << "测试结果2：" << (result2 ? "true" : "false") << "（正确结果应为false）" << endl << endl;

// 自定义测试用例3（空矩阵，测试边界）
vector<vector<int>> matrix3;
int target3 = 10;
bool result3 = sol.searchMatrix(matrix3, target3);
cout << "自定义测试用例3：" << endl;
cout << "matrix：空矩阵" << endl;
cout << "target：" << target3 << endl;
cout << "测试结果3：" << (result3 ? "true" : "false") << "（正确结果应为false）" << endl << endl;

// 自定义测试用例4（只有一行一列的矩阵）
vector<vector<int>> matrix4 = {{7}};
int target4 = 7;
bool result4 = sol.searchMatrix(matrix4, target4);
cout << "自定义测试用例4：" << endl;
cout << "matrix：" << endl;
for (auto row : matrix4) {
for (auto num : row) {
cout << num << " ";
}
cout << endl;
}
cout << "target：" << target4 << endl;
cout << "测试结果4：" << (result4 ? "true" : "false") << "（正确结果应为true）" << endl << endl;

// 自定义测试用例5（目标值在左上角）
vector<vector<int>> matrix5 = {{1,2,3},{4,5,6},{7,8,9}};
int target5 = 1;
bool result5 = sol.searchMatrix(matrix5, target5);
cout << "自定义测试用例5：" << endl;
cout << "matrix：" << endl;
for (auto row : matrix5) {
for (auto num : row) {
cout << num << " ";
}
cout << endl;
}
cout << "target：" << target5 << endl;
cout << "测试结果5：" << (result5 ? "true" : "false") << "（正确结果应为true）" << endl << endl;

// 自定义测试用例6（目标值在右下角）
vector<vector<int>> matrix6 = {{1,2,3},{4,5,6},{7,8,9}};
int target6 = 9;
bool result6 = sol.searchMatrix(matrix6, target6);
cout << "自定义测试用例6：" << endl;
cout << "matrix：" << endl;
for (auto row : matrix6) {
for (auto num : row) {
cout << num << " ";
}
cout << endl;
}
cout << "target：" << target6 << endl;
cout << "测试结果6：" << (result6 ? "true" : "false") << "（正确结果应为true）" << endl;

return 0; // 主函数结束，返回0表示程序正常运行
}

5. C++ 最优解法 调用流程 & 运行过程（逐步看懂）

（1）调用流程

和C++暴力解法的调用流程完全一致，步骤如下，对照代码看就能懂：

（2）运行过程（以测试用例1为例，逐步拆解，能跟着走）

测试用例1：matrix1是5行5列矩阵，target1=5，核心是“大左移、小下移”，逐步缩小范围

补充（测试用例2，target=20）：

运行过程拆解（帮理解“排除行/列”的优势）：

五、两种解法对比（必看，清晰区分）

为了让快速分清两种解法的区别，整理了清晰的对比，不用死记，理解即可：

对比维度

解法一：暴力遍历法

解法二：高效查找法（最优解）

六、常见问题解答

整理了学习过程中最容易问的4个问题，每个问题都用通俗的话解答，避免踩坑：

疑问1：为什么行号、列号要从0开始，而不是从1开始？

这是编程的通用约定，不是这道题特有的！就像我们排队，从第0个位置开始数，和生活中“第1个”对应。比如matrix[0][0]，生活中是“第一行第一列”，编程里写“0行0列”，记住这个对应关系就不会错。

疑问2：高效解法为什么选右上角当起点？选左上角、右下角不行吗？

核心原因：只有右上角（或左下角）的数字，能同时实现“排除一行或一列”，其他位置不行，举个例子说明：

• 选左上角：数字是当前行最小、当前列最小，比如matrix[0][0]=1，比目标值5小，只能向下移，但无法排除一行/一列，还是要遍历很多数字；

• 选右下角：数字是当前行最大、当前列最大，比如matrix[4][4]=30，比目标值5大，只能向左移，也无法排除一行/一列；

• 选右上角：数字是当前行最大、当前列最小，能直接判断“大了左移、小了下移”，每次必排除一行或一列，效率最高。

疑问3：代码里的“边界判断”为什么必须写？不写会怎么样？

必须写！不写会导致代码报错，比如：

• 如果矩阵是空的（matrix=[]），执行len(matrix[0])（Python）或matrix[0].size()（C++）时，会报错“访问了不存在的元素”；

• 边界判断能提前“拦截”空矩阵的情况，直接返回false，避免代码崩溃，这是写算法题的好习惯，一定要记住。

疑问4：Python和C++的代码逻辑一样，为什么语法不一样？

因为Python和C++是两种不同的编程语言，就像“中文和英文”，表达同一个意思（解题逻辑），但用词、句式不一样。比如：

• Python用len(matrix)获取行数，C++用matrix.size()；

• Python用for row in matrix遍历行，C++用for循环+行号i遍历；

• 但核心逻辑（边界判断、遍历/排除思路、条件判断）完全一致，学会一种，另一种只要记语法差异就能快速掌握。

七、总结（必看，快速梳理重点）

这道题的核心是“利用矩阵的升序规律，优化查找效率”，不用害怕，按以下步骤学习，就能完全掌握：