编程这么多年，我始终觉得C语言里的数组是个特别有意思的话题。你说它简单吧，声明一个int a[10]谁都会，可一旦牵扯到指针、函数传参、多维结构，翻车的概率立刻飙升。我见过太多人卡在“数组名到底是不是指针”“为什么函数里sizeof算出来的长度不对”这种问题上，一卡就是好几天。这恰恰说明了一个事实：数组是C语言的地基之一，地基没打牢，后面学指针、学链表、学数据结构都会觉得处处别扭。
这篇文章就是个“通关笔记”，我把数组相关的核心知识点、内存模型、实操案例和坑位记录都整理到一块了。不管你是刚学完基本语法、正准备啃数组的新手，还是想回过头查漏补缺的选手，都能在这里找到值得琢磨的东西。咱们不搞那些照本宣科的官方文档式讲解，而是从一个实际写代码的人的角度，把数组掰开了揉碎了说清楚。
1. 数组到底解决什么问题
1.1 编程中的“收纳盒”：数组的诞生逻辑
先说个最朴素的问题：为什么我们需要数组？假设你要统计一个班30个学生的成绩，没有数组的时候，你得声明30个变量，score1、score2、score3……写起来累不说，根本没法用循环去批量处理。要是100个学生呢？1000个呢？这活儿就没法干了。
数组就是为此而生的。它是一种聚合类型，把一堆相同类型的数据打包放在连续的内存区域里，通过下标去访问每一个元素。你可以把数组想象成旅馆的一排房间：房间号从0开始编号，每个房间住着同样“尺寸”的住客（比如都是4字节的int），你只要知道起始地址和房间号，就能立刻找到对应的住客，不需要一间一间去敲门。
这个“按下标直接定位”的特性，专业说法叫随机访问，时间复杂度是O(1)。它和链表那种“必须从头开始找”的访问方式形成了鲜明的对比，也是数组在算法题、底层开发中地位不可撼动的原因之一。
1.2 数组的内存模型：连续存储到底意味着什么
理解了“随机访问”之后，一个更底层的问题浮出水面：数组在内存里到底是怎么摆的？答案只有四个字——连续存储。也就是说，int a[5]这5个元素在内存中是挨个排列的。
假设int占4字节，数组起始地址是0x1000，那么a[0]在0x1000，a[1]在0x1004，a[2]在0x1008，以此类推。这不只是理论概念，它直接影响你对“数组名”“指针”“越界”的理解。
提示：数组名在大多数表达式中会“退化”成指向首元素的指针。比如int a[5]里的a，单独使用时等于&a[0]，也就是0x1000这个地址。但注意，a本身并不是一个真正的指针变量，你不能做a++这类操作。
理解了连续存储，你就能推导出一个非常重要的结论：数组元素之间的地址差是固定的，等于单个元素的大小。这也是为什么编译器允许你用指针算术去遍历数组，因为知道起始地址和步长，就能精确找到每一个元素。
2. 一维数组：声明、初始化和访问
2.1 声明与内存分配，怎么选对数组长度
声明一个一维数组的语法很简单：类型说明符 数组名[常量表达式]。比如int scores[30]表示声明一个有30个int元素的数组，内存会一次性分配30乘以4等于120字节的空间。这里有几个容易忽略的点。
第一，数组长度必须是编译期就能确定的常量（C99标准后支持变长数组VLA，但建议在初学阶段先当它不存在）。你写int n; int a[n]这种代码，有些编译器会报错，有些会放行但行为不保证。第二，数组一旦声明，长度就无法改变，这也引出了后面要说的动态数组话题。第三，命名规范上，数组名跟普通变量一样要尽量做到“见名知意”，避免用a、b、c这种打哑谜式的命名。
选长度时还有个常见误区：有人喜欢“宁可多也不能少”，申请个超大数组。比如需求说最多100个学生，他直接int scores[10000]。程序确实不会报错，但这是极大的浪费。在嵌入式或者内存受限的环境里，这种写法可能直接让程序跑不起来。正确做法是根据需求上限加少量余量，或者干脆用动态数组按需分配。
2.2 初始化方式与默认值：踩过太多次的坑
C语言数组的初始化方式很灵活，一不小心就踩坑。最常见的四种方式，我列个表格对比一下：
| 初始化写法 | 数组内容 | 注意事项 |
|---|---|---|
| int a[5] = {1, 2, 3, 4, 5}; | 元素为1,2,3,4,5 | 元素个数与声明长度一致 |
| int a[5] = {1, 2, 3}; | 元素为1,2,3,0,0 | 未指定的元素自动补0 |
| int a[5] = {0}; | 元素全部为0 | 常用于“清零” |
| int a[] = {1, 2, 3}; | 数组长度为3 | 由初始化列表推断长度 |
其中最常用的写法是“部分初始化”，花括号里只给部分值，剩下的自动补零。这个特性特别实用，比如你想把数组全部初始化为0，写个{0}就够了，比用循环去赋值省事得多。
真正坑人的是局部数组不初始化的情况。如果你在函数内部声明int a[5]却不赋值，那么数组里存的全是“垃圾值”。这些垃圾不是随机的意义不明的数字，而是这块内存区域之前残留的数据，程序每次运行结果都可能不同。所以判断一个数组是否被真正初始化，千万别靠肉眼观察，建议养成习惯：声明数组后立刻初始化，或者至少给个{0}让内容可预测。
2.3 数组越界：为什么C语言允许你飞出去
数组越界可能是C语言初学者遇上的第一只“拦路虎”。a[5]这个数组，合法的下标范围是0到4，你偏要访问a[5]，程序却不会在运行时报错，而是“正常”地把下标为5的内存位置的数据读给你看。这跟Java、Python这类语言完全不同，那些语言会直接抛异常。
C语言为什么这么“放任”？因为它追求效率。每做一次下标检查都要付出额外的运行时间，对于追求极致性能的语言来说，这种检查被留给了程序员自己。换句话说，C语言信任程序员，相信你永远不会写越界代码。
可现实是，人都会犯错。越界读会读到未知数据，越界写可能覆盖旁边变量的值，这在大型项目里就是最难排查的bug：程序崩溃是往往不是发生在写入的那一刻，而是过了一段时间之后，在其他某个跟你直觉完全无关的地方炸了。调试这种问题，经验丰富的程序员也头疼。
注意：如果“一定要”越界访问（比如在做算法题时数组下标从1开始更舒服），请务必将数组长度多声明一位，int a[6]却只用下标1到5。这种“空间换便利”的写法在竞赛代码里非常常见，但务必保证真的不会访问到越界位置。
3. 二维数组与多维数组：矩阵思维
3.1 二维数组的存储结构与行列访问
一维数组是好理解的线性结构，二维数组就相当于把一维数组的每个元素又变成了一个一维数组。比如int matrix[3][4]，逻辑上看是个三行四列的矩阵，内存里的排布却是“行优先”的：先放第0行的4个元素，再放第1行的4个元素，最后放第2行的4个元素。
这种“行优先存储”意味着什么？意味着matrix[i][j]等价于*((matrix + i) + j)。你把matrix当成一个“装着3个一维数组的数组”，matrix + i就跳到第i行，(matrix + i)拿到这一行的首地址，再加j就是第i行第j列元素的地址，最后用*取出值。初学者初次看到这串表达式往往会头皮发麻，但其实拆开来看没那么玄乎。
有个计算题特别能检验你对“行优先”的理解：已知int matrix[3][4]首地址是0x1000，int占4字节，问matrix[2][1]的地址是多少？计算方式是这样的：前两行一共是2乘4等于8个元素，偏移量就是8乘4等于32字节，再加上第二行内的1个元素偏移4字节，总共偏移36字节，所以地址是0x1024。
3.2 实战：5x5鞍点问题怎么解
鞍点问题是很多学校作业和考试里的常客，也是二维数组综合应用的好例子。题目要求：在一个5乘以5的矩阵中，找出满足“该位置上的元素在其所在行中最大，同时在其所在列中最小”的“鞍点”，并输出它的位置和值；如果不存在则输出特定提示。
我见过一个很好的解法框架，利用stdio.h做输入输出，利用limits.h里的INT_MIN和INT_MAX做初始值。核心思路分三步：
第一步，遍历矩阵，找出每一行的最大值及其列位置。第二步，针对每行最大值的位置，检查该位置的元素是否也是所在列的最小值。第三步，满足条件就记录并输出，否则输出不存在提示。代码结构大概是这样的：
#include <stdio.h> #include <limits.h> #define ROW 5 #define COL 5 int main(void) { int matrix[ROW][COL]; int i, j; for (i = 0; i < ROW; i++) for (j = 0; j < COL; j++) scanf("%d", &matrix[i][j]); int found = 0; for (i = 0; i < ROW; i++) { int max_row = INT_MIN; int col_of_max = 0; for (j = 0; j < COL; j++) { if (matrix[i][j] > max_row) { max_row = matrix[i][j]; col_of_max = j; } } int min_col = INT_MAX; for (int r = 0; r < ROW; r++) { if (matrix[r][col_of_max] < min_col) { min_col = matrix[r][col_of_max]; } } if (matrix[i][col_of_max] == min_col) { printf("鞍点: matrix[%d][%d] = %d\n", i, col_of_max, max_row); found = 1; } } if (!found) printf("未找到鞍点\n"); return 0; }这里面有个容易被忽略的细节：求最大值时，如果行内存在相等元素，到底取哪个作为鞍点位置？不同题目要求不同，有些要求取第一个，有些要求“只考虑严格大于”，所以你要养成先读题再写代码的习惯，从“写代码”变成“解题”，用纸笔把思路画清楚再动手写。
3.3 二维数组作为函数参数的正确姿势
二维数组作为函数参数是让很多人头疼的问题。一个关键限制是：函数形参中，第一个维度的长度可以省略，但后面的维度长度必须明确写出。比如：
void print_matrix(int arr[][4], int rows);或者写成指针形式：
void print_matrix(int (*arr)[4], int rows);这两种写法本质是一样的，都是“指向含有4个int的一维数组的指针”。为什么后面这个维度不能省略？因为编译器需要知道每一行的步长，才能正确计算arr[i][j]的地址偏移。
很多初学者尝试int **arr作为二维数组参数，结果编译通过但运行时崩溃。原因在于数组名退化后的类型是int (*)[4]，而int **是完全不同的类型。两指针的步长不同，自然无法混用。如果你想用int **，通常需要配合动态分配或者手工构造“指针数组”，那是另一种玩法了。
4. 字符数组与字符串：C语言最阴险的角落
4.1 字符数组和字符串字面量的区别
C语言没有独立的字符串类型，所谓的字符串，本质上就是“以空字符\0结尾的字符数组”。这是C语言初学者最不容易转过弯、也最容易出bug的概念。理解这一点之前，你看到的char str[] = "hello"是一个字符串；理解之后你会发现，这不过是一个包含有h、e、l、l、o、\0这6个字符的数组。
这里有一个看似不起眼却极其关键的差别：字符数组和字符串字面量的存储位置不同。char str[] = "hello"会把字符串内容复制到栈上，这块内存可读可写；而char *str = "hello"只是让指针指向了只读的字符串字面量。如果你试图对后者执行str[0] = 'H'这种操作，在部分平台上会直接段错误崩溃。为什么会这样？因为“hello”这5个字符存在了程序的只读数据段里，去了保护权限。
提示：写代码时如果只是读取字符串内容，用char *完全没问题；如果打算修改字符串里面的字符，一定要用char str[]的写法。
4.2 字符串逆序实战
字符串逆序是一道非常经典的指针和数组练习题，也是PAT之类的刷题网站上的常客。它考察的核心其实特别单纯：两个下标的交换问题。实现思路基本是维护一个left指向开头、right指向末尾（这里的末尾是\0前一个字符），然后不断交换两个位置的字符，直到left大于等于right。
从右往左数的关键是必须用“长度减一”找到最后一个有效字符。千万别忘了中间那个\0的存在。如果你把\0也当成普通字符去交换，字符串就“变短了”甚至完全乱了。
很多学校的平时作业或网上OJ里都有“字符串逆序c语言pta”这个题，考的就是这个经典思路。建议你亲手把它写一遍、运行一遍，再试试不同的输入情况，而不是直接复制别人的代码，要记住：这种基本功是你后半辈子写代码的地基。
4.3 如何安全地输入char数组
“如何安全地输入char数组”是很多人踩坑的地方。直接用scanf("%s", str)读入字符串的最大问题是：它不检查输入长度。用户输入100个字符，你的数组只申请了30个，剩下的70个字符照样往内存里写，直接越界，程序崩溃是轻的，数据被覆盖才真的头疼。
更稳妥的方式是限制宽度，比如scanf("%30s", str)，确保最多读入29个字符，留一个位置给\0。如果你需要读入含空格的整行字符串，可以使用fgets(str, sizeof(str), stdin)，它会自动控制读取上限，并且保留换行符。
说到这个，我建议你千万不要用gets这个函数，它完全不检查边界，早已从C标准库中移除。我看过太多初学者还在照着旧教材抄gets，编译时警告不断，运行起来隐患无穷。时代变了，该更新代码习惯就得更新。
5. 指针数组与数组指针：绕不开的兄弟
5.1 指针数组：装地址的数组
指针数组，先说名字就透着一股“陷阱”的味道：它是一个数组，只不过里面装的不是普通数值，而是指针。声明方式int *arr[5]表示“一个有5个元素、每个元素都是int *类型指针”的数组。
这种结构最大的用途场景之一是处理字符串集合。比如你要做一个小型的学生名字列表，用二维字符数组固然可以，但每行的存储长度都按最长的来开，内存太浪费了。用指针数组装字符串常量的首地址，就能做到“长短不一、互不浪费”的字符串表：
const char *names[] = {"小明", "小红", "Tom", "Jerry"};此外，指针数组也用在对二维数组按行重排的场景。比如你需要按行对矩阵排序，直接交换二维数组里的数据行既不高效也不好写，但交换指针数组里的指针只需一次赋值操作，效率高得多。这个思路在数据库排序、图形图像处理里都很常见。
5.2 数组指针：指向数组的指针
数组指针和指针数组的声明只差一对括号，含义却差之千里。数组指针是一个指针，它指向某个数组。声明方式int (*p)[5]表示“一个指针，它指向含有5个int的一维数组”。
这个声明里括号为什么不能省？因为如果不加括号，int *p[5]会先按“p是一个数组”解释，每个元素是int *，这跟int (*p)[5]表达的“p是指针”完全不同。C语言里“声明先看优先级”的规则在这里体现得淋漓尽致。
数组指针最常见的应用场景是二维数组传参，正如前文提到的void print_matrix(int (*arr)[4], int rows)。理解了数组指针，你就能明白为什么二维数组传参时后面那个维度必须写出来：因为函数内部需要根据它计算出指针移动的步长。
5.3 指针算术：数组名的加减法
指针算术初看只是个简单的“指针加数字”，但坑藏在细节里。int *p指向某个int数组，p + 1在内存地址上到底加了多少？答案是加了一个int大小，通常也就是4字节。而对int (*p)[5]这个指向数组的指针来说，p + 1则会一次性跳过一个完整的含有5个int的数组，也就是20字节。
这种感觉就像坐公交车：普通指针是“跳一个座位”，步长是一个元素；数组指针是“跳一排座位”，步长是一整排。所以用指针“移动”数组时，必须明确当前指针的步长到底是什么，不然算出的地址完全是错的。
这些内容闻言简单、用起来却容易乱，进而在调试时浪费大量时间。我的建议是遇到指针运算先不要心算，用printf把每次指针移动前后的地址值打出来验证，看到实际操作结果比什么理论都巩固。
6. 数组的动态化：可变数组与堆内存
6.1 静态数组的限制
静态数组（或者说固定长度数组）的最大限制在于：长度在编译期就写死了。程序跑起来后，用户实际需要处理的数据量可能会大于这个长度，也可能会远远小于。
在实际项目中，数据量是一个高度动态变化的东西，比如用户上传的文件大小、日志条数、网络包个数，全都不是写程序时能确定的。为了应对“不知道有多少数据”的情况，传统静态数组的姿势就是申请一个极大的“估算上限”，然后处理时只使用前面一部分。这既浪费了内存，又可能在某个意外的峰值上崩溃。
所以，很多场景下“可变数组”才是正道，也就是说，能够在程序运行时动态地扩容和缩小，存放的数据多了就自动扩大容量。而C语言实现这种可变数组的底层工具，就是堆内存分配函数。
6.2 malloc/free实现动态数组
C语言中动态分配内存的函数主要是malloc和free。使用非常直接：malloc后面跟着要申请的字节数，返回一个void *指针，然后强制类型转换成你要的类型；使用完毕后用free归还内存，避免内存泄漏。
int n; printf("请输入数组长度: "); scanf("%d", &n); int *arr = (int *)malloc(n * sizeof(int)); if (arr == NULL) { printf("内存分配失败\n"); return 1; } // 使用 arr[0] ~ arr[n-1] 来操作 free(arr);这段代码里有几个非常容易出错的地方。第一，malloc申请的内存内容是随机的，不会自动清零；想让元素初始化为0，可以用calloc，或者自己用循环赋一遍。第二，“每次使用malloc后都要检查返回值”，这是写代码的好习惯；如果返回NULL，说明内存不够了，程序应该做相应的处理。第三，释放内存之后，最好把指针置为NULL，防止后续误用这个“悬空指针”。
注意：动态数组用完之后不free会造成内存泄漏。长期运行的服务进程，每次泄漏几十字节，跑几天就很可能被系统杀掉。调试内存问题可以用valgrind之类的工具，它会明确告诉你哪一行泄漏了多少字节。
6.3 动态二维数组与VLA
动态二维数组有几种构造方式，最实用的是“指针数组 + 每行单独分配”：
int rows = 3, cols = 4; int **matrix = (int **)malloc(rows * sizeof(int *)); for (int i = 0; i < rows; i++) { matrix[i] = (int *)malloc(cols * sizeof(int)); } // 访问 matrix[i][j]，用完记得逐行free再free matrix本身这样得到的内存布局是“每行内部连续、行与行之间不一定连续”，访问起来跟静态二维数组一样用matrix[i][j]就行。值得注意的是，释放内存的顺序必须倒着来，先释放所有行，再释放保存行指针的数组，顺序反了会直接造成“不可控的崩溃”。
至于VLA（变长数组），这是C99引入的新特性，允许int n; int a[n]这样声明。但它的实现同样受栈空间限制，长度稍微大一点就容易爆栈。在正规项目里，我不太建议依赖VLA，尤其是跨平台移植时，不同编译器对VLA的支持和表现并不一致。
7. 数组的经典算法与应用场景
7.1 冒泡排序与选择排序
“冒泡排序c语言”大概是数组算法里的经典入门题，也是很多人对“算法”产生的第一印象。核心思路是相邻元素两两比较，把较大值往后移，每一轮下来最大的元素就像气泡一样浮到了最后，所以它叫冒泡。
void bubble_sort(int arr[], int n) { for (int i = 0; i < n - 1; i++) { int swapped = 0; for (int j = 0; j < n - 1 - i; j++) { if (arr[j] > arr[j + 1]) { int tmp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = tmp; swapped = 1; } } if (!swapped) break; // 没有交换发生，说明已经有序，提前结束 } }这里有一个很常见的优化手段就是加swapped标志。如果某轮排序中一次交换都没有发生，说明序列已经有序，就可以直接跳出循环，不必做无谓的遍历。很多教科书版本直接跑两层循环也可以，但有了这个优化，接近有序的数据排序会快很多。
冒泡排序的时间复杂度是O(n的平方)，只适合小规模数据。我当时学它，主要是为了理解“数组?排序?交换”这三者的关系，这种基本功对未来学快排、归并都有帮助。
7.2 数组去重与查找
数组去重，简单理解就是把重复出现的元素干掉，只保留一个。暴力做法双重循环，每个元素跟之前的元素比较一遍，时间复杂度O(n的平方)。更高效的办法是，先对数组排序，让相等的元素挤在一起，再单趟扫描就能去重，复杂度降到O(n log n)。再进阶一步用哈希表，能达到O(n)。不过C语言里用哈希表需要手动实现，练手时先掌握排序法就够用了。
查找方面，最简单的线性查找不需要数组有序，一个个比对就行。更快的二分查找要求数组必须是有序的，每次砍半，复杂度O(log n)。面试时经常会问“如何在一个有序数组里快速定位某个值”，考的就是二分查找的手写能力。你可以在脑子里走一遍这个过程：取中间位置，跟目标比较，决定是继续在左半查找还是右半查找，直到left越过right。
7.3 循环队列：数组实现环形结构
循环队列是一种非常经典的数据结构，用数组就能实现。基础是固定长度的数组q[m]，再加上两个标志位：rear表示队尾位置，length表示当前队列长度。之所以叫循环，是因为数组下标到了末尾后可以通过取模操作“绕回”到开头，避免挪动整块数据。
它的关键点在于怎么判断“队满”和“队空”。最常用的做法是“浪费一个元素位置”区分：队空和队满时rear和front恰好相等的条件会变得不唯一，所以很多教材用“队头指针连接队尾再取模若等于队头则满”的公式来判断。
实际写代码时，这种成环的下标计算必须格外小心。如果你用rear和length来指示队列状态，查找队列元素时也要注意下标的取模处理，否则很容易出现元素顺序错乱的问题。理解了这种“数组+取模”的思想，你会发现栈、链表之外的又一重天地，也为后续学习操作系统里的环形缓冲区打下了基础。
7.4 树状数组与更高阶概念
如果排序、查找只是基础，那么“树状数组”就是数组进阶应用中的一座小山了。它利用数组的下标二进制特性，实现单点修改和区间求和的高效操作，希望通过“灵感”把复杂度从O(n)降到O(log n)。我在大学时第一次接触它，惊为天人，原来数组可以玩出这么多花样。
当然，这篇文章不是树状数组专题，我只是想提醒你：数组作为一种底层结构，能延展出去的概念太多了，前缀和、差分数组、双指针、滑动窗口等等全都建立在数组之上。你完全可以把它们当作练习题目标，在掌握基础之后逐个击破。
8. 调试与工具链：如何用GDB看数组
8.1 编译选项与警告
“验08利用gdb工具调试c语言程序”这种题目在实验课上很常见，我自己上学时也被布置过。那时我觉得调试是浪费时间，代码对不对跑一下试试就行。后来走上工作岗位才发现，只有会调试的人才能快速定位问题，调试本身也是一门硬技术。
先说编译阶段能省力气的操作：在GCC编译命令里加上-Wall表示把警告全开，加上-g表示生成调试符号。完整的编译命令大概是gcc -Wall -g program.c -o program。加了-Wall之后，很多隐蔽的问题，比如未初始化的变量、类型不匹配、少写返回值之类的问题，编译器会在编译阶段直接帮你指出来，省去在运行时排错的大量时间。
8.2 GDB常用命令展示数组内容
GDB是Linux下最常用的调试工具，功能相当强大。要展示数组内容，通常使用print命令。比如程序执行到某一行，我想看a数组前10个元素的内容，直接输入p a会打印全部，数据一多屏幕就装不下了。想打印指定范围，语法是p a[index]@length，比如p a[0]@10会打印从a[0]开始的10个元素，这对观察局部变化非常有用。结合watch命令监视某个变量或内存地址，你甚至能准确知道它在哪一次操作时被写入或改变。
然后断点是你定位问题强有力的工具。break main会在main函数入口停下来，run运行，next执行下一行但不进入函数，step进入函数内部。习惯一套Shortcut之后，调试的速度会越来越快。
8.3 常见BUG实录
最后，我整理几条数组相关的常见bug让大家避雷。
第一条：忘了数组下标从0开始。你声明int a[10]，循环写for(i = 1; i <= 10; i++)，直接访问了a[10]，越界。
第二条：字符串数组不分配\0的位置。char s[3] = "abc"，这本身就不是合法的字符串，因为字符串需要一个4字节的空闲位置放结尾标志。实际表现为printf("%s", s)输出不完整或输出乱码。正确做法是至少分配4字节。
第三条：函数参数写成int a[]，然后在函数内部用sizeof(a) / sizeof(a[0])，期待得到数组长度。事实上，数组作函数参数时会退化为指针，sizeof(a)得到的是指针大小，这样计算的长度就错了。要真想传长度，必须额外加一个长度参数。
第四条：返回指向局部数组的指针。函数内部定义的数组在函数结束时就销毁了，返回的指针指向“已作废”的内存，程序里再次访问它结果未定义。正确做法是用动态分配、将数组传给外部缓冲区，或靠调用方提供内存。
9. 练习题推荐与刷题路径
学编程就像学游泳，光看不会，光听也不会，只有下水扑通几下才真正会。数组这一块，我建议你从这些经典练习开始，逐个过关。
- 99乘法表：用双重循环打印乘法表，练熟二维遍历。
- 完数查找：找出10000以内的所有完数（真因子之和等于本身），练循环加判断、筛数据的组合能力。
- 字符串逆序：练指针操作和字符串边界处理。
- 冒泡排序：练数组排序的经典套路，并尝试优化它。
- 5乘以5鞍点问题：练二维数组遍历和行列逻辑。
- PAT乙级1037在霍格沃茨找零钱：练模拟计算和进制换算思想，这类题目对数组并不直接，但非常锻炼模拟能力和边界处理能力。
- 循环队列最值问题：基于数组实现一个环形队列，再封装若干操作。
这些题目我大致分为三类：熟练基础类、算法入门类、竞赛进阶类。你可以按照顺序慢慢刷，每道题从读题到写出能跑的代码，再到优化，每一步都有收获。刷题的同时，建议把历次提交的WA（答案错误）记录保存下来，过一段时间再看，你会发现自己进步的速度比想象中快。
10. 环境配置与学习资源参考
学习过程中如果把环境搭得不顺手，很容易消磨热情。我看到不少新手卡在“虚拟机里配置C语言环境”这一步，配了半天，还没开始写代码就累了。其实Windows上装个VSCode加MinGW GCC插件，或者用CLion，都能非常顺滑地写完、编译、调试整个流程。Linux用户则更简单，直接apt或dnf安装build-essential或gcc即可，编辑器用VS Code或者传统的vim都行。
编译器C语言入门的时候，我强烈建议先忘掉IDE自动补全的便利，试试用命令行gcc手动编译。这个阶段多打几条gcc命令，会让你对“编译-链接-运行”的分工有更直观的感知，对后面理解“头文件”“库函数”这些概念都很有帮助。
课程和学习资源方面，网上口碑不错的浙江大学翁恺老师的C语言课程，是很多人心中的“神作”，讲解非常细致，尤其是数组部分，用很多生活中的例子给你加深印象。如果想刷题，PTA平台的练习题也跟这个课程配套。这类平台的好处是一站式在线评测，不用自己搭建环境也能看到结果，特别适合初学阶段。
补充一句：不同编程语言中的“数组”不完全是一回事。比如VBA里的数组下标可以指定从几开始，C#里不同类的实例可以通过object数组混在一起存放。之所以C语言的数组要求类型相同，根本原因在于它要靠类型确定步长、靠步长完成随机访问。在学习C语言数组时，不要被别的语言的用法带偏，等你把C语言搞扎实了，再对比其他语言反而收益更大。
就我个人而言，数组从入门到熟练掌握，通常都要经历三个层次。第一层是会写，就是能声明、能初始化、能访问；第二层是会想，也就是明白内存模型，能预判各种写法的地址偏移和生命周期；第三层是会练，能在写完代码之后用GDB看内存、用valgrind查泄漏，动态分配、释放、边界条件全部游刃有余。
写到这里，我自己回忆起当年卡在源代码上看了一个多小时，最后发现只是越界访问的老bug，仍然觉得又好气又好笑。前面几次踩坑的时候我还挺沮丧，后来反而把这些案例当成了教学的珍宝。你要是练到觉得“数组不过如此”的阶段，再往回看这些坑，就会知道我对这段学习的形容一点都不夸张。
C语言数组只是工具，但用工具的人需要懂得工具的原理。把数组的内存模型想明白、把边界条件写清楚、把调试手法练熟练，后面的指针、链表、二叉树学起来就会顺畅很多。
