用东华OJ的50道基础题，带你系统性复习C++语法（附分类练习题单）

东华OJ 50题通关指南：C++语法精要与实战技巧全解析

引言：为什么选择OJ题库巩固C++基础？

在编程学习的道路上，理论知识的掌握只是第一步，真正的能力提升来自于大量的实践练习。东华OJ平台的50道基础题目，就像50个精心设计的训练关卡，覆盖了C++语法的核心要点。这些题目不是简单的语法演示，而是将编程思维、算法逻辑和语法特性巧妙融合的实战场景。

对于已经学完C++基础语法的同学来说，这套题目可以帮助你：

• 发现知识盲点，填补理解漏洞
• 建立不同语法概念间的联系
• 培养解决实际问题的思维模式
• 为考试和面试积累实战经验

更重要的是，通过系统性地分类练习，你能构建起完整的知识框架，而不是零散的记忆点。接下来，我们将按照C++的核心语法模块，为你设计一条高效的学习路径。

1. 基础结构：顺序、分支与循环

1.1 顺序结构：编程的基石

顺序结构是程序最基本的执行方式，东华OJ的前3题（长方形面积、数列和、解方程）帮助我们建立最基本的编程思维：

// 例题：长方形面积与周长计算 #include <iostream> using namespace std; int main() { int a, b; cin >> a >> b; cout << a*b << " " << 2*(a+b) << endl; return 0; }

关键点：

• 输入输出的基本格式
• 算术运算符的正确使用
• 变量类型的合理选择

提示：即使是简单的顺序结构，也要注意边界条件的处理，例如长方形的长宽是否为0。

1.2 分支结构：程序决策的艺术

分支结构让程序具备判断能力，题目4-11涵盖了if-else和switch的典型应用：

// 例题：闰年判断的经典实现 bool isLeapYear(int year) { return (year%4==0 && year%100!=0) || (year%400==0); }

1.3 循环结构：重复的力量

循环是自动化处理的核心，题目12-33展示了for、while的各种应用场景：

典型模式：

1. 累加/累乘计算
2. 数字特征判断（素数、回文数等）
3. 迭代逼近计算

// 例题：阶乘结果末尾0的个数 int countTrailingZeros(int n) { int count = 0; for(int i=5; n/i>=1; i*=5) { count += n/i; } return count; }

注意：循环结构要特别注意终止条件和边界情况，避免死循环或差一错误。

2. 数据结构：数组与字符串处理

2.1 一维数组：数据的线性组织

数组是存储和处理批量数据的基础工具，题目34-50展示了数组的各种妙用：

应用场景：

• 数字统计与频率分析
• 滑动窗口求极值
• 递推数列计算

// 例题：繁殖问题（递推数列） int rabbitCount(int month) { int dp[50] = {1,1,2,3}; for(int i=4; i<=month; i++) { dp[i] = dp[i-2] + dp[i-3] + dp[i-4]; } return dp[month]; }

2.2 二维数组：矩阵与表格数据

虽然基础题中只有杨辉三角一题，但二维数组是图像处理、矩阵运算的基础：

// 杨辉三角生成 void generatePascalTriangle(int n) { int tri[n][n]; for(int i=0; i<n; i++) { for(int j=0; j<=i; j++) { if(j==0 || j==i) tri[i][j] = 1; else tri[i][j] = tri[i-1][j-1] + tri[i-1][j]; cout << tri[i][j] << " "; } cout << endl; } }

2.3 字符串处理：从基础到进阶

字符串是编程中最常用的数据类型之一，题目81展示了基础处理技巧：

核心技能：

• 字符遍历与特征提取
• 字符串转换与格式化
• 模式匹配与查找

// 计算小数位数 int countDecimalDigits(const string& num) { size_t pos = num.find('.'); if(pos == string::npos) return 0; return num.length() - pos - 1; }

3. 函数封装与递归思想

3.1 函数：模块化编程的基础

题目58展示了如何将重复逻辑封装为函数：

// 素数判断函数 bool isPrime(int n) { if(n < 2) return false; for(int i=2; i*i<=n; i++) { if(n%i == 0) return false; } return true; }

函数设计原则：

1. 单一职责原则
2. 明确的输入输出
3. 避免副作用

3.2 递归：优雅的问题分解

虽然基础题中没有直接考察递归，但许多问题（如约瑟夫环）可以用递归解决：

// 递归实现约瑟夫问题 int josephus(int n, int k) { return n > 1 ? (josephus(n-1, k) + k) % n : 0; }

提示：递归代码简洁但可能有栈溢出风险，对于大规模问题建议改用迭代实现。

4. 经典算法思想初探

4.1 枚举法：暴力之美

许多题目（如公式求解、特殊四位数）可以通过系统枚举解决：

// 寻找满足a²+x²=b²+y²的解 void findSolutions(int a, int b) { for(int x=1; x<=100; x++) { for(int y=1; y<=100; y++) { if(a*a + x*x == b*b + y*y) { cout << x << " " << y << endl; } } } }

4.2 贪心算法：局部最优解

题目49（修理牛棚）展示了贪心算法的典型应用：

// 修理牛棚的最小木板长度计算 int minBoardLength(int m, vector<int>& positions) { sort(positions.begin(), positions.end()); vector<int> gaps; for(int i=1; i<positions.size(); i++) { gaps.push_back(positions[i] - positions[i-1] - 1); } sort(gaps.rbegin(), gaps.rend()); int total = positions.back() - positions.front() + 1; for(int i=0; i<min(m-1, (int)gaps.size()); i++) { total -= gaps[i]; } return total; }

4.3 模拟法：真实场景再现

题目22（约瑟夫环2）需要准确模拟整个移除过程：

// 约瑟夫环模拟实现 vector<int> josephusProcess(int n, int m) { vector<bool> alive(n, true); vector<int> sequence; int pos = 0; for(int i=0; i<n; i++) { int count = 0; while(count < m) { if(alive[pos]) count++; if(count == m) break; pos = (pos + 1) % n; } alive[pos] = false; sequence.push_back(pos + 1); } return sequence; }

5. 调试技巧与性能优化

5.1 常见错误类型

在OJ练习中，我们经常会遇到各种错误：

5.2 测试用例设计

有效的测试是保证程序正确性的关键：

1. 正常情况测试
2. 边界条件测试
3. 极端情况测试
4. 随机数据测试

// 自动生成测试用例示例 void generateTestCases() { // 正常情况 cout << "3\n1 2 3\n"; // 边界情况 cout << "1\n10000\n"; // 极端情况 cout << "100\n"; for(int i=0; i<100; i++) cout << "1 "; cout << endl; }

5.3 性能优化技巧

当遇到时间限制问题时，可以考虑：

1. 使用更高效的数据结构
2. 减少不必要的计算
3. 利用数学性质简化计算
4. 使用记忆化技术避免重复计算

// 素数表的记忆化存储 vector<bool> primeCache; void initPrimeCache(int n) { primeCache.resize(n+1, true); primeCache[0] = primeCache[1] = false; for(int i=2; i*i<=n; i++) { if(primeCache[i]) { for(int j=i*i; j<=n; j+=i) { primeCache[j] = false; } } } }

6. 从题目到实战：思维模式训练

6.1 问题分解技巧

面对复杂问题时，学会分解是关键：

1. 理解题意，明确输入输出
2. 识别问题中的子任务
3. 设计解决每个子任务的方案
4. 组合子解决方案形成最终答案

以题目"数字串处理"为例：

• 子任务1：统计连续相同数字的长度
• 子任务2：记录最大长度和对应数字
• 子任务3：处理多个相同最大长度的情况

6.2 模式识别能力

许多题目存在共同的解决模式：

6.3 算法选择策略

根据问题特点选择合适的算法：

1. 数据规模小 → 枚举法
2. 有序数据 → 二分查找
3. 最优子结构 → 动态规划
4. 重复子问题 → 记忆化或递归

// 根据问题特点选择算法示例 void solveProblem(const Problem& p) { if(p.dataSize < 100) { bruteForceSolution(p); } else if(p.isSorted) { binarySearchSolution(p); } else if(p.hasOptimalSubstructure) { dynamicProgrammingSolution(p); } else { generalSolution(p); } }

7. 进阶挑战：超越基础题目

7.1 多维问题扩展

许多一维问题可以扩展到多维：

1. 一维数组 → 二维矩阵
2. 单层循环 → 嵌套循环
3. 线性结构 → 树形结构

// 二维版本的数字串处理 void findMaxBlock(const vector<vector<int>>& matrix) { int maxCount = 0, value = 0; for(int i=0; i<matrix.size(); i++) { for(int j=0; j<matrix[0].size(); j++) { int count = dfs(matrix, i, j, matrix[i][j]); if(count > maxCount) { maxCount = count; value = matrix[i][j]; } } } cout << value << " " << maxCount << endl; }

7.2 效率对比实验

通过对比不同算法的实际表现，深入理解复杂度：

// 素数判断算法对比 void comparePrimeAlgorithms(int n) { clock_t start = clock(); // 朴素算法 for(int i=2; i<=n; i++) { bool prime = true; for(int j=2; j*j<=i; j++) { if(i%j == 0) { prime = false; break; } } } cout << "Naive: " << (clock()-start) << "ms\n"; start = clock(); // 埃拉托斯特尼筛法 vector<bool> isPrime(n+1, true); for(int i=2; i*i<=n; i++) { if(isPrime[i]) { for(int j=i*i; j<=n; j+=i) { isPrime[j] = false; } } } cout << "Sieve: " << (clock()-start) << "ms\n"; }

7.3 真实项目中的应用

这些基础算法在实际开发中无处不在：

1. 约瑟夫问题 → 进程调度算法
2. 数字处理 → 数据清洗与转换
3. 日期计算 → 日历应用开发
4. 字符串处理 → 文本分析工具

// 实际项目中的日期处理示例 class Calendar { public: static int dayOfWeek(int y, int m, int d) { if(m < 3) { m += 12; y--; } return (d + 2*m + 3*(m+1)/5 + y + y/4 - y/100 + y/400) % 7; } static bool isValidDate(int y, int m, int d) { if(m < 1 || m > 12 || d < 1) return false; int daysInMonth[] = {31,28,31,30,31,30,31,31,30,31,30,31}; if(m == 2 && isLeapYear(y)) daysInMonth[1]++; return d <= daysInMonth[m-1]; } };

8. 学习路线与资源推荐

8.1 系统化学习路径

建议按照以下顺序逐步提升：

1. 基础语法巩固（2周）

   • 变量与数据类型
   • 控制结构
   • 函数基础

2. 数据结构掌握（3周）

   • 数组与字符串
   • 结构体与类
   • STL容器

3. 算法思维训练（4周）

   • 排序与搜索
   • 递归与回溯
   • 动态规划

8.2 推荐资源列表

在线平台：

• LeetCode（算法题库）
• Codeforces（竞赛训练）
• HackerRank（分类挑战）

书籍推荐：

• 《C++ Primer》（语法参考）
• 《算法导论》（理论基础）
• 《编程珠玑》（实战技巧）

工具推荐：

• Visual Studio Code（轻量级编辑器）
• CLion（专业C++ IDE）
• Valgrind（内存检测工具）

8.3 持续进步的方法

1. 每日一题保持手感
2. 定期复习经典题目
3. 参与编程竞赛锻炼
4. 阅读优秀代码学习
5. 坚持写技术博客总结

// 学习进度跟踪示例 class LearningTracker { private: map<string, int> topicProgress; public: void completeExercise(const string& topic) { topicProgress[topic]++; } void printProgressReport() { for(const auto& [topic, count] : topicProgress) { cout << topic << ": " << count << " exercises completed\n"; } } };

9. 常见面试问题解析

9.1 基础概念考察

典型问题：

1. 指针和引用的区别
2. const关键字的作用
3. 虚函数实现原理
4. 内存管理方式

// 面试常见代码分析题 void analyzeCode() { int a = 5; int &b = a; int *c = &a; cout << (*(&b))++ << endl; // 输出？a的值变为？ cout << (*c)++ << endl; // 输出？a的值变为？ }

9.2 白板编程挑战

常见白板编程题目类型：

1. 字符串反转
2. 链表操作
3. 二叉树遍历
4. 排序算法实现

// 白板编程示例：字符串反转 string reverseString(const string& s) { string result; for(int i=s.length()-1; i>=0; i--) { result += s[i]; } return result; // 更高效的实现：原地交换字符 }

9.3 性能分析问题

面试官可能要求分析算法复杂度：

// 复杂度分析示例 void complexityAnalysis() { // O(n)时间，O(1)空间 int sum = 0; for(int i=1; i<=n; i++) sum += i; // O(n^2)时间，O(n)空间 vector<vector<int>> matrix(n, vector<int>(n)); for(int i=0; i<n; i++) { for(int j=0; j<n; j++) { matrix[i][j] = i + j; } } }

10. 从学习者到贡献者

10.1 参与开源项目

成长路径建议：

1. 从修复文档开始
2. 解决简单的issue
3. 提交功能改进
4. 维护独立模块

// 开源项目贡献示例：添加测试用例 TEST(PrimeTest, HandlesZeroAndOne) { EXPECT_FALSE(isPrime(0)); EXPECT_FALSE(isPrime(1)); } TEST(PrimeTest, HandlesPrimeNumbers) { EXPECT_TRUE(isPrime(2)); EXPECT_TRUE(isPrime(3)); EXPECT_TRUE(isPrime(5)); }

10.2 题目创作与分享

设计好的编程题目需要考虑：

1. 明确的题意描述
2. 合理的输入输出规范
3. 全面的测试用例
4. 多种解决思路的可能性

// 自定义题目示例：特殊矩阵生成 /** * 题目：生成特殊螺旋矩阵 * 输入：整数n(1<=n<=100) * 输出：n×n矩阵，元素从1到n²按螺旋顺序排列 * 示例： * 输入：3 * 输出： * 1 2 3 * 8 9 4 * 7 6 5 */

10.3 技术社区参与

有价值的社区参与方式：

1. 解答新手问题
2. 分享解题思路
3. 组织编程比赛
4. 撰写技术文章

// 技术文章代码示例：高效素数筛法解析 class PrimeSieve { public: vector<int> generatePrimes(int n) { vector<bool> isPrime(n+1, true); vector<int> primes; for(int p=2; p*p<=n; p++) { if(isPrime[p]) { for(int i=p*p; i<=n; i+=p) { isPrime[i] = false; } } } for(int p=2; p<=n; p++) { if(isPrime[p]) primes.push_back(p); } return primes; } };