#include<iostream>using namespace std;struct Node{ char data;Node *next;};int main(){Node *head=NULL,*q,*p;int n=0;p=new Node;cout<<"Input a char:";cin>>p->data;while(p->data!='*'){n++;if(n==1) head=p;else q->next=p;q=p;p=new Node;cout<<"Input a char:";cin>>p->data;};q->next=NULL;cout<<"Points="<<n<<endl;p=head;while(p!=NULL){ cout<<p->data<<"  ";q=p;p=p->next;delete q;}cout<<endl;}

编写计算斐波那契（Fibonacci）数列的第n项函数fib（n）(n < 40)。数列描述：f1=f2==1;fn=fn-1+fn-2(n>=3)。代码如下：#include<iostream>using namespace std;int fib(int n){if(n==1||n==2){return 1;}return fib(n-1)+fib(n-2);}int main(){int n;while(cin>>n){cout<<fib(n)<<endl;}return 0;}如果限制范围，需要记忆化递归，防止重复：#include<iostream>using namespace std;long long fib(int n,long long memo[]){//记忆化递归if(n==1||n==2){return 1;}if(memo[n]!=0){return memo[n];}memo[n]=fib(n-1,memo)+fib(n-2,memo);return memo[n];}int main(){int n;while(cin>>n){long long memo[71]={0};cout<<fib(n,memo)<<endl;}return 0;}记忆化递归通过「数组 memo 缓存已计算的结果」，后续遇到相同子问题直接读取缓存，时间复杂度优化为 \(O(n)\)，空间复杂度 \(O(n)\)（递归栈 + 缓存数组）。

“回文素数”是指正读和反读都一样的素数，例如 11, 101, 131 等。“孪生素数”指相差为2的两个素数，例如：11与13，17与19。若x是回文素数，x+2是素数，则称（x,x+2)为回文孪生素数对,例如(3,5) , (101,103)。编写一个程序，输入两个正整数 n，k，输出 K个大于等于n的回文孪生素数对。思路：先判断素数->回文孪生#include<iostream>#include<string>using namespace std;bool isPrime(int num){if(num<2)return false;for(int i=2;i*i<=num;i++){if(num%i==0)return false;}return true;}bool isP(int num){string s=to_string(num);//数值转化为字符串int left=0,right=s.size()-1;while(left<right){if(s[left]!=s[right])return false;left++;right--;}return true;}int main(){int n,k;cin>>n>>k;int count=0;int x=n;while(count<k){if(isP(x)&&isPrime(x)&&isPrime(x+2)){cout<<"("<<x<<","<<x+2<<")"<<endl;count++;}x++;}return 0;}

汉诺塔是一个源于印度古老传说的益智玩具。据说大梵天创造世界的时候做了三根金刚石柱子，在一根柱子上从下往上按照大小顺序摞着64片黄金圆盘，大梵天命令僧侣把圆盘移到另一根柱子上，并且规定：在小圆盘上不能放大圆盘，每次只能移动一个圆盘。当所有圆盘都移到另一根柱子上时，世界就会毁灭。递归函数如下：#include<iostream>#include<string>using namespace std;void hanoi(int n,string from,string a,string to){if(n==1){cout<<from<<"->"<<to<<endl;return;}hanoi(n-1,from,to,a);cout<<from<<"->"<<to<<endl;hanoi(n-1,a,from,to);}int main(){int n;string a,b,c;cin>>n>>a>>b>>c;hanoi(n,a,b,c);return 0;}

在C++中，结构体（struct） 是一种用户自定义数据类型，用于将不同类型的变量（成员）组合成一个整体，核心作用是“打包”相关数据，方便管理和使用。1. 结构体的基本定义与使用结构体通过  struct  关键字定义，语法如下，结合代码示例更易理解：代码：#include# includeusing namespace std;// 1. 定义结构体（相当于创建一个新的"数据模板"）struct Student {// 成员变量：不同类型的数据string name;  // 姓名（string类型）int age;      // 年龄（int类型）float score;  // 分数（float类型）};  // 注意：结构体定义结尾必须加分号int main() {// 2. 声明结构体变量（使用"模板"创建具体数据）Student stu1;  // stu1 是 Student 类型的变量// 3. 给成员变量赋值（通过"变量名.成员名"访问）stu1.name = "张三";stu1.age = 18;stu1.score = 92.5;// 4. 访问并输出成员变量cout << "姓名：" << stu1.name << endl;cout << "年龄：" << stu1.age << endl;cout << "分数：" << stu1.score << endl;return 0;}输出结果：plaintext姓名：张三年龄：18分数：92.5

1.末尾向开头遍历#include# includeusing namespace std;int main(){string s;cin >> s;// 从字符串最后一个字符开始，反向遍历到第一个字符for(int i = s.length() - 1; i >= 0; i--){cout << s[i];}cout << endl;return 0;}2.reverse#include# include#include   // 包含 reverse 函数using namespace std;int main() {string s;cin >> s;reverse(s.begin(), s.end());  // 反转字符串：begin()是起始迭代器，end()是结束迭代器cout << s << endl;return 0;}3.双指针#include# includeusing namespace std;int main() {string s;cin >> s;int left = 0;                  // 左指针：起始位置int right = s.length() - 1;    // 右指针：末尾位置while (left < right) {         // 两指针未相遇时，交换字符swap(s[left], s[right]);   // 交换左右指针指向的字符（C++内置swap函数）left++;                    // 左指针右移right--;                   // 右指针左移}cout << s << endl;return 0;}4.#include# includeusing namespace std;// 递归函数：逆序输出字符串 s（从索引 index 开始）void reverseString(const string& s, int index) {if (index == s.length()) {     // 递归终止条件：索引到达字符串末尾return;}// 先递归处理下一个字符（子问题：逆序输出 s[index+1 ... end]）reverseString(s, index + 1);// 递归返回后，输出当前字符（子问题解决后，输出当前字符，实现逆序）cout << s[index];}int main() {string s;cin >> s;reverseString(s, 0);  // 从索引 0 开始递归cout << endl;return 0;}

十一、标准模板库(STL)​容器​：vector动态数组，提供自动内存管理​算法​：sort排序等通用算法​迭代器​：统一访问容器元素的接口十二、异常处理​异常机制​：try检测异常，throw抛出异常，catch捕获处理​异常安全​：保证程序在异常情况下的稳定性十三、文件操作​文件流​：ifstream读文件，ofstream写文件，fstream读写文件​文件操作​：打开、读写、关闭文件的基本流程

七、数组与字符串​数组​：相同类型元素集合，通过下标访问，支持多维数组​字符串​：string类提供丰富操作，支持连接、比较、查找等八、指针与引用​指针​：存储变量地址，通过*解引用访问数据，支持指针算术运算​引用​：变量的别名，必须初始化，通过&声明，不能重新绑定九、内存管理​动态分配​：new申请内存，delete释放内存，new[]分配数组，delete[]释放数组​内存安全​：避免内存泄漏(及时释放)、悬空指针(释放后置空)十、结构体与类​结构体​：数据聚合类型，可包含成员变量和成员函数​类​：面向对象核心，支持封装(public/private)、构造函数、成员函数

四、运算符体系​算术运算​：+ - * / % 加减乘除取模​关系运算​：== != > < >= <= 比较大小关系​逻辑运算​：&& || ! 与或非逻辑判断​赋值运算​：= 及复合赋值 += -= *= /=​位运算​：& | ^ ~ << >> 按位操作五、流程控制结构​条件分支​：if-else条件判断，switch-case多路选择​循环结构​：for循环(明确次数)，while循环(条件判断)，do-while循环(至少执行一次)​跳转语句​：break跳出循环，continue跳过本次，return函数返回六、函数机制​函数定义​：返回类型 函数名(参数列表){函数体}​参数传递​：值传递(拷贝副本)、指针传递(传递地址)、引用传递(传递别名)​函数特性​：支持重载(同名不同参)、默认参数(参数缺省值)

一、程序基本结构C++程序由预处理指令、主函数和语句组成。必须包含main()函数作为程序入口，使用分号结束每条语句。二、数据类型系统基本类型：int整型、double双精度浮点、float单精度浮点、char字符型、bool布尔型类型修饰：short短整型、long长整型、unsigned无符号型类型转换：支持隐式自动转换和显式强制转换，推荐使用static_cast三、变量与常量变量声明：三种初始化方式 - 拷贝初始化(int a=10)、直接初始化(int a(10))、列表初始化(int a{10})常量定义：const定义运行时常量，constexpr定义编译时常量，宏常量使用#define(不推荐)

给定一个整数序列，把其中的重复的整数去掉，并将去重后的序列从小到大排序输出。#include# include#include# includeusing namespace std;int main(){int n;cin>>n;vector nums(n);for(int i=0;i>nums[i];}sets(nums.begin(),nums.end());// 去重：利用set自动去重且排序的特性bool first=true;for(int num :s){if(!first){cout<<" ";}cout<，bool 表示是否插入成功（重复元素插入失败）；插入多个元素：支持初始化列表、迭代器范围。2.删除元素——按值删除：返回删除的元素个数（0 或 1，因无重复）；按迭代器删除：无返回值，需确保迭代器有效；按范围删除：删除 [first, last) 区间的元素。3. 查找元素（find、count、lower_bound、upper_bound）find(x)：返回指向 x 的迭代器，若不存在返回 s.end()；count(x)：返回 x 的个数（0 或 1，因无重复）；lower_bound(x)：返回第一个 >= x 的元素的迭代器；upper_bound(x)：返回第一个 > x 的元素的迭代器。

对于一个有序序列，我们可以用二分搜索的方式在该序列中搜索某个数值。以升序序列为例，二分搜索首先确定搜索的范围（即搜索序列的第一个元素的位置 left 和最后一个元素的位置 right），然后计算出中间位置 mid。比如我们要搜索的序列是：2, 7, 11, 19, 23, 31, 33, 39。在初始的状态下，搜索范围是整个序列，那么第一个元素的位置left就是1，最后一个元素的位置right就是8，mid = (left + right)/2 = 4（注意序列的长度是偶数，left+right的和是奇数，这里对结果进行了向下取整）。接下来，检查中间位置的元素是否是要搜索的值 target（假设我们要搜索的值是31，那么target就等于31），如果不是，则比较中间元素与 target 的大小关系：如果中间位置的元素比target大，因为序列是升序的，所以 target 只可能在中间元素的左侧，也就是位于 left 和 mid - 1之间，此时把 right 更新为 mid - 1，也就是说，下一次我们要搜索的范围的右边界发生了变化。更新right后，再次计算新的mid，重复上面的搜索过程；如果中间位置的元素比 target 小，那么 target 只可能位于 mid + 1 和 r 之间，此时把 l 更新为 mid + 1（这种情况是左边界发生了变化）后，重复上面的搜索过程。在搜索过程中，一旦发现某一次，搜索范围中间的值等于target，那么就是找到了目标值；或者始终找不到的情况下，当left > right的时候，我们就知道target不在我们搜索的序列中，此时搜索也就结束了。以在序列（2, 7, 11, 19, 23, 31, 33, 39）中搜索31为例，说明一下二分搜索的流程。第一轮搜索：left = 1，right = 8（注意在大多数编程语言中，数组下标是从0开始的），mid = (1 + 8) / 2 = 4，序列中第四个元素是19，19小于要搜索的目标值31，因此31只可能在序列的后半段，此时更新左侧边界left，把left赋值为mid + 1，此时left变成了5；第二轮搜索：left = 5，right = 8，mid = (5 + 8) / 2 = 6，序列中第6个元素是31，此时找到了目标元素，其在序列中的位置是6，搜索结束。再以要搜索的值是30为例，我们从刚才的第二轮搜索继续。到了上面的第二轮搜索，序列中第6个元素是31，大于30，那么30只可能存在于第5个元素（left的值为5）的右侧、31（第6个元素）的左侧，此时更新right，将其赋值为mid - 1，此时right变成了5。继续进行第三轮搜索。第三轮搜索：left = 5，right = 5，mid = (5 + 5) / 2 = 5。序列中第5个元素是23，小于30，此时更新left为mid + 1，left的值变为6，继续进行第四轮搜索。第四轮搜索：在进行搜索前，发现left的值已经大于right，这时可以确定要搜索的值不在序列中，搜索结束。#include# includeusing namespace std;int main() {int n;cin >> n;vector nums(n);for (int i = 0; i < n; i++) {cin >> nums[i];}int V;cin >> V;int left = 0, right = n - 1;int pos = -1;while (left <= right) {int mid = (left + right) / 2;if (nums[mid] == V) {pos = mid + 1;  // 位置从1开始编号，所以加1break;} else if (nums[mid] < V) {left = mid + 1;} else {right = mid - 1;}}if (pos != -1) {cout << pos << endl;} else {cout << "Value not found." << endl;}return 0;}

素数(质数)是一个正整数，除了 1 和它本身之外，不能被其它任何正整数整除，用2～m-1逐个去除 m。如果 m 能被 2～ m-1之中任何一个整数整除，则提前结束循环，此时 i≤m-1 ；如果 m 不能被 2～m-1 之间的任一整数整除，则在完成最后一次循环后，i 的值为 m，表明m未曾被 2～m-1之间任一整数整除过，m 是素数。#includeusing namespace std;int main(){bool isPrime=true;int m;cin>>m;if(m==1){isPrime=false;}else{for(int i=2;i*i<=m;i++){if(m%i==0){isPrime=false;break;}}}if(isPrime){cout<<<" is a prime number"<

所谓水仙花数是指一个m位数（m>=3 &&m<=7），它的每个位上的数字m次幂之和等于本身。 例如，3位数153是水仙花，其各位数字的立方和等于153。 要求：输入一个3位数n，输出所有介于100至n之间（包括100和n）的位数为3的水仙花数。代码如下：#includeusing namespace std;int main(){int m;cin>>m;for(int i=100;i<=m;i++){int g=i%10;int s=i/10%10;int b=i/100;if(g*g*g+s*s*s+b*b*b==i){cout<<i><</i>