算法学习day2：数组高频技巧与避坑总结

算法学习day2，我把数组相关的题目从头到尾过了一遍。说实话，数组看起来是数据结构里最基础的一层，但真做起题来你会发现，它反而是变化最多的一个东西。双指针、滑动窗口、二分查找、前缀和、去重、多维数组传参，随便拎一个出来都能写好几道题。我自己的感受是，只要把数组这关啃扎实，后面学链表、哈希表、树都会顺很多，因为很多代码套路是共通的。

这篇day2笔记，我不打算只把自己做过的题罗列一遍，而是从“数组这个结构到底是怎么运作的”开始，再一点点展开遍历、去重、排序、二维数组这些高频场景。全程用最直白的话讲原理，配合可复现的代码片段和踩坑记录，给同样在啃算法的朋友做一个参考。不管你是刚开始刷题，还是学到一半觉得数组概念很散，这篇都很适合当一份阶段性的复习提纲。

1. 先把数组当成一块连续内存来理解

很多初学者一开始就急着刷题，数组的基本性质反而被跳过了。但数组题的所有技巧，几乎都是从它的底层存储方式长出来的。你只要把“连续内存”这四个字记住了，后面一大半的坑都能提前避开。

1.1 数组的底层布局与随机访问

数组在内存里是一段连续的空间，每个元素占用的字节数相同。你声明一个int数组，比如int arr[5]，编译之后它占用的就是5个连续int空间。这段内存的首地址就是数组名，也就是arr指向的位置，后面每个元素通过偏移量来定位。

比如arr[i]，本质上是访问arr + i * sizeof(int)这个地址上的数据。这是计算机组成原理里最基础的那个“地址 = 基地址 + 下标 × 元素大小”公式。所以数组的随机访问为什么是O(1)？因为算地址只是一个加法和乘法操作，不依赖数组长度。你访问arr[0]和访问arr[9999]的耗时几乎完全一样，这在链表里是做不到的。

理解了这一点，你就明白为什么数组特别适合做需要频繁按索引取值的事情：二分查找、堆排序、树状数组底层的存储，全部依赖这种随机访问能力。你不理解数组的连续存储，就很难理解为什么树状数组能通过下标二进制来跳转，也难理解为什么很多算法书说“数组缓存友好”。

1.2 连续存储带来的三个限制

连续有连续的好处，代价也同样写在脸上。

第一，数组长度是固定的。你在C/C++里声明一个数组，默认大小就定死了。虽然C99支持变长数组（VLA），C++也有std::array，但总体思路是编译期或运行时一次性分配好一块连续空间，后面没法像链表那样随意插一个节点进去。Java、Python里的“动态数组”其实也是内部维护了一块固定大小的底层数组，容量不够时再重新开一块更大的内存，把数据整体拷贝过去。所以原地“无限增长”是不存在的，只是语言层面封装的假象。

第二，插入和删除非常昂贵。你往数组中间插一个元素，为了让后面的元素保持连续，必须把它们一个一个往后挪。删除掉中间某个元素，也要把后续元素往前搬。最坏情况下时间复杂度是O(n)。所以一旦确认某个场景需要频繁插入删除，就应该考虑链表，而不是死磕数组。

第三，越界访问很危险。因为数组没有天然的“边界哨兵”，C/C++这类语言不会在运行时帮你检查下标是否合法。你一旦写出arr[n]，它确实会去内存里找那个位置的数，只不过找到的是你数组后面的其他数据。这就是未定义行为。我见过不少初学者写循环判断条件时把< n写成<= n，然后数据莫名其妙错乱，其实就是越界读到了相邻内存。

平时练题时，我会下意识地先问自己一句：这个操作会不会改变数组的长度？如果会，那就要想清楚是原地操作还是重新分配，后续遍历的下标该怎么控制。这个习惯能减少大约一半的数组bug。

2. 遍历数组的高频姿势：双指针与滑动窗口

数组题里出镜率最高的不是稀奇古怪的树结构，而是双指针。你要说为什么双指针这么火，我觉得是因为它把“双重循环暴力解”降维成“单循环”的思路，在数组这种顺序结构上特别自然。这里我把双指针拆成三个常用套路来讲，每个都配合实际场景。

2.1 快慢指针：一次循环内完成删除和去重

先看一个经典问题：给定一个有序数组，原地删除重复元素，让每个元素只出现一次，返回删除后数组的新长度。要求不使用额外数组空间。

我第一次看到这题时，第一反应是发现重复了就把后面的元素整体往前搬，这么做的问题是外层循环每次遇到重复都要做一次O(n)的搬移，最后整体复杂度O(n²)。后来发现快慢指针能很优雅地解决。

快慢指针的核心思想是：慢指针指向“下一个要覆盖的位置”，快指针负责向前探索新元素。因为数组是有序的，重复元素一定相邻，快指针一路走，只要发现当前元素和慢指针指向的元素不一样，就把当前值写到慢指针的下一个位置。

python复制def remove_duplicates(nums):
    if not nums:
        return 0

    slow = 0
    for fast in range(1, len(nums)):
        if nums[fast] != nums[slow]:
            slow += 1
            nums[slow] = nums[fast]

    return slow + 1

这个过程本质上是用覆盖代替删除，用一个变量记录有效长度。为什么快？因为整个数组只遍历了一次，快指针停下来的时候数组的“逻辑长度”已经有了，多余的元素根本不用物理删除。你甚至不用管slow后面的数组里还剩什么，那都是历史遗留的脏数据，不影响最终结果。

2.2 左右指针：有序数组的夹逼思路

左右指针用在有序数组非常顺手，最典型的场景就是“两数之和 II”和“合并两个有序数组”。

两数之和要求在一个升序数组里找两个数，使它们的和等于目标值。暴力做法就是两层循环，O(n²)的复杂度。左右指针的做法是：左指针指向开头，右指针指向结尾，相加后和目标值比较。如果和太大了，说明需要把大的数变小一点，右指针往左移；如果和太小了，说明需要把小的数变大一点，左指针往右移。

python复制def two_sum_sorted(nums, target):
    left, right = 0, len(nums) - 1

    while left < right:
        current_sum = nums[left] + nums[right]

        if current_sum == target:
            return [left + 1, right + 1]
        elif current_sum < target:
            left += 1
        else:
            right -= 1

    return []

为什么这个看似简单的思路是O(n)而不是O(n²)？因为每一步都排除了一个元素：要么左边界往右移动了，说明当前左边这个数和任何右边的数组合都不可能满足条件；要么右边界往左移动了，说明当前右边这个数和任何左边的数组合也不可能满足。夹逼的过程把搜索空间压缩成了一条线，而不是一个二维平面。

同样的思路还能用在“反转数组”“判断字符串是否回文”上。说到底，左右指针就是利用有序性来排除无效搜索空间，你理解了“排除”二字，再遇到类似题就会主动去想：能不能左右夹逼，能不能利用顺序剪枝。

2.3 滑动窗口：连续子数组问题的通用解法

滑动窗口处理的是“连续子数组”中找最长/最短/满足条件的问题。它本质上也是双指针，只是两个指针之间的距离动态变化，看起来像是一个窗口在数组上滑动。

典型题目是“和无重复字符的最长子串”和“长度最小的子数组”。在这里我只讲一个最简单的模型：寻找最短连续子数组，使子数组和大于等于某个值S。

窗口的左边是left，右边是right。right不断向右扩展，把新元素加入窗口的和中。一旦当前窗口内部的元素和已经大于等于S，就记录窗口长度，然后尝试把left向右缩，缩小窗口看看还能不能保持满足条件。每次缩完后窗口的起点就更新了。

python复制def min_sub_array_len(target, nums):
    left = 0
    current_sum = 0
    min_length = float("inf")

    for right in range(len(nums)):
        current_sum += nums[right]

        while current_sum >= target:
            min_length = min(min_length, right - left + 1)
            current_sum -= nums[left]
            left += 1

    return min_length if min_length != float("inf") else 0

滑动窗口的复杂度是O(n)，因为left和right各自最多移动n次。这个问题的难点不在于双指针本身，而在于你什么时候该扩大窗口、什么时候该收缩窗口，以及窗口里除了“和”还要维护哪些额外状态。

我在学滑动窗口时踩过一个坑：以为窗口就是随便两个下标，结果遇到负数时整个逻辑就崩了。因为滑动窗口的思路成立有一个前提条件，也就是窗口向右扩张时，窗口内数值单调不减（或满足某种单调性），这样你才敢在“不满足条件时收缩”。如果数组里有负数，这个单调性被打破，固定套路就得重新设计。所以看到滑动窗口题，第一件事是确认数据是否满足单调性，而不是直接套模板。

3. 从热搜词看数组操作的真实高频需求

我翻了翻目前资料里关于数组的热搜词，排在前面的是“数组去重”“数组方法”“数组转字符串”“对象数组去重”“取数组最大值”。这些东西看起来更像是日常业务开发会遇到的问题，而不是纯算法竞赛题。也就是说，数组不只是用来刷题的，在真实项目里它同样是出镜率最高的数据结构。这里挑几个典型的场景来讲。

3.1 数组去重：几条不同思路的取舍

数组去重几乎每个开发者都写过。但不同语言、不同数据规模下，最优解是完全不同的。

如果你用的是JavaScript，面对的是普通数字数组，最简单的写法是用Set：

javascript复制const arr = [1, 2, 2, 3, 4, 4, 5]
const result = [...new Set(arr)]

时间复杂度O(n)，代码也就一行，工程上完全够用。但如果你的数组是一个对象数组，要根据某个字段去重，Set就不能直接比对象本身了，因为对象的引用不同，就算字段相同也会被当成两个元素。

这时候常见做法是用一个Map或者对象来记录已经出现过的字段：

javascript复制const users = [
  { id: 1, name: "张三" },
  { id: 2, name: "李四" },
  { id: 1, name: "张三" }
]

const seen = new Map()
const result = users.filter(user => {
  if (seen.has(user.id)) {
    return false
  }
  seen.set(user.id, true)
  return true
})

如果数组本身是有序的，也可以走快慢指针原地去重，省掉额外空间。这里没有“万能的方法”，关键看你是不是在意空间复杂度、原数组是否有序、数组元素是否可哈希。去重这个动作的本质是让“重复概念的判断”变得可计算，而判断标准不同，代码长相就完全不同。

3.2 排序算法在数组里怎么练

热搜词里还有“冒泡排序算法c++”“堆排序算法”，说明很多人现在开始用数组练手写排序了。这其实是很好的切入点，因为数组是排序算法最自然的载体，学排序本质就是在学怎么操作数组下标。

冒泡排序用来理解“交换”这个概念很直观，但它的复杂度是O(n²)，实际工程里不会大规模使用。堆排序则依赖数组下标之间的父子关系：对于下标i的元素，它的左孩子是2*i+1，右孩子是2*i+2，父节点是(i-1)/2。你看，这又是和数组的连续存储强相关。学堆排序时如果你不把“连续内存、下标计算”想通，很难理解为什么堆的调整是一棵“虚拟树”上的操作。

这里给个建议：不要只去背排序代码，要能解释为什么冒泡排序能通过相邻比较把最大值“冒”到最后，为什么堆排序的建堆过程是O(n)而不是O(n log n)。一旦你能把这些“为什么”讲清楚，说明你对数组操作是真的理解了，而不是单纯手熟。

3.3 数组转字符串、取最大值这类“工程小事”

很多刷题攻略对这类问题不屑一顾，但在真实开发里，数组转字符串的用法频率极高。JavaScript里[1, 2, 3].join("-")能得到"1-2-3"，Python里",".join(map(str, nums))也能把数字列表拼成字符串。你要是不熟悉这些内置方法，每次都得手写循环，既不优雅也容易出边界问题。

取最大值同理，C++可以用std::max_element，Java可以用Arrays.stream(arr).max()，JavaScript有Math.max(...arr)。但要注意一点：在数组特别大时，把Math.max(...arr)直接展开可能超出调用栈参数上限，更稳妥的写法是arr.reduce((a, b) => Math.max(a, b), -Infinity)。这些细节只会在真实项目中暴露出来，刷题时不容易察觉。

我自己在实际开发里倾向先想清楚这个操作是“生成新数组”还是“改原数组”，再去选方法。因为像JavaScript的sort和reverse是原地修改的，map和filter会返回新数组。用混了会带来非常隐蔽的状态污染问题。

4. 二维数组与指针：逃不掉的进阶话题

数组学到后面，一定会遇到二维数组。热词里提到“二维数组”“c语言 二维数组”“多维数组 c++ 指针”“二维字符数组”，这说明连很多学了一段时间的人，在二维数组和指针这里都会被卡住。所以我专门用一章来讲透这个问题。

4.1 二维数组的行主序存储

二维数组在逻辑上像一个表格，有行有列，但在内存里依然是一段连续的一维空间。C/C++和大多数语言里数组按行主序存储，也就是先把第一行的数据连续排好，再接第二行。假设有一个int a[3][4]，内存布局上就是12个int连续排在一起，a[0][0]地址最低，a[0][3]后面紧跟着a[1][0]。

理解行主序对缓存优化特别重要。你遍历二维数组时，如果外层循环是行，内层循环是列，访问顺序和内存布局一致，CPU缓存命中率高；如果你把顺序颠倒成“先列后行”，每次访问都要跳到很远的地址，缓存命中率大幅下降。数据量小的时候差异不明显，一旦矩阵达到几千乘几千，两种写法的耗时差距可能是数倍。

所以二维数组的初始化也要从这个角度去理解：

cpp复制int matrix[3][4] = {
    {1, 2, 3, 4},
    {5, 6, 7, 8},
    {9, 10, 11, 12}
};

花括号里的每一行其实就是在描述一块连续内存第一行到第三行的初始值。如果你写int matrix[][4]省略第一维度，编译器能通过第二维大小算出来你初始化了多少行，但它没办法省掉第二维，因为第二维直接关系到底层内存怎么划分、指针如何跳跃。

4.2 传参时指针退化问题

C/C++里二维数组传参是个大坑。很多人写过这样的函数：

cpp复制void print_matrix(int matrix[][], int rows, int cols) {
    // ...
}

编译直接报错。因为数组类型在作为参数传递时会退化成指针，int matrix[][4]能编译通过，是因为第二维4让编译器知道每一行跨越4个int，matrix[i]寻址时才能通过i * 4跳到第i行开头。如果你连第二维都不写，编译器完全不知道一行有多长，不要说访问特定行，连数组的步长都没法确定。

更常见的方式是用指针数组或双重指针。int** matrix这种写法适合“每一行长度不一样”的场景，比如你动态给每一行分配了不同的列数。但要注意，int**和int[m][n]在内存布局上不等价。一个合法的二维数组，可以用&matrix[0][0]取出首地址，然后像一维数组那样线性访问整块内存。而int**是一个指向指针的指针，它指向的内存里存放的是一组指针，每个指针再指向真正的行数据，两者完全不同。

下面是两种写法的对比：

cpp复制#include <iostream>

// 方法一：确定第二维大小
void print_with_cols(int matrix[][4], int rows) {
    for (int i = 0; i < rows; ++i) {
        for (int j = 0; j < 4; ++j) {
            std::cout << matrix[i][j] << " ";
        }
        std::cout << std::endl;
    }
}

// 方法二：手动传入每一行的地址
void print_with_pointer(int (*matrix)[4], int rows) {
    for (int i = 0; i < rows; ++i) {
        for (int j = 0; j < 4; ++j) {
            std::cout << matrix[i][j] << " ";
        }
        std::cout << std::endl;
    }
}

int main() {
    int arr[2][4] = {
        {1, 2, 3, 4},
        {5, 6, 7, 8}
    };

    print_with_cols(arr, 2);
    print_with_pointer(arr, 2);

    return 0;
}

不管用哪种写法，关键是要搞清楚“指针的类型决定了它移动一步的字节数”。int*往前走一步是4字节，int (*)[4]往前走一步是16字节，因为这已经是一整行指针了。这个点理解了，很多二维数组的编译报错就不会再让你发懵。

4.3 二维字符数组与字符串数组的纠缠

二维字符数组又是一个很常见的困惑点。C语言里没有独立的字符串类型，字符串本质是字符数组，所以字符串数组就是一个二维字符数组：

cpp复制char names[3][20] = {
    "Alice",
    "Bob",
    "Charlie"
};

这相当于创建了一个3行20列的二维字符数组，每行最多存19个字符加结尾的\0。names[0]的类型是char*，指向"Alice"所在那一行的首地址。这种方案适合你想统一管理固定长度的字符串缓冲区。

如果你想用指针数组来存字符串，写法是这样的：

cpp复制const char* names[] = {"Alice", "Bob", "Charlie"};

这里每个元素就是const char*，指向各自的字符串字面量，内存不连续，每个字符串的长度也可以完全不同。两种写法的区别很直接：二维字符数组预先分配了固定的矩形空间，适合数据要原地修改；字符指针数组不关心每行长度差异，更适合只读的字符串集合。

很多刚学C++字符串初始化的人会问，为什么不直接写std::string names[] = {"Alice", "Bob"}？当然可以，而且更安全。日常C++开发里我几乎不会去用裸指针维护字符串数组，std::vector<std::string>把内存管理和边界检查全部接管了，省心太多。但你要明白，vector底层的空间仍然是一个动态增长的一维数组，二维数组相关的那些思维模式其实依然在发挥作用。

5. 数组算法常见的坑与排查实录

前面讲了不少原理和代码，这一节我想直接回归到“怎么找bug”。每次我看到有人在群里问数组相关的报错，来来回回就那么几个原因。这里整理一下我自己排查问题时的顺序，也相当于一份数组问题排查速查表。

5.1 越界：最普遍的崩溃源头

越界分为两类。第一类是真正的越界访问，C/C++里可能表现为随机数据错乱，严重时直接Segmentation fault；Java里则会抛ArrayIndexOutOfBoundsException。我现在写循环判断时，习惯性检查两个地方：循环条件里的临界值是不是< length，以及访问i+1这类表达式的循环上限是不是改成了length - 1。

第二类越界是逻辑越界，也就是下标没超范围，但访问的语义已经不对了。比如你做“原地覆盖”类操作时，慢指针已经被你推进到slow+1，但下一次快指针可能还没走出那个区域，导致本来应该被覆盖的旧数据又被当作有效数据读了出去。这类问题没有报错提示，只能通过打印中间结果来发现。

我建议做题时先养成一个习惯：凡是会用到nums[i-1]或nums[i+1]的场景，先确认i的起点终点是否符合预期。先写边界条件，再写主逻辑，能省很多调试时间。

5.2 增删元素后下标错乱

在遍历数组时做删除操作，是新手最容易踩的坑。比如JavaScript里你写for循环，用i遍历数组，一旦发现某元素符合条件就arr.splice(i, 1)。此时删除当前元素后，后面所有元素都往前挪了一位，可循环里的i已经进入了下一轮判断，直接跳过了原本位于i+1的元素。

解决方案有三个方向：第一，倒序循环，因为删除当前元素不会影响已经遍历过的元素的位置；第二，循环里手动把i减回去；第三，直接用filter生成新数组，不要原地删。

同理，在算法题里如果需要“删除后不加下标偏移”，最好重新思考一下是否可以用双指针的“覆盖”思维替代物理删除。覆盖比删除安全，因为你不需要真正改变数组长度，只用维护一个有效边界长度就好了。

5.3 二维数组指针和动态分配混用

之前讲二维数组时已经提过，这里补充一个实际场景。有些人在C++里动态创建一个二维数组时，会写：

cpp复制int** arr = new int*[rows];
for (int i = 0; i < rows; ++i) {
    arr[i] = new int[cols];
}

这样创建出来的int**可以正确访问，但它的内存是两段式的：第一段保存rows个指针，第二段是每一行单独的连续内存。不同行之间不一定连续。所以你对这种矩阵没法像普通二维数组那样直接用memset整体清零，也不能把它直接传给形参为int[rows][cols]的函数。如果你需要一整块连续空间，正确做法是：

cpp复制int* arr = new int[rows * cols];

访问row行col列时就写arr[row * cols + col]。这种写法内存完全连续，访问速度也更快，适合做图像处理或矩阵运算。代价是代码可读性差一些，需要自己维护行宽。

5.4 数组问题排查速查表

这张表是我自己每次被数组卡住时回来对照用的清单。每次卡壳，先别急着打日志，先过一遍这个列表，基本能命中八成问题。

6. 我的几点心得

把数组这章啃完之后，我最大的感受是：很多人在数组上花的时间不少，但一直困在“会写但总写错”的循环里，问题出在只记语句、没看结构。

数组是内存里的一块连续空间，这个性质是所有数组技巧的地基。把这条刻在脑子里以后，双指针不会觉得玄乎，因为它不过是用两个下标在同一个连续空间里分工协作；二维数组传参也不会觉得混乱，因为它本质还是线性内存，只是你选择了不同的指针类型告诉编译器“一次跳多远”。

有些同学总想问“这些算法我工作里用得到吗”。我的理解是，直接写一遍快速排序的机会确实不多，但“有序”“去重”“双指针”“窗口”这套思维模式每天都在用。比如合并两个有序列表、批量检查一批数据里的重复项、找出日志里连续时间窗口的异常指标，剥开业务外壳，底下都是数组那一套。

如果你正在按day1、day2这样的节奏推进算法学习，我建议你在做完每道数组题之后，让代码躺一会儿，回头把双指针的三个套路自己画一遍。把每次移动指针时数组状态的变化写出来，比刷十道同类型题都管用。数组这关过好了，后面接触链表或者更复杂的结构时，你的手感会明显比别人稳。