Appearance
第4章 流程图
🎯 本章学习目标
学完本章，你将能够：
- ✅ 说出流程图的定义和作用
- ✅ 认识六种常用符号（起止框、处理框、判断框、输入输出框、流程线、连接点）
- ✅ 记住每种符号的形状和含义
- ✅ 掌握三种基本结构的流程图（顺序、分支、循环）
- ✅ 区分当型循环（while）与直到型循环（do-while）的流程图
- ✅ 学会阅读流程图并写出输出结果
- ✅ 能用变量跟踪表法解流程图阅读题
- ✅ 理解流程图与代码的对应关系
- ✅ 能将简单代码转换成流程图
- ✅ 掌握流程图循环次数的计算方法
🗺️ 本章知识图谱
流程图
├── 基本概念
│ ├── 定义：用图形符号+流程线描述算法
│ ├── 作用：直观清晰、无歧义
│ └── 与代码的关系：可互相转换
├── 六种符号 ⭐⭐⭐
│ ├── 起止框：圆角矩形（开始/结束）
│ ├── 处理框：矩形（赋值/计算）
│ ├── 判断框：菱形（一进两出，是/否）
│ ├── 输入输出框：平行四边形
│ ├── 流程线：带箭头的线
│ └── 连接点：圆圈（跨页/交叉连接）
├── 三种基本结构
│ ├── 顺序结构：从上到下，一进一出
│ ├── 分支结构：菱形判断，二选一
│ │ ├── 单分支（if）
│ │ └── 双分支（if-else）
│ └── 循环结构
│ ├── 当型循环：先判断后执行（while）
│ └── 直到型循环：先执行后判断（do-while）
├── 流程图阅读题
│ ├── 三步法：找入口→盯变量→判分支
│ ├── 变量跟踪表：逐圈记录变量值
│ └── 常见题型：求和、计数、找最值
└── 代码↔流程图转换
├── 矩形 → 赋值/计算语句
├── 菱形 → if 判断
├── 当型回路 → while 循环
└── 直到型回路 → do-while 循环一、什么是流程图
1.1 流程图的定义
流程图（Flow Chart） 是用规定的图形符号加上流程线（箭头） 来描述算法的图形化工具。它把"先做什么、再做什么、遇到条件怎么分支、什么时候重复"全部画成一张图，让人一眼就能看清算法的执行过程。
生活类比：商场里的"导购图"、App 下单后的"物流进度条"、餐厅出餐的"取餐叫号流程"，本质都是流程图——用图形把步骤和走向画出来。
1.2 为什么要用流程图？
| 对比项 | 自然语言（用文字描述） | 流程图（用图形描述） |
|---|---|---|
| 直观程度 | 啰嗦，要读完整段话 | 一目了然，箭头指向就是执行顺序 |
| 严谨程度 | 容易有二义性（"回到上面"到底回到哪？） | 符号含义统一规定，无歧义 |
| 分支/循环 | 描述起来绕口 | 菱形分叉、箭头回环，结构清晰 |
| 交流与调试 | 口说无凭 | 团队讨论、梳理思路的标准"语言" |
易错点 ⚠️： 流程图是算法的描述工具，不是编程语言。它不能被计算机直接运行，但可以很方便地"翻译"成 C++ 代码——这正是本章第四节要练的功夫。
二、流程图的六种常用符号 ⭐⭐⭐⭐⭐
流程图的符号是全国统一规定的，形状和含义一一对应，必须背熟：
| 符号名称 | 形状 | ASCII 示意 | 含义与作用 | 入口/出口 |
|---|---|---|---|---|
| 起止框（终端框） | 圆角矩形 | ( 开始 ) | 表示算法的开始和结束。一个流程图有且仅有一个开始，可以有一个或多个结束 | 一进一出 |
| 处理框 | 矩形 | [ x ← x+1 ] | 表示赋值、计算等处理操作 | 一进一出 |
| 判断框 | 菱形 | < x > 0 ? > | 表示条件判断，根据条件是否成立决定走哪条路 | 一进两出（是/否） |
| 输入/输出框 | 平行四边形 | / 输入 n / | 表示输入数据或输出结果 | 一进一出 |
| 流程线 | 带箭头的线 | ↓ → ↑ ← | 表示执行方向，箭头指向下一步 | — |
| 连接点 | 圆圈 | ( ① ) | 流程图较大、流程线需要跨页或交叉时，用相同编号的圆圈把断开的地方接上 | 成对出现 |
六种符号全家福：
( 开 始 ) ← 起止框：圆角矩形（终端框）
|
/ 输入 n / ← 输入/输出框：平行四边形
|
[ s ← 0 ] ← 处理框：矩形（赋值、计算）
|
< n > 0 ? > ← 判断框：菱形（一个入口，"是/否"两个出口）
/ \
是/ \否
| |
( ① ) / 输出 s / ← 连接点：圆圈（① 两处编号相同，表示流程在此相接）
| |
... ( 结 束 )高频考点 🔥：符号辨认与出入口数量
- 菱形 = 判断框，这是考得最多的一个形状。判断框有一个入口、两个出口，两个出口必须分别标注"是/否"（或 Y/N、成立/不成立）。
- 起止框、处理框、输入/输出框都是一进一出；流程线不是"框"，只负责指路。
- 赋值和计算用矩形处理框，输入输出用平行四边形——千万不要把"输入 n"画成矩形。
- 连接点（圆圈）通常是成对出现、编号相同的，作用相当于电路图里的"接线柱"。
易错点 ⚠️：
- 判断框的出口不能只有一个，也不能两个出口都标"是"；条件成立走"是"、不成立走"否"，缺一不可。
- "圆角矩形表示开始结束"——别把圆角矩形当成处理框，处理框是直角矩形。
- 一个流程图只能有一个开始框，但结束框可以有多个（比如分支结构中两条路各自结束）。
三、三种基本结构的流程图 ⭐⭐⭐⭐
任何复杂的算法，流程图都由三种基本结构搭建而成：顺序结构、分支结构、循环结构。它们恰好对应我们学过的三种程序结构。
3.1 顺序结构：一步接一步，直线执行
顺序结构最简单：从上到下，每个框执行一次，没有分叉也没有回头。
( 开 始 )
|
/ 输入 a /
/ 输入 b /
|
[ c ← a + b ]
|
/ 输出 c /
|
( 结 束 )对应代码：
cpp
int a, b;
cin >> a >> b; // 输入
int c = a + b; // 处理（计算）
cout << c << endl; // 输出3.2 分支结构（选择结构）：菱形判断，二选一
分支结构对应 if-else 语句：遇到菱形判断框，条件成立走"是"支路，不成立走"否"支路，两条支路最后汇合（或各自结束）。
( 开 始 )
|
/ 输入 n /
|
< n >= 60 ? >
/ \
是/ \否
| |
/ 输出"及格" / / 输出"不及格" /
\ /
\ /
( 结 束 )对应代码：
cpp
if (n >= 60)
cout << "及格" << endl; // "是"支路
else
cout << "不及格" << endl; // "否"支路高频考点 🔥： 看到菱形就找"是/否"两个箭头分别通向哪里——阅读题中分支结构的考点就是"代入当前变量值，判断条件真假，选对支路"。
3.3 循环结构：箭头绕回来，重复执行
循环结构对应 while / do-while 语句，流程线会绕回到前面的判断框，形成"回路"。循环分两种：
① 当型循环（先判断，后执行）——对应 while：先判断条件，条件成立才执行循环体；条件一次都不成立，循环体一次也不执行。
( 开 始 )
|
[ s ← 0, i ← 1 ]
|
+------->+
| < i <= 100 ? >----否----> / 输出 s / ----> ( 结束 )
| |是
| [ s ← s + i ]
| [ i ← i + 1 ]
+--------+
（流程线绕回判断框：先判断，再决定要不要执行循环体）② 直到型循环（do-while）（先执行，后判断）——对应 do-while：先执行一次循环体，再判断条件；条件成立就回去继续，不成立才退出。循环体至少执行一次。
( 开 始 )
|
[ s ← 0, i ← 1 ]
|
+--->[ s ← s + i ]
| [ i ← i + 1 ]
| |
+---< i <= 100 ? >---是---+ （箭头绕回处理框：先执行，再判断）
|否
/ 输出 s /
|
( 结 束 )两种循环对比：
| 对比项 | 当型循环（while） | 直到型循环（do-while） |
|---|---|---|
| 判断时机 | 先判断后执行 | 先执行后判断 |
| 循环体最少执行 | 0 次（条件一开始就不成立） | 至少 1 次 |
| 流程图特征 | 箭头回到判断框之前，判断框在回路最上方 | 判断框在回路最下方，"否"出口才离开 |
| C++ 对应 | while (条件) { ... } | do { ... } while (条件); |
易错点 ⚠️：
- 判断两种循环就看判断框的位置：菱形在循环体前面是当型，在循环体后面是直到型。
- 当型循环可能一次都不执行；直到型循环至少执行一次。这是判断题高频考点。
- 循环"转圈"时，循环变量必须在循环体内被更新（如
i ← i+1），否则条件永远成立，变成死循环——流程图阅读题中看到变量不更新，要立刻警觉。
四、流程图与代码的互相转换 ⭐⭐⭐
会画图、会读图，还要会"翻译"。转换规则其实就是符号对语句：
| 流程图元素 | C++ |
|---|---|
| 平行四边形"输入" | cin >> x; |
| 平行四边形"输出" | cout << x; |
矩形处理框 x ← 表达式 | x = 表达式; |
| 菱形 + "是/否"两分支 | if (条件) {...} else {...} |
| 当型回路（先判断） | while (条件) {...} |
| 直到型回路（先执行） | do {...} while (条件); |
完整示例：求 1+2+3+…+100 的和（当型循环）
流程图：
[ s ← 0, i ← 1 ]
|
+<-----+
| < i <= 100 ? >---否---> / 输出 s /
| |是
| [ s ← s + i ]
| [ i ← i + 1 ]
+------+翻译成代码：
cpp
#include <iostream>
using namespace std;
int main() {
int s = 0, i = 1; // 处理框：初始化
while (i <= 100) { // 判断框：当型循环条件
s = s + i; // 处理框：累加
i = i + 1; // 处理框：循环变量更新
}
cout << s << endl; // 输出框
return 0;
}
// 输出：5050高频考点 🔥： 反过来"读代码画流程图"也要会：顺序语句一路向下画矩形；
if画菱形分两叉；while画一个菱形加一条绕回去的箭头。做题时建议先在草稿纸上把循环结构画成流程图再追变量，比直接盯代码不容易错。
五、流程图阅读题解题三步法 🔥🔥🔥
二级选择题中的流程图题，套路高度固定：给一张流程图（有时给输入值），问输出结果。按下面三步做，稳拿分：
第一步：找入口。 从"开始"框出发，顺着箭头方向走，不要跳框。
第二步：盯变量。 在草稿纸上列出流程图中出现的所有变量，每经过一个处理框（矩形），就立刻更新变量的值。
第三步：判分支。 遇到菱形判断框，把当前变量值代入条件：成立走"是"，不成立走"否"；遇到回路就一圈一圈走，直到走"否"出口离开循环。
核心工具是一张变量变化表：把每一圈循环后各变量的值逐行记录下来，输出结果自然浮现。切忌"用眼睛看、凭感觉猜"——流程图题的错误选项，几乎都是给"懒得动笔"的同学准备的。
六、📝 实战练习
练习题 1（程序阅读题）
题目： 阅读下面的流程图，当输入 n = 5 时，输出的结果是（ ）
( 开 始 )
|
/ 输入 n /
|
[ s ← 0, i ← 1 ]
|
+------->+
| < i <= n ? >----否----> / 输出 s / ----> ( 结束 )
| |是
| [ s ← s + i ]
| [ i ← i + 1 ]
+--------+A. 10 B. 15 C. 21 D. 5
🔑 点击查看答案与解析
答案： B
解析： 列变量变化表，逐圈跟踪：
| 圈数 | 判断 i<=5 | s 的值 | i 的值 |
|---|---|---|---|
| 初始 | — | s=0 | i=1 |
| 第1圈 | 1≤5 是 | s=0+1=1 | i=2 |
| 第2圈 | 2≤5 是 | s=1+2=3 | i=3 |
| 第3圈 | 3≤5 是 | s=3+3=6 | i=4 |
| 第4圈 | 4≤5 是 | s=6+4=10 | i=5 |
| 第5圈 | 5≤5 是 | s=10+5=15 | i=6 |
| 第6次判断 | 6≤5 否 | 退出循环，输出 s=15 | — |
即 s = 1+2+3+4+5 = 15，选 B。（陷阱项 C 的 21 是 n=6 的结果，A 的 10 是 1+2+3+4，都是常见的"少转/多转一圈"错误。）
对应代码：
cpp
#include <iostream>
using namespace std;
int main() {
int n;
cin >> n; // 输入 n
int s = 0, i = 1; // 初始化累加器 s 和循环变量 i
while (i <= n) { // 当型循环：先判断 i<=n
s = s + i; // 累加
i = i + 1; // 循环变量加 1
}
cout << s << endl; // 输出 15
return 0;
}练习题 2（判断题）
题目： 阅读下面的流程图，当输入 n = 7 时，输出的内容是（ ）
( 开 始 )
|
/ 输入 n /
|
< n % 2 == 0 ? >
/ \
是/ \否
| |
/ 输出"偶数" / / 输出"奇数" /
\ /
\ /
( 结 束 )A. 偶数 B. 奇数 C. 0 D. 1
🔑 点击查看答案与解析
答案： B
解析： 代入 n = 7：7 % 2 == 1，条件 n % 2 == 0 不成立，走"否"支路，输出"奇数"，选 B。若输入 n = 8，则 8 % 2 == 0，走"是"支路输出"偶数"。
考点：
%是取余运算，除以 2 余 0 为偶数、余 1 为奇数；菱形判断后两条支路互斥，只会走其中一条。
对应代码：
cpp
#include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
if (n % 2 == 0) // 判断框条件
cout << "偶数" << endl; // "是"支路
else
cout << "奇数" << endl; // "否"支路
return 0;
}练习题 3（程序阅读题）
题目： 阅读下面的流程图，依次输入 n = 5，五个数为 3、8、2、9、4，输出的结果是（ ）
( 开 始 )
|
/ 输入 n /
|
[ mx ← 0, i ← 1 ]
|
+<-----+
| < i <= n ? >---否---> / 输出 mx / ---> ( 结束 )
| |是
| / 输入 x /
| |
| < x > mx ? >---是---> [ mx ← x ]
| |否 |
| | |
| +<-----------------+
| |
| [ i ← i + 1 ]
+------+A. 4 B. 8 C. 9 D. 26
🔑 点击查看答案与解析
答案： C
解析： mx 是"打擂主"，初始为 0；每读入一个数 x，若 x 比当前 mx 大就替换它。逐圈跟踪：
| 圈数 i | 读入 x | 判断 x>mx | mx 变化 |
|---|---|---|---|
| 初始 | — | — | mx=0 |
| i=1 | 3 | 3>0 是 | mx=3 |
| i=2 | 8 | 8>3 是 | mx=8 |
| i=3 | 2 | 2>8 否 | mx=8（不变） |
| i=4 | 9 | 9>8 是 | mx=9 |
| i=5 | 4 | 4>9 否 | mx=9（不变） |
| i=6 | — | 6≤5 否，退出 | 输出 mx=9 |
选 C。（陷阱项 D 的 26 是把五个数相加的结果，那是"求和"流程图的套路，不是求最大值。）
对应代码：
cpp
#include <iostream>
using namespace std;
int main() {
int n;
cin >> n; // 数据个数
int mx = 0; // 擂主初始为 0
for (int i = 1; i <= n; i++) {
int x;
cin >> x; // 读入一个数
if (x > mx) { // 菱形判断：新数更大？
mx = x; // 替换擂主
}
}
cout << mx << endl; // 输出 9
return 0;
}练习题 4（判断题）
题目： 阅读下面的流程图（注意判断框在循环体下方），当输入 n = 10 时，输出的结果是（ ）
( 开 始 )
|
/ 输入 n /
|
[ cnt ← 0, i ← 1 ]
|
+--->< i % 2 == 0 ? >---是---> [ cnt ← cnt + 1 ]
| |否 |
| +-----------------------+
| |
| [ i ← i + 1 ]
| |
+------< i <= n ? >---是---+ （箭头绕回上方菱形）
|否
/ 输出 cnt /
|
( 结 束 )A. 4 B. 5 C. 10 D. 6
🔑 点击查看答案与解析
答案： B
解析： 这是直到型循环：先执行循环体（判断 i 是否为偶数、是则 cnt 加 1，然后 i 加 1），再判断 i <= n 决定是否继续。统计的是 1～10 中偶数的个数：2、4、6、8、10，共 5 个，选 B。
验证几个关键节点：i=2 时 cnt 变 1；i=10 时是偶数，cnt 变 5，随后 i 变成 11，判断 11≤10 不成立，退出，输出 5。
易错点 ⚠️： 若把这张图误读成当型循环，在 n=0 这类边界上就会出错——直到型循环的循环体至少执行一次。阅读时先看判断框位置定类型，再追变量。
对应代码（do-while）：
cpp
#include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int cnt = 0, i = 1;
do {
if (i % 2 == 0) cnt++; // 循环体：偶数则计数
i++;
} while (i <= n); // 直到型：先执行，后判断
cout << cnt << endl; // n=10 时输出 5
return 0;
}练习题 5（判断题）
题目： 判断下列说法是否正确：
① 流程图中，菱形框表示输入输出操作。（ ）
② 判断框有一个入口和两个出口，两个出口应分别标注"是"和"否"。（ ）
③ 当型循环的特点是先执行循环体，再判断条件，因此循环体至少执行一次。（ ）
④ 圆角矩形（终端框）表示算法的开始和结束。（ ）
⑤ 流程图中可以没有流程线，只要图形画全即可。（ ）
🔑 点击查看答案与解析
答案： ① ❌ ② ✅ ③ ❌ ④ ✅ ⑤ ❌
解析：
- ① ❌：菱形是判断框；输入输出用平行四边形。
- ② ✅：判断框一进两出，"是/否"标注齐全。
- ③ ❌：说反了——**直到型（do-while）**才是先执行后判断、至少执行一次；当型（while）是先判断后执行，可能一次都不执行。
- ④ ✅：圆角矩形即起止框（终端框）。
- ⑤ ❌：流程线（箭头）规定执行顺序，没有箭头就无法判断先后走向，是流程图不可缺少的组成部分。
练习题 6（程序阅读题）
题目： 阅读下面的流程图，当输入 n = 4 时，输出的结果是（ ）
( 开 始 )
|
/ 输入 n /
|
[ f ← 1, i ← 1 ]
|
+------->+
| < i <= n ? >----否----> / 输出 f / ----> ( 结束 )
| |是
| [ f ← f * i ]
| [ i ← i + 1 ]
+--------+A. 4 B. 10 C. 24 D. 120
🔑 点击查看答案与解析
答案： C
解析： 这是求阶乘 n! 的流程图（f = 1×2×3×…×n）。列变量跟踪表：
| 圈数 | 判断 i<=4 | f 的值 | i 的值 |
|---|---|---|---|
| 初始 | — | f=1 | i=1 |
| 第1圈 | 1≤4 是 | f=1×1=1 | i=2 |
| 第2圈 | 2≤4 是 | f=1×2=2 | i=3 |
| 第3圈 | 3≤4 是 | f=2×3=6 | i=4 |
| 第4圈 | 4≤4 是 | f=6×4=24 | i=5 |
| 第5次判断 | 5≤4 否 | 退出循环，输出 f=24 | — |
4! = 24，选 C。
🔥 注意与累加的区别：累加器初始化为 0（
s=0），累乘器初始化为 1（f=1）。如果累乘器初始化为 0，那结果永远是 0——这是判断题的经典陷阱。
练习题 7（判断题）
题目： 下列关于流程图循环结构的说法，正确的是（ ）
① 当型循环的判断框在循环体上方，直到型循环的判断框在循环体下方 ② 当型循环至少执行一次循环体 ③ 直到型循环的特点是"先判断，后执行" ④ 判断循环类型的关键是看判断框的位置
A. ①② B. ②③ C. ①④ D. ③④
🔑 点击查看答案与解析
答案： C
解析：
- ① 正确 ✅：当型循环先判断后执行，判断框在上方；直到型循环先执行后判断，判断框在下方。看判断框位置是区分两种循环的最直观方法；
- ② 错误 ❌：当型循环（while）可能一次都不执行（条件一开始就不成立时）；至少执行一次是直到型循环（do-while）的特点；
- ③ 错误 ❌：说反了——直到型是"先执行，后判断"，当型才是"先判断，后执行"；
- ④ 正确 ✅：判断框位置决定了循环类型——判断框在循环体前面 = 当型，在后面 = 直到型。
选 C（①④）。
💡 记忆口诀："当在上、直在下；当0次、直1次"——当型判断在上方、最少0次；直到型判断在下方、最少1次。
练习题 8（判断题）
题目： 阅读下面的 C++ 代码，判断其对应的流程图结构最准确的描述是（ ）
cpp
if (a > 0) {
if (b > 0)
cout << "A";
else
cout << "B";
} else {
cout << "C";
}A. 一个判断框，两个分支 B. 两个判断框嵌套（外层判断 a>0，内层判断 b>0） C. 三个判断框并列 D. 一个循环结构加一个分支结构
🔑 点击查看答案与解析
答案： B
解析： 这是典型的嵌套分支结构——外层 if 判断 a>0，成立后进入内层，内层又有一个 if-else 判断 b>0。对应的流程图有两个菱形判断框嵌套：外层判断 a>0，"是"支路内再有一个判断 b>0 的菱形；外层"否"支路直接输出 C。
流程图示意：
( 开始 )
|
< a > 0 ? >
/ \
是/ \否
| |
< b > 0 ? > / 输出C /
/ \ |
是/ \否 |
| | |
/ 输出A / / 输出B / |
\ / |
\ / |
( 结 束 ) <--+🔥 高频考点：嵌套 if 对应嵌套的菱形判断框。读嵌套流程图要从外到内逐层判断，画流程图时注意每个菱形都有"是/否"两个出口。
七、📊 考点总结表
| 考点 | 重要程度 | 出题形式 |
|---|---|---|
| 流程图的概念与作用 | ⭐⭐ | 判断/选择 |
| 六种符号辨认（起止/处理/判断/输入输出/流程线/连接点） | ⭐⭐⭐⭐ | 选择/判断 |
| 判断框菱形、一进两出、是/否标注 | ⭐⭐⭐⭐⭐ | 选择/判断 |
| 顺序、分支、循环三种结构的画法 | ⭐⭐⭐⭐ | 选择/填空 |
| 当型 while 与直到型 do-while 的区别（判断位置、最少执行次数） | ⭐⭐⭐⭐⭐ | 选择/判断 |
| 流程图阅读：追踪变量、写输出结果 | ⭐⭐⭐⭐⭐ | 选择高频 |
| 流程图与 C++ 代码互相转换 | ⭐⭐⭐ | 选择/编程辅助 |
| 变量变化表解题法 | ⭐⭐⭐⭐⭐ | 所有阅读题 |
⭐ 必背速记卡
┌─────────────────────────────────────────────────────┐
│ 1. 流程图六符号：起止、处理、判断、输入输出、流程线、连接点│
│ 2. 圆角矩形=起止框（开始/结束），一个开始可多个结束 │
│ 3. 矩形=处理框（赋值计算），一进一出 │
│ 4. 菱形=判断框（条件判断），一进两出（是/否） │
│ 5. 平行四边形=输入输出框 │
│ 6. 圆圈=连接点，成对出现编号相同 │
│ 7. 三种基本结构：顺序、分支、循环 │
│ 8. 顺序结构：从上到下直线走，没有分支也没有回头 │
│ 9. 分支结构：菱形判断二选一 │
│ 10. 当型循环（while）：先判断后执行，最少0次 │
│ 11. 直到型循环（do-while）：先执行后判断，最少1次 │
│ 12. 判断循环类型看菱形位置：在上=当型，在下=直到型 │
│ 13. 阅读题三步法：找入口→盯变量→判分支 │
│ 14. 变量跟踪表是神器：每圈更新值，答案自然出 │
│ 15. 循环体内必须更新变量，否则会死循环 │
└─────────────────────────────────────────────────────┘