一、二维数组的定义
当一维数组元素的类型也是一维数组时，便构成了“数组的数组”，即二维数组。
二维数组定义的一般格式：
数据类型 数组名[常量表达式][常量表达式]
例如：
int a[4][10]
a数组实质上是一个有 \(4\) 行、 \(10\) 列的表格，表格中课存储 \(40\) 个元素。第 \(1\) 行第 \(1\) 列对应 \(a\) 数组的 \(a[0][0]\)，第n行第m列对应数组元素 \(a[n-1][m-1]\)。
说明：当定义的数组下表有多个时，我们称为多维数组，下标的个数并不局限在一个或两个，可以任意多个，如定义一个三维数组 \(a\) 和四维数组 \(b\)：
int a[5][3][10];
int b[100][100][20][5];
多维的数组引用赋值等操作与二维数组类似。
二、二维数组元素的引用
二维数组的数组元素引用于一位数组元素引用类似，区别在于二维数组元素的引用必须给出两个下标。
引用的格式为：
<数组名>[下标1][下标2]
说明：显然，每个下标表达式取值不应超出下标所指定的范围，否则会导致致命的越界错误。
例如，设有定义：
int a[3][5];
则表示 \(a\) 是二维数组（相当于一个 \(3 \times 5\) 的表格），共有 \(3 \times 5 = 15\) 个元素，它们是：
a[0][0] a[0][1] a[0][2] a[0][3] a[0][4]
a[1][0] a[1][1] a[1][2] a[1][3] a[1][4]
a[2][0] a[2][1] a[2][2] a[2][3] a[2][4]
因此可以看成一个矩阵（表格），\(a[2][3]\) 即表示第 \(3\) 行第 \(4\) 列的元素。
三、二维数组的初始化
二维数组的初始化和一维数组类似。可以将每一行分开来写在各自的括号里，也可以把所有数据写在一个括号里。
例如：
int direct[4][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
int direct[4][2] = { 1, 0, 0, 1, -1, 0, 0, -1 };
例1 对角线翻转
题目描述
给你一个 \(n \times n\) 的二维数组，你需要对其按照对角线进行翻转，并输出翻转后的二维数组。
例如，下面左边是一个 \(3 \times 3\) 的二维数组，后边是它按照对角线进行翻转后的二维数组：
1 2 3 1 4 7
4 5 6 2 5 8
7 8 9 3 6 9
输入格式
输入的第一行包含一个整数 \(n(1 \le n \le 100)\)。
接下来 \(n\) 行，每行包含 \(n\) 个整数，用于表示二维数组中的每个元素（每个元素均为 \(1000\) 以内的正整数）。
输出格式
输出 \(n\) 行，每行包含 \(n\) 个整数，两两之间以一个空格分隔，用于表示按对角线翻转后的二维数组。
样例输入
3
1 2 3
4 5 6
7 8 9
样例输出
1 4 7
2 5 8
3 6 9
问题分析
我们假设数组 \(a[i][j]\) 用于表示原二维数组中第 \(i\) 行第 \(j\) 列的元素，而沿对角线翻转后它的位置变到了第 \(j\) 行第 \(i\) 列。
所以，输入的时候，我们开两层for循环，外层循环遍历行号 \(i\)，内层循环遍历列号 \(j\) ，输入 \(a[i][j]\)；
而输出的时候，我们开两层for循环，外层循环遍历列号 \(j\)，内层循环遍历行号 \(i\)，输出 \(a[i][j]\) 即可。
示例代码：
#include <bits/stdc++.h>
using namespace std;
int n, a[100][100];
int main() {
cin >> n;
for (int i = 0; i < n; i ++) // 输入的时候先遍历行号i，再遍历列号j
for (int j = 0; j < n; j ++)
cin >> a[i][j]; // 输入a[i][j]
for (int j = 0; j < n; j ++) { // 输出的时候先遍历列号j，在遍历行号i
for (int i = 0; i < n; i ++) {
if (i > 0) cout << " "; // 除了最前面那个元素以外的元素前先数一个空格，能保证两两之间以一个空格分隔
cout << a[i][j]; // 输出a[i][j]
}
cout << endl; // 内层循环结束记得加一个回车
}
return 0;
}
例2 对角线增加
题目描述
已知一个 \(n \times n\) 的矩阵（方阵），把所有处在矩阵的两条对角线上面的元素都加上 \(10\)，然后输出这个新矩阵。
输入格式
输入的第一行包含一个整数 \(n(1 \le n \le 100)\)。
接下来 \(n\) 行，每行包含 \(n\) 个整数，用于表示二维数组中的每个元素（每个元素均为 \(1000\) 以内的正整数）。
输出格式
输出 \(n\) 行，每行包含 \(n\) 个整数，两两之间以一个空格分隔，用于表示两条对角线上的元素都 \(+10\) 之后的矩阵。
样例输入
3
1 1 1
1 1 1
1 1 1
样例输出
11 1 11
1 11 1
11 1 11
问题分析
首先我们假设行号和列号都从 \(0\) 开始，即左上角的元素为 \(a[0][0]\)，右下角的元素为 \(a[n-1][n-1]\)，然后我们去遍历每一行（假设行号是 \(i\)），那么只有列号 \(j\) 满足条件 \(j==i\) 或者 \(j == n-1-i\) 的格子上的元素需要 \(+10\)。
当然我们要注意，当 \(n\) 为奇数时，中间的那个点 \(a[n/2][n/2]\) 同时处在了两条对角线上，但是只需要加一遍即可。
示例代码如下：
#include <bits/stdc++.h>
using namespace std;
int n, a[100][100];
int main() {
cin >> n;
for (int i = 0; i < n; i ++)
for (int j = 0; j < n; j ++)
cin >> a[i][j];
for (int i = 0; i < n; i ++) {
if (i == n-1-i) // 说明第i行两条对角线上的点重叠了
a[i][i] += 10; // 所以只需要给这一个点+10即可
else { // 否则，需要给两个点依次+10
a[i][i] += 10;
a[i][n-1-i] += 10;
}
}
for (int i = 0; i < n; i ++) {
for (int j = 0; j < n; j ++) {
if (j) cout << " ";
cout << a[i][j];
}
cout << endl;
}
return 0;
}
例3 稀疏矩阵存储方案
题目描述
大部分元素是 \(0\) 的矩阵称为 稀疏矩阵 ，假设有 \(k\) 个非 \(0\) 元素，则可把稀疏矩阵用 \(k \times 3\) 的矩阵简记之，其中第一列是行号，第二列是列号，第三列是该行、该列下的非零元素的值。如：
0 0 0 5 简记为: 1 4 5 // 第1行第4列有一个5
0 2 0 0 2 2 2 // 第2行第2列有一个2
0 1 0 0 3 2 1 // 第3行第2列有一个1
试编程读入一稀疏矩阵，转换成简记形式，并输出。
输入格式
输入的第一行包含两个整数 \(n,m(1 \le n \le 100)\)，分别表示矩阵的行数和列数。
接下来 \(n\) 行，每行包含 \(m\) 个整数，用于表示二维数组中的每个元素（每个元素均为 \(1000\) 以内的正整数）。
输出格式
输出若干行，每行包含 \(3\) 个整数，以空格分隔，分别表示行号、列号和该非零元素的值。
请按照行号从小到大，行号相同的列号从小到大输出这些数据。
样例输入
3 4
0 0 0 5
0 2 0 0
0 1 0 0
样例输出
1 4 5
2 2 2
3 2 1
问题分析
本题中需要解决的主要问题是查找非零元素并记忆位置。将原始矩阵存于数组 \(a\)。转换后的矩阵存于数组 \(b\)，当然 \(b\) 数组的行数可以控制在一个可控范围内。
我们可以开一个变量 \(k\)，一开始 \(k=0\)，然后我们去遍历每一行每一列。
如果第 \(i\) 行第 \(j\) 列的元素 \(a[i][j] \ne 0\)，则执行如下操作：
k ++;
b[k][0] = i;
b[k][1] = j;
b[k][2] = a[i][j];
这样，最终我们可以的数据将会保存在 \(b\) 数组中坐标从 \(1\) 到 \(k\) 范围内。
示例代码：
#include <bits/stdc++.h>
using namespace std;
int n, m, a[101][101], b[10010][3], k;
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i ++) {
for (int j = 1; j <= m; j ++) {
cin >> a[i][j];
if (a[i][j]) { // 输入的同时就进行判断
k ++;
b[k][0] = i; // 标记行号
b[k][1] = j; // 标记列号
b[k][2] = a[i][j]; // 标记数值
}
}
}
for (int i = 1; i <= k; i ++)
cout << b[i][0] << " " << b[i][1] << " " << b[i][2] << endl;
return 0;
}