在编程入门阶段，「猜数字游戏」是绕不开的经典案例 —— 它不仅能帮我们巩固循环、分支、结构体等基础语法，更藏着算法世界里「高效缩小问题范围」的核心思想。本文将以一份可直接运行的 AI 生成 C++ 猜数字游戏为切入点，先拆解游戏代码逻辑，再自然过渡到二分查找算法的原理、实现与应用，带初学者一步步理解「每次砍半」的高效奥秘。
观前提示：本文使用AI写作
一、入门实践：可直接运行的猜数字游戏
在讲算法前，我们先从的代码入手。以下是完整的 C++ 猜数字游戏代码（已优化可读性，支持多难度、分数记录，可直接复制到 Dev-C++/VS 运行）：
#include <iostream>
#include <cstdlib>
#include <ctime>
#include <string>
#include <iomanip>
using namespace std;
// 1. 难度结构体：封装难度相关属性（高内聚设计）
struct Difficulty {
string name; // 难度名称（如"简单"）
int minNum; // 随机数最小值
int maxNum; // 随机数最大值
int maxAttempts; // 最大猜测次数
int basePoints; // 基础分数（剩余次数越多得分越高）
};
// 2. 显示游戏规则（输入0可随时调用）
void showHelp() {
cout << "\n===== 游戏帮助 =====" << endl;
cout << "1. 按所选难度生成1个随机数，需在限定次数内猜出" << endl;
cout << "2. 每次猜测后，系统提示「太大」或「太小」" << endl;
cout << "3. 剩余次数越多，得分越高（得分=基础分×剩余次数）" << endl;
cout << "4. 游戏中输入'0'可重新查看帮助" << endl;
cout << "=====================\n" << endl;
}
// 3. 难度选择：循环校验输入合法性
int chooseDifficulty(Difficulty difficulties[], int count) {
cout << "\n请选择难度级别:" << endl;
// 遍历输出所有难度选项
for (int i = 0; i < count; i++) {
cout << i + 1 << ". " << difficulties[i].name
<< " | 范围: " << difficulties[i].minNum << "-" << difficulties[i].maxNum
<< " | 次数: " << difficulties[i].maxAttempts
<< " | 基础分: " << difficulties[i].basePoints << endl;
}
int choice;
// 输入不合法则重新输入（循环校验）
do {
cout << "请输入难度编号(1-" << count << "): ";
cin >> choice;
} while (choice < 1 || choice > count);
return choice - 1; // 转换为数组索引（0开始）
}
// 4. 核心游戏逻辑：一轮猜数字流程
int playRound(Difficulty diff) {
// 生成[minNum, maxNum]区间的随机数（随机数种子在main中初始化）
int secretNumber = rand() % (diff.maxNum - diff.minNum + 1) + diff.minNum;
int guess; // 玩家猜测的数字
int attempts = 0; // 已尝试次数
cout << "\n===== 新游戏开始 =====" << endl;
cout << "当前难度: " << diff.name << endl;
cout << "目标数字范围: " << diff.minNum << "~" << diff.maxNum << endl;
cout << "剩余猜测次数: " << diff.maxAttempts << endl;
// 猜测循环：未用完次数则持续猜
while (attempts < diff.maxAttempts) {
attempts++;
cout << "\n第" << attempts << "次猜测（剩余" << diff.maxAttempts - attempts << "次）: ";
cin >> guess;
// 特殊逻辑：输入0查看帮助（不消耗次数）
if (guess == 0) {
showHelp();
attempts--; // 回退次数，避免消耗
continue;
}
// 输入合法性校验：超出范围则重新输入
if (guess < diff.minNum || guess > diff.maxNum) {
cout << "输入无效！请输入" << diff.minNum << "~" << diff.maxNum << "之间的数字" << endl;
attempts--;
continue;
}
// 核心判断：根据猜测结果缩小范围（衔接二分的关键）
if (guess > secretNumber) {
cout << "太大了！下次猜小一点" << endl;
} else if (guess < secretNumber) {
cout << "太小了！下次猜大一点" << endl;
} else {
// 猜对计算得分：剩余次数越多得分越高
int score = diff.basePoints * (diff.maxAttempts - attempts + 1);
cout << "\n恭喜猜对！答案是 " << secretNumber << "！" << endl;
cout << "总尝试次数: " << attempts << " | 本轮得分: " << score << endl;
return score;
}
}
// 次数用完未猜对
cout << "\n次数已用尽！正确答案是 " << secretNumber << endl;
return 0;
}
// 5. 显示游戏历史记录（统计总分、平均分）
void showHistory(int scores[], int rounds) {
if (rounds == 0) {
cout << "\n暂无游戏记录~" << endl;
return;
}
cout << "\n===== 游戏历史记录 =====" << endl;
cout << setw(4) << "轮次" << " | " << setw(4) << "得分" << endl;
cout << "------------------------" << endl;
int total = 0;
for (int i = 0; i < rounds; i++) {
cout << setw(4) << i + 1 << " | " << setw(4) << scores[i] << endl;
total += scores[i];
}
cout << "------------------------" << endl;
cout << setw(4) << "总计" << " | " << setw(4) << total << endl;
cout << setw(4) << "平均" << " | " << setw(4) << total / rounds << endl;
cout << "========================\n" << endl;
}
// 主函数：游戏入口
int main() {
srand((unsigned int)time(0)); // 初始化随机数种子（确保每次运行随机数不同）
// 定义4个难度级别（通过结构体数组组织）
Difficulty difficulties[] = {
{"简单", 1, 50, 10, 10}, // 1-50，10次机会，基础分10
{"中等", 1, 100, 10, 20}, // 1-100，10次机会，基础分20
{"困难", 1, 200, 8, 30}, // 1-200，8次机会，基础分30
{"专家", 1, 500, 9, 50} // 1-500，9次机会，基础分50
};
const int DIFF_COUNT = sizeof(difficulties) / sizeof(Difficulty); // 难度数量
// 游戏状态变量
int totalRounds = 0; // 总游戏轮次
const int MAX_HISTORY = 100; // 最大记录数
int scoreHistory[MAX_HISTORY] = {0}; // 得分历史
char playAgain; // 是否继续游戏
// 欢迎界面
cout << "=====================================" << endl;
cout << " C++ 猜数字游戏 " << endl;
cout << "=====================================\n" << endl;
showHelp(); // 首次运行显示帮助
// 游戏主循环：直到用户选择退出
do {
int diffIdx = chooseDifficulty(difficulties, DIFF_COUNT); // 选择难度
int roundScore = playRound(difficulties[diffIdx]); // 玩一轮
// 记录得分（不超过最大记录数）
if (totalRounds < MAX_HISTORY) {
scoreHistory[totalRounds++] = roundScore;
}
showHistory(scoreHistory, totalRounds); // 显示历史记录
// 询问是否继续
cout << "是否继续游戏？(y/n): ";
cin >> playAgain;
} while (playAgain == 'y' || playAgain == 'Y');
cout << "\n感谢游玩！再见~" << endl;
return 0;
}
二、代码拆解：从语法到思想的铺垫
要理解二分查找，先得吃透猜数字游戏的核心逻辑 ——「根据反馈缩小范围」。我们按模块拆解代码，重点关注和算法思想相关的设计：
2.1 结构体Difficulty：封装思想的实践
代码用结构体将「难度名称、数字范围、尝试次数、基础分」打包，避免了零散变量的混乱。这种高内聚设计是编程好习惯，后续修改难度时只需修改结构体数组，无需改动其他函数。
2.2 playRound函数：猜数字的核心逻辑
这是衔接二分查找的关键模块，核心逻辑是：
- 生成随机数作为目标；
- 玩家输入猜测值，系统根据「太大 / 太小」给出反馈；
- 玩家根据反馈调整下次猜测的范围。
这里的关键问题是：如何让猜测次数最少？
如果玩家乱猜（比如从 1 开始逐个试），最坏情况需要 50 次（简单难度）；但如果每次猜当前范围的「中间值」，最坏情况只需 6 次（因为 2^6=64 > 50）—— 这就是二分查找的核心思路！
三、从游戏到算法：二分查找的本质
当我们意识到「每次猜中间值是最优策略」时，就已经触碰到了二分查找的本质。下面系统讲解二分查找的定义、适用场景、原理与实现。
3.1 二分查找是什么？
二分查找（Binary Search）是一种高效的查找算法，适用于「有序且无重复元素的数组」（若有重复元素，需调整逻辑处理）。其核心思想是：
每次将查找范围砍半；
通过比较中间元素与目标值的大小，排除一半不可能的范围；
重复上述过程，直到找到目标或范围为空。
3.2 适用场景（初学者必记）
- 数据结构：有序数组（若无序，需先排序，但排序成本可能高于线性查找）；
- 数据量：适合大数据量（小数据量下，线性查找与二分查找效率差距不大）；
- 访问方式：支持随机访问（如数组，可直接通过索引定位中间元素；链表不适合，因为定位中间元素需 O (n) 时间）。
3.3 二分查找原理：用猜数字举例
以「简单难度（1-50），目标数字 37」为例，演示二分查找过程：
- 初始范围：left=1，right=50，中间值 mid=25（(1+50)/2=25.5，取整）；
- 25 < 37 → 排除 1-25，新范围 left=26，right=50；
- 新中间值 mid=38（(26+50)/2=38）；
- 38 > 37 → 排除 38-50，新范围 left=26，right=37；
- 新中间值 mid=31（(26+37)/2=31.5，取整）；
- 31 < 37 → 排除 26-31，新范围 left=32，right=37；
- 新中间值 mid=34（(32+37)/2=34.5，取整）；
- 34 < 37 → 排除 32-34，新范围 left=35，right=37；
- 新中间值 mid=36（(35+37)/2=36）；
- 36 < 37 → 排除 35-36，新范围 left=37，right=37；
- 中间值 mid=37，等于目标 → 找到！
仅用 6 次就找到目标，远优于线性查找的 37 次。
四、二分查找的代码实现（C++）
二分查找有两种常见实现方式：迭代法（推荐，无栈溢出风险）和递归法（思路简洁，但数据量大时可能栈溢出）。
4.1 迭代法实现（基础版）
#include <iostream>
#include <vector>
using namespace std;
// 二分查找：返回目标值在有序数组中的索引，未找到返回-1
int binarySearch(vector<int>& arr, int target) {
int left = 0; // 左边界
int right = arr.size() - 1; // 右边界（初始为数组最后一个元素索引）
// 循环条件：left <= right（当left=right时，仍需判断该元素是否为目标）
while (left <= right) {
// 计算中间索引：避免(left+right)溢出（如left=2^31-1，right=2^31-1时溢出）
int mid = left + (right - left) / 2;
if (arr[mid] == target) {
return mid; // 找到目标，返回索引
} else if (arr[mid] < target) {
left = mid + 1; // 目标在右半区，调整左边界
} else {
right = mid - 1; // 目标在左半区，调整右边界
}
}
return -1; // 未找到目标
}
// 测试
int main() {
vector<int> sortedArr = {1, 3, 5, 7, 9, 11, 13, 15}; // 必须是有序数组
int target = 7;
int index = binarySearch(sortedArr, target);
if (index != -1) {
cout << "目标" << target << "在数组中的索引：" << index << endl;
} else {
cout << "未找到目标" << target << endl;
}
return 0;
}
4.2 递归法实现
#include <iostream>
#include <vector>
using namespace std;
// 递归辅助函数：传入左、右边界
int binarySearchRecur(vector<int>& arr, int target, int left, int right) {
// 递归终止条件：范围为空，未找到
if (left > right) {
return -1;
}
int mid = left + (right - left) / 2;
if (arr[mid] == target) {
return mid;
} else if (arr[mid] < target) {
// 递归查找右半区
return binarySearchRecur(arr, target, mid + 1, right);
} else {
// 递归查找左半区
return binarySearchRecur(arr, target, left, mid - 1);
}
}
// 对外接口
int binarySearch(vector<int>& arr, int target) {
return binarySearchRecur(arr, target, 0, arr.size() - 1);
}
// 测试
int main() {
vector<int> sortedArr = {2, 4, 6, 8, 10, 12};
int target = 8;
int index = binarySearch(sortedArr, target);
cout << (index != -1 ? "找到，索引：" + to_string(index) : "未找到") << endl;
return 0;
}
4.3 关键细节：边界条件处理
初学者最容易踩坑的是「循环条件」和「边界调整」，这里重点解释：
- 循环条件left <= right：
当left = right时，中间值mid就是left（或right），此时仍需判断该元素是否为目标。若用left < right，会漏掉left = right的情况。 - 中间索引mid = left + (right - left)/2：
避免直接用(left + right)/2—— 当left和right都是大整数（如2^31-1）时，left + right会溢出，而left + (right - left)/2等价且无溢出风险。
五、算法效率分析：为什么二分查找高效？
5.1 时间复杂度
每次循环将范围砍半，设数组长度为n，最坏情况需要循环log2(n)次（如n=50时，log2(50)≈6）。因此时间复杂度为 O(logn)，远优于线性查找的O(n)。
5.2 空间复杂度
迭代法：仅用left、right、mid三个变量，空间复杂度为 O(1)（常数级）；
递归法：递归深度为log2(n)，栈空间消耗为 O(logn)。
六、实战优化：用二分查找给猜数字游戏加 AI
我们可以基于二分查找，给游戏加一个「AI 自动猜数」功能，让 AI 用最优策略快速猜对，对比人工猜数的效率。
优化后的autoPlay函数
// AI自动猜数（基于二分查找）
int autoPlay(Difficulty diff) {
int secretNumber = rand() % (diff.maxNum - diff.minNum + 1) + diff.minNum;
int left = diff.minNum;
int right = diff.maxNum;
int attempts = 0;
int aiGuess;
cout << "\n===== AI自动猜数模式 =====" << endl;
cout << "目标数字范围: " << diff.minNum << "~" << diff.maxNum << endl;
cout << "AI开始猜数..." << endl;
while (attempts < diff.maxAttempts) {
attempts++;
// AI猜中间值（二分策略）
aiGuess = left + (right - left) / 2;
cout << "AI第" << attempts << "次猜测：" << aiGuess << endl;
if (aiGuess > secretNumber) {
cout << "AI猜大了！下次猜小一点" << endl;
right = aiGuess - 1; // 缩小右边界
} else if (aiGuess < secretNumber) {
cout << "AI猜小了！下次猜大一点" << endl;
left = aiGuess + 1; // 缩小左边界
} else {
int score = diff.basePoints * (diff.maxAttempts - attempts + 1);
cout << "\nAI猜对了！答案是 " << secretNumber << "！" << endl;
cout << "AI尝试次数: " << attempts << " | 得分: " << score << endl;
return score;
}
}
cout << "\nAI次数用尽！正确答案是 " << secretNumber << endl;
return 0;
}
在main函数中调用autoPlay，即可看到 AI 用二分策略快速猜对 —— 比如「专家难度（1-500）」，AI 最坏情况仅需 9 次（2^9=512 > 500），完全符合理论预期。
七、总结：二分查找的核心思想与应用
- 核心思想：通过「每次砍半范围」减少无效搜索，将时间复杂度从O(n)降至O(logn)，是「分治思想」的典型应用。
- 关键前提：必须是有序数组（若无序，需权衡排序成本）。
- 实际应用：
查找有序数组中的目标值（如数据库索引查询）；
寻找有序数组中「第一个大于目标值的元素」「最后一个小于目标值的元素」等边界问题；
数值计算（如求平方根的近似值）。
对于初学者，建议先运用好「迭代法」实现，再尝试递归法，重点关注边界条件的处理 —— 只有掌握这些细节，才能在实际开发中灵活应用二分查找解决问题。
最后，不妨运行文中的猜数字游戏，先用人工乱猜，再用 AI 自动猜，直观感受二分查找的高效 —— 理论结合实践，才能真正掌握算法思维。
扫一扫
6万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
