💻作者简介：曾 与 你 一 样 迷 茫，现 以 经 验 助 你 入 门 C 语 言
💡个人主页：@ 笑 口 常 开 xpr 的 个 人 主 页
📚系列专栏：C 启 新 程
✨代码趣语：世 上 只 有 两 种 编 程 语 言：一 种 是 总 是 被 人 骂 的，一 种是 从 来 没 人 用 的。
💪代码千行，始 于 坚 持 ，每 日 敲 码，进 阶 编 程 之 路。
📦gitee 链 接：gitee

       在 编 程 的 奇 妙 宇 宙 里，每 一 道 C 语 言 的 题 目 都 宛 如 一 颗 神 秘 的 星 辰 ，潜 藏 着 无 尽 的 解 题 思 路 和 创 新 可 能 。你 可 曾 在 夜 深 人 静 时 苦 思 冥 想，一 道 看 似 简 单 的 C 语言 题 目 背 后 ，究 竟 藏 着 怎 样 的 算 法 奥 秘 ？又 能 为 我 们 解 决 实 际 问题 带 来 怎 样 的 启 发 ？今 天 ，让 我 们 投 身 C 语 言 刷 题 海 洋，挖 掘 代 码 宝 藏 ，体 验 解 题 快 感，解 锁 其 无 限 潜 力，向 编 程 高 手 迈 进！

第 一 题 - - - 冒 泡 排 序

描 述：
首 先 输 入 一 个 整 数 n （0 < n <= 100），然 后 输 入 n 个 整 数（整 数 之 间 用 空 格 隔 开），程 序 将 对 所 输 入 的 整 数 进 行 排 序 操 作，排 序 规 则 为 升 序（ 即 从 大 到 小），最 终 输 出 排 序 后 的 整 数 序 列。
输 入 描 述：
两 行 ，第 一 行 为 整 数 n ，第 二 行 为 n 个 整 数，中 间 用 空 格 隔 开。
输 出 描 述：
一 行，整 数 之 间 用 空 格 隔 开。
示 例 1 ：
输 入 ：1 2 3 4 5 6 7 8 9
输 出 ：9 8 7 6 5 4 3 2 1
示 例 2 ：
输 入 ：1 2 5 6 8 7 9 9 10
输 出 ：10 9 9 8 7 6 5 2 1

思 路 分 析：

         针 对 这 道 题 目，我 们 可 以 先 定 义 一 个 数 组，将 给 定 的 n 个 数 字 依 次 存 储 到 该 数 组 中 。随 后，运 用 函 数 来 完 成 排 序 操 作。在 此，我 们 以 冒 泡 排 序 算 法 为 例，对 数 组 中 的 数 字 进 行 从 大 到 小 排 序。

冒 泡 排 序

         冒 泡 排 序（Bubble Sort）是 一 种 基 础 的 排 序 算 法，它 的 基 本 思 想 就 如 同 水 中 的 气 泡 一 样，较 小 的 元 素 会 逐 渐 “ 浮 ” 到 数 组 的 顶 部 （ 即 数 组 的 前 面 ），而 较 大 的 元 素 则 会 “ 沉 ” 到 数 组 的 底 部（ 即 数 组 的 后 面 ）。具 体 来 说，冒 泡 排 序 会 重 复 地 走 访 过 要 排 序 的 数 列，一 次 比 较 两 个 元 素，如 果 它 们 的 顺 序 错 误（例 如 ，在 升 序 排 序 中 前 一 个 元 素 大 于 后 一 个 元 素），就 把 它 们 交 换 过 来。这 个 过 程 会 一 直 重 复，直 到 整 个 数 列 都 被 排 序 好。

冒 泡 排 序 的 原 理

比 较 相 邻 元 素
         从 数 组 的 第 一 个 元 素 开 始，依 次 比 较 相 邻 的 两 个 元 素。如 果 顺 序 错 误，则 交 换 它 们 的 位 置。

重 复 比 较

         对 数 组 中 的 每 一 对 相 邻 元 素 都 进 行 上 述 比 较 和 交 换 操 作，直 到 最 后 一 对 元 素。这 样，经 过 一 轮 比 较 后，最 大 的 元 素 就 会 被 移 动 到 数 组 的 末 尾。

缩 小 范 围

         排 除 已 经 排 好 序 的 最 后 一 个 元 素，对 剩 余 的 元 素 重 复 上 述 步 骤，直 到 整 个 数 组 都 被 排 序 好。

如 图 所 示 为 冒 泡 排 序 的 过 程：

温 馨 提 示：读 者 们 ，先 自 己 写 代 码，这 是 提 升 编 程 能 力 的 好 机 会。若 未 达 要 求 ，别 气 馁 ，参 考 下 文 代 码 会 有 新 收 获。

下 面 展 示 代 码 示 例 。

#include<stdio.h>
#include<string.h>
void sort(int arr[], int sz)
{int i = 0;int j = 0;for (i = 0;i < sz - 1;i++)//进行sz - 1次比较{for (j = 0;j < sz - 1 - i;j++)//进行sz - 1 - i已经排好的数{if (arr[j] > arr[j + 1]){int temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}
}
int main()
{int num = 0;scanf("%d", &num);int arr[100];memset(arr, 0, sizeof(arr));int i = 0;for (i = 0;i < num;i++){scanf("%d", &arr[i]);}int sz = num;sort(arr, sz);for (i = 0;i < sz;i++){printf("%d ",arr[i]);}return 0;
}

代 码 解 释：

冒 泡 排 序 函 数 sort

void sort(int arr[], int sz)
{int i = 0;int j = 0;for (i = 0; i < sz - 1; i++) // 进行 sz - 1 次比较{for (j = 0; j < sz - 1 - i; j++) // 进行 sz - 1 - i 次比较，排除已经排好的数{if (arr[j] > arr[j + 1]){int temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}
}

函 数 定 义

void sort(int arr[ ], int sz) 定 义 了 一 个 名 为 sort 的 函 数，它 接 受 一 个 整 型 数 组 arr 和 数 组 的 大 小 sz 作 为 参 数，不 返 回 任 何 值（void）。

外 层 循 环

       for (i = 0; i < sz - 1; i++) 控 制 排 序 的 轮 数，总 共 需 要 进 行 sz - 1 轮 排 序。因 为 每 一 轮 排 序 都 会 将 一 个 最 大 的 元 素 放 到 正 确 的 位 置，经 过 sz - 1 轮 后，整 个 数 组 就 会 有 序。

内 层 循 环

       for (j = 0; j < sz - 1 - i; j++) 用 于 比 较 相 邻 的 元 素 。随 着 外 层 循 环 的 进 行，已 经 排 好 序 的 元 素 会 越 来 越 多，所 以 内 层 循 环 的比 较 次 数 会 逐 渐 减 少（sz - 1 - i）。

元 素 交 换

         if(arr[ j ] > arr[ j + 1 ]) 判 断 相 邻 的 两 个 元 素，如 果 前 一 个 元 素 大 于 后 一 个 元 素，则 交 换 它 们 的 位 置，通 过 临 时 变 量 temp 实 现 交 换。**如 果 想 要 数 字 从 小 到 大 进 行 排 序，只 需 将 " > " 改 为 " < " 即 可。

第 二 题 - - - 回 型 矩 阵

描 述：
给 你 一 个 整 数 n，输 出 n ∗ n 的 回 型 矩 阵。
输 入 描 述 ：
输 入 一 行，包 含 一 个 整 数 n
1 <= n <= 19
输 出 描 述 ：
输 出 n 行，每 行 包 含 n 个 正 整 数.
示 例 ：
输 入 ：
4
输 出 ：
  1   2   3 4
12 13 14 5
11 16 15 6
10   9   8 7

特 点

         回 型 矩 阵 的 特 点 是 从 外 向 内 一 圈 一 圈 地 填 充 数 字。我 们 可 以 按 照 顺 时 针 方 向，从 矩 阵 的 最 外 层 开 始，逐 步 向 内 层 填 充 数 字。

确 定 边 界：定 义 矩 阵 的 四 个 边 界，分 别 是 上 边 界 top、下 边 界 bottom、左 边 界 left 和 右 边 界 right。初 始 时，top = 0，bottom = n - 1，left = 0，right = n - 1。​

填 充 方 向：按 照 顺 时 针 方 向 填 充，即 先 从 左 到 右 填 充 上 边 界 ，然 后 从 上 到 下 填 充 右 边 界，接 着 从 右 到 左 填 充 下 边 界，最 后 从 下 到 上 填 充 左 边 界。每 次 填 充 完 一 圈 后，将 边 界 向 内 收 缩，即 top++，bottom–，left++，right–。​

填 充 数 字：使 用 一 个 变 量 num 来 记 录 当 前 要 填 充 的 数 字，初 始 值 为 1。在 每 次 填 充 时 ，将 num 的 值 赋 给 当 前 位 置 的 矩 阵 元 素，并 将 num 自 增 1。

温 馨 提 示：读 者 们 ，先 自 己 写 代 码，这 是 提 升 编 程 能 力 的 好 机 会。若 未 达 要 求 ，别 气 馁 ，参 考 下 文 代 码 会 有 新 收 获。

下 面 展 示 代 码 示 例 。

#include<stdio.h>
#define ROW 100
#define COL 100
void back(int num1)
{int arr1[ROW][COL] = { 0 };int top = 0;int bottom = num1 - 1;int left = 0;int right = num1 - 1;int num = 1;int i = 0;while (left <= right && top <= bottom){//从左向右填充上边界for (i = left;i <= right;i++){arr1[top][i] = num++;}top++;//从上向下填充右边界for (i = top;i <= bottom;i++){arr1[i][right] = num++;}right--;//从右向左填充下边界for (i = right;i >= left;i--){arr1[bottom][i] = num++;}bottom--;//从下向上填充左边界for (i = bottom;i >= top;i--){arr1[i][left] = num++;}left++;}for (i = 0;i < num1;i++){int j = 0;for (j = 0;j < num1;j++){printf("%3d ", arr1[i][j]);}printf("\n");}
}
int main()
{int num1 = 0;scanf("%d", &num1);back(num1);
}

开 头：

• #include<stdio.h> 引 入 输 入 输 出 库，供 printf、scanf 使 用。​
• #define ROW 100 和 #define COL 100设 数 组 arr1 行 列 数，能 存 n ≤ 100 的 矩 阵。​

back 函 数：​

• void back(int num1) 负 责 生 成、输 出 矩 阵，num1 为 矩 阵 大 小 n。​
• 定 义 int arr1[ROW][COL] = { 0 }; 存 矩 阵，初 始 全 为 0。​
• 初 始 化 边 界 top = 0、bottom = num1 - 1、left = 0、right = num1 - 1，num = 1 记 填 充 数，i 作 循 环 变 量。​

生 成 矩 阵：

• while (left <= right && top <= bottom) 为 循 环 核 心，确 保 各 圈 正 确 填 充。​
• 4 个 for 循 环 依 次 填 充 上、右、下、左 边 界，每 圈 结 束 边 界 收 缩。​

输 出 矩 阵：
​
用 嵌 套 for 循 环 输 出，外 层 控 行，内 层 控 列，以 宽 度 3 格 式 输 出 并 换 行。​

main 函 数：
​

• 定 义 int num1 = 0; 存 输 入 的 n。​
• 用 scanf(“%d”, &num1); 读 n。​
• 调 用 back(num1) 生 成 输 出 矩 阵，return 0; 结 束 程 序。​

上 述 代 码 的 改 进：

#include<stdio.h>
#define ROW 100
#define COL 100
void back(int num1)
{int arr1[ROW][COL] = { 0 };int top = 0;int bottom = num1 - 1;int left = 0;int right = num1 - 1;int num = 1;int i = 0;while (left <= right && top <= bottom){//从左向右填充上边界for (i = left;i <= right;i++){arr1[top][i] = num++;}top++;//从上向下填充右边界for (i = top;i <= bottom;i++){arr1[i][right] = num++;}right--;if (top <= bottom){//从右向左填充下边界for (i = right;i >= left;i--){arr1[bottom][i] = num++;}bottom--;}if (left <= right){//从下向上填充左边界for (i = bottom;i >= top;i--){arr1[i][left] = num++;}left++;}}for (i = 0;i < num1;i++){int j = 0;for (j = 0;j < num1;j++){printf("%2d ", arr1[i][j]);}printf("\n");}
}
int main()
{int num1 = 0;scanf("%d", &num1);back(num1);
}

第 三 题 - - - 蛇 形 矩 阵

描 述：
给 你 一 个 整 数 n，输 出 n ∗ n 的 蛇 形 矩 阵。
输 入 描 述 ：
输 入 一 行，包 含 一 个 整 数 n
输 出 描 述 ：
输 出 n 行，每 行 包 含 n 个 正 整 数，通 过 空 格 分 隔。
1 <= n <= 1000
示 例 ：
输 入 ：
4
输 出 ：
  1  2   6    7
  3  5   8  13
  4  9  12 14
10 11 15 16

温 馨 提 示：读 者 们 ，先 自 己 写 代 码，这 是 提 升 编 程 能 力 的 好 机 会。若 未 达 要 求 ，别 气 馁 ，参 考 下 文 代 码 会 有 新 收 获。

下 面 展 示 代 码 示 例 。

#include<stdio.h>
#define ROW 100
#define COL 100
void snake(int num) 
{int arr[ROW][COL] = { 0 };int i = 0;int j = 0;int num1 = 1;int derection = 0;i = 0;j = 0;while (num1 <= num * num) {arr[i][j] = num1++;//右上方向if (derection == 0) {if (i == 0 && j < num - 1) {j++;//到达上边界,右移derection = 1;}else if (j == num - 1) {i++;//到达右边界,下移derection = 1;}else {i--;j++;}}//左下方向else {if (j == 0 && i < num - 1) {i++;//到达左边界,下移derection = 0;}else if (i == num - 1) {j++;//到达下边界,右移derection = 0;}else {i++;j--;}}}for (i = 0; i < num; i++) {for (j = 0; j < num; j++) {printf("%d ", arr[i][j]);}printf("\n");}
}
int main() 
{int num = 0;scanf("%d", &num);snake(num);return 0;
}

头 文 件 与 宏 定 义

• #include <stdio.h> 引 入 输 入 输 出 库
• #define ROW 100 和 #define COL 100 设 定 存 储 矩 阵 的 二 维 数 组 大 小。

snake 函 数

         void snake(int num) 负 责 生 成 矩 阵。内 部 定 义 二 维 数 组 arr 并 初 始 化 为 0，初 始 化 行 索 引 i、列 索 引 j、填 充 数 字 num1（初 始 值 1）和 方 向 标 志 derection（0 为 右 上，1 为 左 下）。​

矩 阵 填 充 循 环

       while (num1 <= num * num) 确 保 矩 阵 完 整 填 充。通 过 derection 判 断 方向，按 右 上 或 左 下 方 向 填 充，遇 边 界 则 改 变 方 向 和 移 动 方 式。​

矩 阵 输 出

嵌 套 for 循 环 遍 历 arr，输 出 矩 阵 元 素 并 换 行 展 示 。​

main 函 数

         定 义 num 存 储 输 入 矩 阵 大 小，用 scanf 获 取 输 入，调 用 snake(num) 生 成 输 出 矩 阵，最 后 return 0 结 束 程 序。

总结

       至 此，关 于 C 语 言 的 探 索 暂 告 一 段 落 ，但 你 的 编 程 征 程 才 刚 刚 启 航。写 代 码 是 与 机 器 深 度 对 话 ，过 程 中 虽 会 在 语 法 、算 法 困 境 里 挣 扎，但 这 些 磨 砺 加 深 了 对 代 码 的 理 解。愿 你 合 上 电 脑 后，灵 感 不 断，在 C 语 言 的 世 界 里 持 续 深 耕，书 写 属 于 自 己 的 编 程 传 奇，下 一 次 开 启 ，定 有 全 新 的 精 彩 等 待。小 编 期 待 重 逢，盼 下 次 阅 读 见 你 们 更 大 进 步，共 赴 代 码 之 约！