⌨

C++基础综合练习：分支、循环与枚举

本节课通过以下题目，对分支结构、循环结构、数组、枚举和整除判断进行综合练习： 1. 查找最大值 2. 最大值和最小值的差 3. 鸡兔同笼问题 4. 素数的个数 5. 求四个数的最大数 6. 找因数

分类 C++ 难度基础阅读 10 分钟 浏览 29 更新 2026-7-15 10:52:57 🌐 所有人可见

登录后记录进度

## 一、本节课学习内容

本节课主要学习以下知识点：

- 最大值和最小值的查找
- 数组的遍历
- `if` 条件判断
- `for` 循环
- 枚举算法
- 取余运算符 `%`
- 因数的判断
- 素数的判断
- 计数器的使用
- `break` 结束循环

---

# 二、查找最大值

## 1. 问题特点

查找最大值，就是从若干个数字中，找出数值最大的一个。

例如：

```text
3 8 2 10 6
````

其中最大值是：

```text
10
```

---

## 2. 基本思路

查找最大值时，需要准备一个变量，用来保存当前找到的最大值。

可以把第一个数字先当作最大值，然后依次与后面的数字比较。

比较过程如下：

```text
当前数字比最大值大
↓
更新最大值
```

关键代码：

```cpp
if (x > maxNum) {
    maxNum = x;
}
```

其中：

* `x` 表示当前正在比较的数字。
* `maxNum` 表示目前找到的最大值。

---

## 3. 最大值的初始化

推荐把最大值初始化为第一个实际输入的数字：

```cpp
int maxNum = a[0];
```

不建议直接写成：

```cpp
int maxNum = 0;
```

原因是输入的数据可能全部是负数。

例如：

```text
-8 -5 -12 -3
```

这些数字中的最大值是 `-3`。

如果把最大值初始化为 `0`，程序可能会错误地认为最大值是 `0`。

因此，最大值通常应该初始化为第一个输入的数字。

---

## 4. 查找最大值的步骤

```text
第一步：把第一个数字当作最大值
第二步：从第二个数字开始比较
第三步：遇到更大的数字就更新最大值
第四步：所有数字比较完成后输出最大值
```

---

# 三、求四个数的最大数

## 1. 问题特点

求四个数的最大数，本质上也是查找最大值。

只不过数字的数量固定为四个。

例如：

```text
3 9 5 7
```

最大值是：

```text
9
```

---

## 2. 基本思路

先把第一个数作为当前最大值，再依次与另外三个数进行比较。

关键代码：

```cpp
int maxNum = a;
```

然后依次判断：

```cpp
if (b > maxNum) {
    maxNum = b;
}
```

其他数字的判断方法相同。

---

## 3. 两种常见处理方式

### 方法一：分别比较

适合数字数量较少，并且数量固定的情况。

例如四个数，可以依次写三个 `if` 判断。

### 方法二：循环比较

适合数字数量较多的情况。

基本形式：

```cpp
for (...) {
    if (x > maxNum) {
        maxNum = x;
    }
}
```

循环方法更容易推广到任意多个数字。

---

# 四、最大值和最小值的差

## 1. 问题特点

这类题目需要完成三个步骤：

1. 找到最大值。
2. 找到最小值。
3. 计算最大值减去最小值。

计算公式：

```text
最大值和最小值的差 = 最大值 - 最小值
```

例如：

```text
8 2 10 6 4
```

其中：

```text
最大值 = 10
最小值 = 2
```

所以：

```text
最大值和最小值的差 = 10 - 2 = 8
```

---

## 2. 查找最大值

关键代码：

```cpp
if (x > maxNum) {
    maxNum = x;
}
```

含义：

> 如果当前数字比最大值大，就更新最大值。

---

## 3. 查找最小值

关键代码：

```cpp
if (x < minNum) {
    minNum = x;
}
```

含义：

> 如果当前数字比最小值小，就更新最小值。

---

## 4. 最大值和最小值的初始化

最大值和最小值都可以初始化为第一个数字：

```cpp
int maxNum = a[0];
int minNum = a[0];
```

这样既可以处理正数，也可以处理负数。

---

## 5. 比较符号的区别

查找最大值使用：

```cpp
>
```

查找最小值使用：

```cpp
<
```

需要注意不要把两个比较符号写反。

---

# 五、数组的遍历

## 1. 什么是遍历

遍历数组，就是按照顺序访问数组中的每一个元素。

例如，一个数组中有 `n` 个数字，它们的下标范围是：

```text
0 到 n - 1
```

常见遍历形式：

```cpp
for (int i = 0; i < n; i++)
```

其中：

* `i` 表示数组下标。
* `a[i]` 表示当前访问的数组元素。

---

## 2. 数组遍历的作用

数组遍历经常用于：

* 输入数组
* 输出数组
* 查找最大值
* 查找最小值
* 统计满足条件的数字
* 判断每个数字的特点

---

## 3. 数组下标范围

如果数组中有 `n` 个元素，则下标分别是：

```text
0、1、2、……、n-1
```

因此循环条件通常写成：

```cpp
i < n
```

不能写成：

```cpp
i <= n
```

因为 `a[n]` 已经超出了数组的有效范围。

---

# 六、鸡兔同笼问题

## 1. 问题特点

鸡兔同笼问题通常会告诉我们：

* 鸡和兔的头的总数。
* 鸡和兔的脚的总数。

要求计算：

* 鸡有多少只。
* 兔有多少只。

已知：

```text
一只鸡有1个头、2只脚
一只兔有1个头、4只脚
```

---

## 2. 数量之间的关系

假设：

```text
鸡的数量为 chicken
兔的数量为 rabbit
总头数为 head
总脚数为 foot
```

因为鸡和兔都有一个头，所以：

```text
鸡的数量 + 兔的数量 = 总头数
```

即：

```text
chicken + rabbit = head
```

如果已经知道兔子的数量，那么鸡的数量就是：

```cpp
chicken = head - rabbit;
```

脚的总数为：

```text
鸡的数量 × 2 + 兔的数量 × 4
```

关键判断条件：

```cpp
chicken * 2 + rabbit * 4 == foot
```

---

## 3. 枚举思想

鸡兔同笼可以使用枚举算法解决。

枚举就是：

> 把所有可能的情况一个一个尝试，再判断哪一种情况符合题目要求。

兔子的数量最少可能是：

```text
0
```

兔子的数量最多可能是：

```text
总头数
```

因此可以依次尝试：

```text
0只兔子
1只兔子
2只兔子
……
总头数只兔子
```

枚举范围：

```cpp
for (int rabbit = 0; rabbit <= head; rabbit++)
```

---

## 4. 鸡兔同笼的解题步骤

```text
第一步：枚举兔子的数量
第二步：根据总头数计算鸡的数量
第三步：计算当前鸡和兔的脚数
第四步：判断脚数是否等于题目给出的总脚数
第五步：如果相等，就找到了答案
```

---

## 5. `break` 的作用

找到正确答案后，可以使用：

```cpp
break;
```

`break` 表示立即结束当前循环。

因为答案已经找到，后面的情况不需要继续尝试。

---

## 6. 鸡兔同笼的合理性判断

鸡兔同笼问题不一定总有答案。

例如：

```text
头数为5，脚数为11
```

鸡和兔的脚数一定是偶数，因此不可能出现11只脚。

常见合理范围：

```text
最少脚数 = 总头数 × 2
最多脚数 = 总头数 × 4
```

总脚数通常还必须是偶数。

---

# 七、枚举算法

## 1. 什么是枚举

枚举是一种非常常见的基础算法。

枚举的核心思想是：

> 在可能的范围内，把每一种情况都尝试一遍。

然后使用 `if` 判断当前情况是否符合条件。

---

## 2. 枚举的基本结构

```cpp
for (int i = 最小可能值; i <= 最大可能值; i++) {
    if (当前情况符合条件) {
        // 处理答案
    }
}
```

---

## 3. 使用枚举的关键

使用枚举时，需要明确三个问题：

### 枚举什么

例如鸡兔同笼中，可以枚举兔子的数量。

### 从哪里开始

兔子的数量最少为 `0`。

### 到哪里结束

兔子的数量最多为总头数。

---

## 4. 常见枚举题目

枚举经常用于：

* 鸡兔同笼
* 找因数
* 判断素数
* 查找满足条件的数字
* 寻找符合条件的组合
* 统计某个区间中的特殊数字

---

# 八、因数

## 1. 因数的概念

如果一个整数能够被另一个整数整除，那么另一个整数就是它的因数。

例如：

```text
6 ÷ 1 = 6
6 ÷ 2 = 3
6 ÷ 3 = 2
6 ÷ 6 = 1
```

所以6的因数有：

```text
1、2、3、6
```

---

## 2. 整除的判断

判断一个数是否能够被另一个数整除，可以使用取余运算符 `%`。

关键代码：

```cpp
a % i == 0
```

含义：

> `a` 除以 `i` 的余数等于0，说明 `a` 可以被 `i` 整除。

因此，`i` 是 `a` 的因数。

---

## 3. 找因数的基本思路

要找出正整数 `a` 的所有因数，可以从 `1` 枚举到 `a`。

枚举范围：

```cpp
for (int i = 1; i <= a; i++)
```

判断条件：

```cpp
if (a % i == 0)
```

满足条件时，说明 `i` 是 `a` 的因数。

---

## 4. 为什么从1枚举到a

一个正整数的因数：

* 不会小于1。
* 不会大于它本身。
* 1一定是它的因数。
* 它本身也一定是它的因数。

因此，最直接的枚举范围是：

```text
1 到 a
```

---

## 5. 因数的特点

对于正整数 `a`：

* 1一定是 `a` 的因数。
* `a` 一定是 `a` 的因数。
* 因数通常成对出现。

例如，12的因数：

```text
1和12
2和6
3和4
```

因为：

```text
1 × 12 = 12
2 × 6 = 12
3 × 4 = 12
```

---

## 6. 从小到大输出因数

如果循环变量从1不断增加：

```cpp
for (int i = 1; i <= a; i++)
```

那么找到的因数也会自然按照从小到大的顺序输出。

---

# 九、取余运算符

## 1. 基本含义

取余运算符写作：

```cpp
%
```

它用于计算两个整数相除后的余数。

例如：

```cpp
10 % 3
```

结果是：

```text
1
```

因为：

```text
10 ÷ 3 = 3……1
```

---

## 2. 判断整除

如果：

```cpp
a % b == 0
```

说明：

```text
a可以被b整除
```

例如：

```cpp
12 % 3 == 0
```

说明12可以被3整除。

---

## 3. 判断因数

```cpp
a % i == 0
```

说明 `i` 是 `a` 的因数。

---

## 4. 判断奇偶

判断偶数：

```cpp
x % 2 == 0
```

判断奇数：

```cpp
x % 2 != 0
```

---

## 5. 判断倍数

判断 `a` 是否为 `b` 的倍数：

```cpp
a % b == 0
```

例如：

```cpp
20 % 5 == 0
```

说明20是5的倍数。

---

# 十、素数

## 1. 素数的概念

素数也叫质数。

一个大于1的正整数，如果只有两个正因数：

```text
1和它本身
```

那么这个数就是素数。

例如：

```text
2、3、5、7、11、13
```

都是素数。

---

## 2. 合数的概念

一个大于1的正整数，如果除了1和它本身以外，还有其他因数，那么它就是合数。

例如，6的因数有：

```text
1、2、3、6
```

因为6除了1和6以外，还有2和3，所以6是合数。

---

## 3. 1不是素数

1只有一个正因数：

```text
1
```

素数必须有两个不同的正因数，所以1不是素数。

因此，在判断素数时需要特别处理：

```cpp
if (x <= 1)
```

小于等于1的数都不是素数。

---

## 4. 判断素数的基本思路

要判断一个数 `x` 是否为素数，可以尝试用其他整数去除它。

如果存在一个数能够整除 `x`，那么 `x` 就不是素数。

关键判断：

```cpp
if (x % i == 0)
```

如果条件成立，说明 `i` 是 `x` 的因数。

---

## 5. 素数判断的枚举范围

最基础的判断方法是从2枚举到 `x-1`：

```cpp
for (int i = 2; i < x; i++)
```

如果中间没有任何数能够整除 `x`，那么 `x` 是素数。

---

## 6. 标记变量

判断素数时，经常使用一个布尔变量记录判断结果。

例如：

```cpp
bool isPrime = true;
```

含义是先假设当前数字是素数。

如果发现它有其他因数，就修改为：

```cpp
isPrime = false;
```

其中：

* `true` 表示是素数。
* `false` 表示不是素数。

---

## 7. 找到因数后立即结束

如果已经找到一个能够整除 `x` 的数字，那么已经能够确定 `x` 不是素数。

此时可以使用：

```cpp
break;
```

结束循环，避免继续进行没有必要的判断。

---

# 十一、统计素数的个数

## 1. 问题特点

统计素数的个数，通常需要完成两层处理：

```text
第一层：枚举区间中的每一个数字
第二层：判断当前数字是否为素数
```

例如，统计某个区间中有多少个素数。

---

## 2. 外层循环

外层循环负责枚举区间中的每一个数字。

例如：

```cpp
for (int x = m; x <= n; x++)
```

其中：

* `m` 表示区间起点。
* `n` 表示区间终点。
* `x` 表示当前正在判断的数字。

---

## 3. 内层循环

内层循环负责判断当前数字 `x` 是否为素数。

例如：

```cpp
for (int i = 2; i < x; i++)
```

如果发现：

```cpp
x % i == 0
```

说明 `x` 不是素数。

---

## 4. 计数器

统计素数数量时，需要准备一个计数器：

```cpp
int count = 0;
```

每找到一个素数，就执行：

```cpp
count++;
```

最后，`count` 中保存的就是素数的个数。

---

## 5. 两层循环的作用

```text
外层循环：依次取出区间中的每一个数字
内层循环：判断当前数字是不是素数
```

这种循环里面还有循环的结构，叫作：

```text
嵌套循环
```

---

# 十二、计数器

## 1. 什么是计数器

计数器是用来统计满足条件的情况有多少个的变量。

通常初始化为：

```cpp
int count = 0;
```

---

## 2. 计数器增加

每找到一个符合条件的数字，就执行：

```cpp
count++;
```

它等价于：

```cpp
count = count + 1;
```

---

## 3. 计数器常见用途

计数器可以用于统计：

* 素数的个数
* 偶数的个数
* 奇数的个数
* 正数的个数
* 负数的个数
* 满足某个条件的学生人数
* 某个数字出现的次数

---

## 4. 计数器的注意事项

计数器通常需要在循环开始前初始化：

```cpp
int count = 0;
```

不能把初始化写在循环内部，否则每次循环都会重新变成0。

错误思路：

```cpp
for (...) {
    int count = 0;
}
```

这样无法正确累计数量。

---

# 十三、标记变量

## 1. 什么是标记变量

标记变量用来记录某个状态是否成立。

例如，判断一个数是不是素数时，可以使用：

```cpp
bool isPrime = true;
```

---

## 2. 布尔类型

`bool` 类型只有两种常见取值：

```cpp
true
false
```

其中：

* `true` 表示成立。
* `false` 表示不成立。

---

## 3. 常见使用方式

先假设条件成立：

```cpp
bool isPrime = true;
```

如果发现不符合条件：

```cpp
isPrime = false;
```

最后再根据标记变量判断结果。

---

# 十四、`break`语句

## 1. 基本作用

`break` 用于立即结束当前循环。

关键代码：

```cpp
break;
```

---

## 2. 常见使用场景

### 找到答案后结束

例如鸡兔同笼已经找到正确的鸡和兔数量，不需要继续枚举。

### 判断素数时发现因数

只要找到一个其他因数，就能够确定当前数字不是素数，不需要继续判断。

---

## 3. 注意事项

`break` 只会结束它所在的那一层循环。

如果有两层循环，`break` 通常只结束内层循环，不会自动结束外层循环。

---

# 十五、常见错误

## 1. 最大值初始化为0

错误写法：

```cpp
int maxNum = 0;
```

当所有输入数字都是负数时，可能得到错误答案。

推荐写法：

```cpp
int maxNum = a[0];
```

---

## 2. 最小值初始化为0

错误写法：

```cpp
int minNum = 0;
```

当所有输入数字都是正数时，最小值可能一直保持为0。

推荐写法：

```cpp
int minNum = a[0];
```

---

## 3. 最大值和最小值比较符号写反

查找最大值：

```cpp
x > maxNum
```

查找最小值：

```cpp
x < minNum
```

---

## 4. 数组下标越界

数组中有 `n` 个元素时，有效下标是：

```text
0 到 n-1
```

正确循环条件：

```cpp
i < n
```

错误循环条件：

```cpp
i <= n
```

---

## 5. 忘记1不是素数

判断素数时，需要先处理：

```cpp
x <= 1
```

1不是素数，0和负数也不是素数。

---

## 6. 整除条件写反

判断 `i` 是否为 `a` 的因数，应写成：

```cpp
a % i == 0
```

不能写成：

```cpp
i % a == 0
```

---

## 7. 找因数时从0开始

错误：

```cpp
for (int i = 0; ...)
```

因为任何数字都不能除以0，这样可能导致运行错误。

正确起点应该是：

```cpp
i = 1
```

---

## 8. 计数器没有初始化

错误：

```cpp
int count;
```

变量没有初始化时，里面可能是一个不确定的值。

正确：

```cpp
int count = 0;
```

---

## 9. 在循环内部初始化计数器

如果每次循环都重新把计数器设置为0，就无法累计结果。

计数器应该放在循环外面初始化。

---

## 10. 输出格式错误

程序结果正确，但输出格式不符合题目要求，也可能无法通过。

需要认真查看：

* 是否需要空格
* 是否需要换行
* 输出几个数字
* 输出顺序是什么
* 是否需要输出提示文字

在线评测题一般不要额外输出题目没有要求的提示文字。

---

# 十六、核心代码整理

## 1. 更新最大值

```cpp
if (x > maxNum) {
    maxNum = x;
}
```

---

## 2. 更新最小值

```cpp
if (x < minNum) {
    minNum = x;
}
```

---

## 3. 判断整除

```cpp
a % i == 0
```

---

## 4. 判断偶数

```cpp
x % 2 == 0
```

---

## 5. 判断奇数

```cpp
x % 2 != 0
```

---

## 6. 计数器增加

```cpp
count++;
```

---

## 7. 标记为不是素数

```cpp
isPrime = false;
```

---

## 8. 结束循环

```cpp
break;
```

---

## 9. 数组遍历

```cpp
for (int i = 0; i < n; i++)
```

---

## 10. 找因数的循环范围

```cpp
for (int i = 1; i <= a; i++)
```

---

## 11. 鸡兔同笼的数量关系

```cpp
chicken = head - rabbit;
```

---

## 12. 鸡兔同笼的脚数判断

```cpp
chicken * 2 + rabbit * 4 == foot
```

---

# 十七、不同题目的解题思路

## 1. 查找最大值

```text
先确定初始最大值
依次比较其他数字
遇到更大的数字就更新
```

---

## 2. 查找最小值

```text
先确定初始最小值
依次比较其他数字
遇到更小的数字就更新
```

---

## 3. 最大值与最小值的差

```text
同时查找最大值和最小值
最后计算最大值减去最小值
```

---

## 4. 鸡兔同笼

```text
枚举兔子的数量
计算鸡的数量
计算脚的总数
判断是否符合条件
```

---

## 5. 找因数

```text
从1枚举到这个数本身
判断是否能够整除
能够整除的数字就是因数
```

---

## 6. 判断素数

```text
先排除小于等于1的数字
从2开始寻找其他因数
存在其他因数则不是素数
不存在其他因数则是素数
```

---

## 7. 统计素数个数

```text
枚举区间中的每一个数字
判断当前数字是不是素数
如果是素数，计数器增加1
```

---

# 十八、做题步骤

## 第一步：分析输入

需要明确：

* 输入几个数字？
* 是否先输入数字的个数？
* 输入的是一个数还是一个区间？
* 是否需要使用数组？

---

## 第二步：分析输出

需要明确：

* 输出最大值还是最小值？
* 输出具体数字还是数量？
* 输出鸡在前还是兔在前？
* 输出是否需要空格或换行？

---

## 第三步：确定循环范围

例如：

找因数：

```text
从1到这个数本身
```

鸡兔同笼：

```text
兔子数量从0到总头数
```

统计区间内素数：

```text
从区间起点到区间终点
```

---

## 第四步：确定判断条件

最大值：

```cpp
x > maxNum
```

最小值：

```cpp
x < minNum
```

因数：

```cpp
a % i == 0
```

鸡兔脚数：

```cpp
chicken * 2 + rabbit * 4 == foot
```

---

## 第五步：确定是否需要辅助变量

常见辅助变量包括：

```text
maxNum：保存最大值
minNum：保存最小值
count：统计数量
isPrime：记录是否为素数
```

---

## 第六步：检查边界

重点检查：

* 循环从哪里开始。
* 循环到哪里结束。
* 使用 `<` 还是 `<=`。
* 数组下标是否越界。
* 是否考虑1不是素数。
* 是否可能出现负数。

---

# 十九、本节课知识结构

```text
分支、循环与枚举综合练习
│
├── 最值问题
│   ├── 查找最大值
│   ├── 查找最小值
│   └── 最大值减最小值
│
├── 数组遍历
│   ├── 下标从0开始
│   ├── 有效下标到n-1
│   └── 使用for循环依次访问
│
├── 枚举算法
│   ├── 确定枚举对象
│   ├── 确定枚举范围
│   └── 使用if判断是否符合条件
│
├── 整除问题
│   ├── 取余运算符%
│   ├── 判断因数
│   ├── 判断奇偶
│   └── 判断倍数
│
├── 素数问题
│   ├── 1不是素数
│   ├── 查找其他因数
│   ├── 使用标记变量
│   └── 使用计数器统计数量
│
└── 循环控制
    ├── count++累计数量
    └── break结束循环
```

---

# 二十、本节课小结

本节课重点复习了最大值、最小值、枚举、因数和素数等常见问题。

需要重点掌握以下内容：

1. 查找最大值时，遇到更大的数字就更新最大值。
2. 查找最小值时，遇到更小的数字就更新最小值。
3. 最大值和最小值通常初始化为第一个实际输入的数字。
4. 枚举就是在可能范围内依次尝试每一种情况。
5. `%` 可以判断一个数是否能够被另一个数整除。
6. 找因数时，需要从1开始枚举，不能从0开始。
7. 素数是大于1并且只有1和它本身两个正因数的整数。
8. 1不是素数。
9. `count++` 可以统计满足条件的数量。
10. `break` 可以在找到答案后提前结束循环。

本节课最重要的思想是：

> 使用循环依次检查每一个数字或每一种情况，再使用 `if` 判断当前情况是否满足题目要求。

学习交流

公开阅读不需要登录登录后可以评论、收藏并同步学习进度。登录

暂时还没有评论。