C语言程序设计100个经典例子

C语言程序设计100个经典例子说明：本示例集按知识点递进划分，涵盖基础语法、字符串、数组、算法、数据结构、指针、文件操作等核心内容，每例均提供完整可运行代码（适配C99及以上标准，编译命令参考：gcc文件名.c-std=c99-o文件名），并附关键知识点说明，既适合初学者入门练习，也可用于进阶者巩固提升，所有例子经过验证，可直接复制运行。第一部分：基础语法（1-10例）例1：HelloWorld（最基础程序）c

#include<stdio.h>

intmain(void){

printf("Hello,World!\n");//标准输出函数，\n表示换行

return0;//程序正常结束，返回0

}

说明：C语言入门第一个程序，核心是掌握printf输出函数、程序入口main函数的基本结构，以及预处理指令#include<stdio.h>（引入标准输入输出头文件）。例2：交换两个整数（不借助第三变量，异或实现）c

#include<stdio.h>

intmain(void){

inta,b;

printf("请输入两个整数：");

scanf("%d%d",&a,&b);//标准输入函数，&表示取变量地址

//异或特性：a^a=0，a^0=a，利用异或实现无临时变量交换

a=a^b;

b=a^b;

a=a^b;

printf("交换后：a=%d,b=%d\n",a,b);

return0;

}

说明：掌握异或运算符^的特性，理解地址运算符&的作用，对比借助临时变量的交换方式，体会位运算的简洁性。例3：阶乘（递归实现）c

#include<stdio.h>

//递归函数：计算n的阶乘，n!=n*(n-1)*...*1

longlongfactorial(intn){

returnn<=1?1:n*factorial(n-1);//递归终止条件：n≤1时返回1

}

intmain(void){

intn;

printf("请输入一个整数：");

scanf("%d",&n);

//用longlong类型避免整数溢出（适用于较大的n）

printf("%d的阶乘是%lld\n",n,factorial(n));

return0;

}

说明：理解递归函数的定义、调用机制和终止条件，掌握longlong数据类型的使用场景，避免阶乘计算中的溢出问题。例4：斐波那契数列（迭代实现）c

#include<stdio.h>

intmain(void){

intn;

printf("请输入斐波那契数列项数：");

scanf("%d",&n);

longlonga=0,b=1,temp;//初始化前两项，a=第1项，b=第2项

printf("斐波那契数列：\n");

for(inti=0;i<n;i++){

printf("%lld",a);

temp=a+b;//计算下一项

a=b;//更新a为当前b

b=temp;//更新b为下一项

}

printf("\n");

return0;

}

说明：对比递归实现，体会迭代方式的效率优势（避免递归栈溢出），掌握循环结构的灵活运用，理解斐波那契数列“前两项之和等于后一项”的规律。例5：判断一个整数是否为质数c

#include<stdio.h>

#include<math.h>//引入数学库，使用sqrt函数

#include<stdbool.h>//引入bool类型头文件

//判断n是否为质数，返回true（是）或false（否）

boolisPrime(intn){

if(n<2)returnfalse;//小于2的数不是质数

//优化：只需判断到sqrt(n)，减少循环次数

for(inti=2;i<=(int)sqrt(n);i++){

if(n%i==0)//能被除1和自身外的数整除，不是质数

returnfalse;

}

returntrue;

}

intmain(void){

intn;

printf("请输入一个整数：");

scanf("%d",&n);

printf("%d%s质数。\n",n,isPrime(n)?"是":"不是");

return0;

}

说明：掌握质数的定义，学会使用sqrt函数优化循环效率，理解bool类型的使用，以及三目运算符?:的简洁表达。例6：输出指定范围内的所有质数c

#include<stdio.h>

#include<math.h>

#include<stdbool.h>

boolisPrime(intn){

if(n<2)returnfalse;

for(inti=2;i<=(int)sqrt(n);i++){

if(n%i==0)

returnfalse;

}

returntrue;

}

intmain(void){

intlower,upper;

printf("请输入下界和上界：");

scanf("%d%d",&lower,&upper);

printf("区间[%d,%d]内的质数有：\n",lower,upper);

//遍历区间，依次判断每个数是否为质数

for(inti=lower;i<=upper;i++){

if(isPrime(i))

printf("%d",i);

}

printf("\n");

return0;

}

说明：复用自定义函数isPrime，掌握循环嵌套的使用（外层遍历区间，内层判断质数），注意边界值（如下界小于2时的处理）。例7：计算两个正整数的最大公约数（GCD）和最小公倍数（LCM）c

#include<stdio.h>

//欧几里得算法（辗转相除法）求最大公约数

intgcd(inta,intb){

returnb==0?a:gcd(b,a%b);//递归终止条件：b=0时，a为最大公约数

}

intmain(void){

inta,b;

printf("请输入两个正整数：");

scanf("%d%d",&a,&b);

intg=gcd(a,b);

//最小公倍数公式：LCM(a,b)=(a*b)/GCD(a,b)，先除后乘避免溢出

intlcm=a/g*b;

printf("最大公约数：%d\n",g);

printf("最小公倍数：%d\n",lcm);

return0;

}

说明：掌握欧几里得算法的原理，理解最大公约数与最小公倍数的关系，注意“先除后乘”避免整数溢出的技巧。例8：反转一个整数（如输入123，输出321）c

#include<stdio.h>

intmain(void){

intn,rev=0;//rev用于存储反转后的整数

printf("请输入一个整数：");

scanf("%d",&n);

while(n!=0){

rev=rev*10+n%10;//取n的个位，拼接至rev末尾

n/=10;//去掉n的个位

}

printf("反转后的整数为：%d\n",rev);

return0;

}

说明：利用循环和取余、整除运算，拆解整数的每一位，掌握“拼接数字”的核心思路，注意负数反转的特殊情况（可自行扩展处理）。例9：判断一个整数是否为回文数（如121、12321）c

#include<stdio.h>

intmain(void){

intn,original,rev=0;

printf("请输入一个整数：");

scanf("%d",&n);

original=n;//保存原始值，用于后续对比

//反转整数（复用例8的反转逻辑）

while(n!=0){

rev=rev*10+n%10;

n/=10;

}

//回文数判断：原始值与反转后的值相等

if(original==rev)

printf("%d是回文数。\n",original);

else

printf("%d不是回文数。\n",original);

return0;

}

说明：复用整数反转的逻辑，理解回文数的定义，掌握“保存原始值”的解题技巧，可扩展处理负数（负数一定不是回文数）。例10：计算一个整数的各位数字之和（如输入123，输出6）c

#include<stdio.h>

intmain(void){

intn,sum=0;

printf("请输入一个整数：");

scanf("%d",&n);

//处理负数：将负数转为正数（不影响各位数字之和）

if(n<0)

n=-n;

while(n!=0){

sum+=n%10;//取个位数字，累加到sum

n/=10;//去掉个位

}

printf("各位数字之和为：%d\n",sum);

return0;

}

说明：掌握取余运算获取数字个位的方法，处理负数的边界情况，理解循环累加的核心思路。第二部分：字符串与数组（11-20例）例11：输入并输出一个字符串（基础字符串操作）c

#include<stdio.h>

#include<string.h>//引入字符串处理头文件

intmain(void){

charstr[100];//定义字符数组，存储字符串（预留足够空间）

printf("请输入一个字符串：");

gets(str);//读取字符串（注意：gets存在安全隐患，可替换为fgets）

//fgets(str,100,stdin);//安全读取方式，避免缓冲区溢出

printf("你输入的字符串是：%s\n",str);

printf("字符串长度为：%d\n",strlen(str));//strlen计算字符串长度（不含结束符'\0'）

return0;

}

说明：掌握字符数组存储字符串的方式，了解gets函数的安全隐患，学会使用strlen函数计算字符串长度，理解字符串结束符'\0'的作用。例12：字符串反转（如输入"abcde"，输出"edcba"）c

#include<stdio.h>

#include<string.h>

intmain(void){

charstr[100],temp;

intlen,i,j;

printf("请输入一个字符串：");

fgets(str,100,stdin);

len=strlen(str);

//去掉fgets读取的换行符（若存在）

if(str[len-1]=='\n')

str[len-1]='\0';

len=strlen(str);

//双指针法：i从开头，j从末尾，交换字符

for(i=0,j=len-1;i<j;i++,j--){

temp=str[i];

str[i]=str[j];

str[j]=temp;

}

printf("反转后的字符串：%s\n",str);

return0;

}

说明：掌握双指针法的解题思路，处理fgets读取字符串时的换行符问题，理解字符串的可修改性（字符数组存储的字符串可直接修改）。例13：判断一个字符串是否为回文字符串（如"abba"、"abcba"）c

#include<stdio.h>

#include<string.h>

#include<stdbool.h>

boolisPalindromeStr(charstr[]){

intlen=strlen(str);

inti=0,j=len-1;

//双指针对比首尾字符，不相等则不是回文

while(i<j){

if(str[i]!=str[j])

returnfalse;

i++;

j--;

}

returntrue;

}

intmain(void){

charstr[100];

printf("请输入一个字符串：");

fgets(str,100,stdin);

//去掉换行符

if(str[strlen(str)-1]=='\n')

str[strlen(str)-1]='\0';

if(isPalindromeStr(str))

printf("%s是回文字符串。\n",str);

else

printf("%s不是回文字符串。\n",str);

return0;

}

说明：复用双指针法，理解回文字符串的定义，掌握自定义字符串处理函数的编写，注意忽略大小写的扩展（可自行添加字符大小写转换逻辑）。例14：统计字符串中指定字符的出现次数（如统计"abacaba"中'a'的次数）c

#include<stdio.h>

#include<string.h>

intmain(void){

charstr[100],ch;

intcount=0,i;

printf("请输入一个字符串：");

fgets(str,100,stdin);

printf("请输入要统计的字符：");

scanf("%c",&ch);

//遍历字符串，统计指定字符出现次数

for(i=0;str[i]!='\0';i++){

if(str[i]==ch)

count++;

}

printf("字符'%c'在字符串中出现了%d次。\n",ch,count);

return0;

}

说明：掌握字符串的遍历方法（通过循环判断结束符'\0'），理解计数器变量的使用，注意处理输入时的缓冲区问题（如先输入字符串再输入字符，避免换行符干扰）。例15：拼接两个字符串（不使用strcat函数）c

#include<stdio.h>

#include<string.h>

intmain(void){

charstr1[100],str2[100],result[200];

inti=0,j=0;

printf("请输入第一个字符串：");

fgets(str1,100,stdin);

printf("请输入第二个字符串：");

fgets(str2,100,stdin);

//去掉两个字符串的换行符

if(str1[strlen(str1)-1]=='\n')

str1[strlen(str1)-1]='\0';

if(str2[strlen(str2)-1]=='\n')

str2[strlen(str2)-1]='\0';

//先将str1复制到result

while(str1[i]!='\0'){

result[i]=str1[i];

i++;

}

//再将str2拼接在result后面

while(str2[j]!='\0'){

result[i]=str2[j];

i++;

j++;

}

result[i]='\0';//给拼接后的字符串添加结束符

printf("拼接后的字符串：%s\n",result);

return0;

}

说明：理解字符串拼接的底层逻辑，掌握字符数组的遍历与赋值，对比strcat函数的使用，注意拼接后的字符串长度不能超过目标数组的容量。例16：比较两个字符串的大小（不使用strcmp函数）c

#include<stdio.h>

#include<string.h>

intmain(void){

charstr1[100],str2[100];

inti=0;

printf("请输入第一个字符串：");

fgets(str1,100,stdin);

printf("请输入第二个字符串：");

fgets(str2,100,stdin);

//去掉换行符

if(str1[strlen(str1)-1]=='\n')

str1[strlen(str1)-1]='\0';

if(str2[strlen(str2)-1]=='\n')

str2[strlen(str2)-1]='\0';

//逐字符对比，直到出现不同字符或到达字符串末尾

while(str1[i]!='\0'&&str2[i]!='\0'&&str1[i]==str2[i]){

i++;

}

//根据对比结果判断大小

if(str1[i]=='\0'&&str2[i]=='\0')

printf("两个字符串相等。\n");

elseif(str1[i]<str2[i])

printf("str1<str2\n");

else

printf("str1>str2\n");

return0;

}

说明：理解字符串比较的规则（按ASCII码逐字符对比），掌握循环终止条件的设计，对比strcmp函数的返回值逻辑（相等返回0，str1小返回负数，str1大返回正数）。例17：一维数组的遍历与求和c

#include<stdio.h>

#defineN10//定义常量N，指定数组长度

intmain(void){

intarr[N],sum=0,i;

printf("请输入%d个整数：\n",N);

//输入数组元素

for(i=0;i<N;i++){

printf("arr[%d]=",i);

scanf("%d",&arr[i]);

}

//遍历数组，计算总和

for(i=0;i<N;i++){

sum+=arr[i];

}

//输出数组元素和总和

printf("数组元素：");

for(i=0;i<N;i++){

printf("%d",arr[i]);

}

printf("\n数组元素总和：%d\n",sum);

return0;

}

说明：掌握一维数组的定义、初始化、输入和遍历方法，理解常量#define的使用（便于修改数组长度），掌握循环累加的逻辑。例18：求一维数组的最大值和最小值c

#include<stdio.h>

#defineN10

intmain(void){

intarr[N],max,min,i;

printf("请输入%d个整数：\n",N);

for(i=0;i<N;i++){

printf("arr[%d]=",i);

scanf("%d",&arr[i]);

}

//初始化max和min为数组第一个元素

max=arr[0];

min=arr[0];

//遍历数组，更新max和min

for(i=1;i<N;i++){

if(arr[i]>max)

max=arr[i];

if(arr[i]<min)

min=arr[i];

}

printf("数组最大值：%d\n",max);

printf("数组最小值：%d\n",min);

return0;

}说明：掌握数组最值的求解思路（初始化最值为数组第一个元素，再遍历对比更新），理解循环起始条件（从第二个元素开始对比）。例19：二维数组的输入与输出（3行4列）c

#include<stdio.h>

#defineROW3//行数

#defineCOL4//列数

intmain(void){

intarr[ROW][COL],i,j;

printf("请输入%d行%d列的整数：\n",ROW,COL);

//输入二维数组（双重循环：外层控制行，内层控制列）

for(i=0;i<ROW;i++){

for(j=0;j<COL;j++){

printf("arr[%d][%d]=",i,j);

scanf("%d",&arr[i][j]);

}

}

//输出二维数组（按行输出）

printf("二维数组：\n");

for(i=0;i<ROW;i++){

for(j=0;j<COL;j++){

printf("%d\t",arr[i][j]);//\t表示制表符，使输出对齐

}

printf("\n");//每行结束换行

}

return0;

}说明：掌握二维数组的定义、输入和输出方法，理解双重循环的嵌套逻辑（外层控制行，内层控制列），学会使用制表符\t优化输出格式。例20：计算二维数组的每行之和与每列之和c

#include<stdio.h>

#defineROW3

#defineCOL4

intmain(void){

intarr[ROW][COL],rowSum[ROW]={0},colSum[COL]={0};

inti,j;

//输入二维数组

printf("请输入%d行%d列的整数：\n",ROW,COL);

for(i=0;i<ROW;i++){

for(j=0;j<COL;j++){

scanf("%d",&arr[i][j]);

}

}

//计算每行之和与每列之和

for(i=0;i<ROW;i++){

for(j=0;j<COL;j++){

rowSum[i]+=arr[i][j];//累加每行元素

colSum[j]+=arr[i][j];//累加每列元素

}

}

//输出每行之和

printf("每行之和：\n");

for(i=0;i<ROW;i++){

printf("第%d行之和：%d\n",i+1,rowSum[i]);

}

//输出每列之和

printf("每列之和：\n");

for(j=0;j<COL;j++){

printf("第%d列之和：%d\n",j+1,colSum[j]);

}

return0;

}

说明：掌握二维数组的遍历与累加逻辑，理解行和、列和的计算方法，学会使用额外的一维数组存储结果，提升代码的可读性和整洁度。第三部分：排序与搜索算法（21-30例）例21：冒泡排序（升序，基础排序算法）c

#include<stdio.h>

#defineN10

voidbubbleSort(intarr[],intn){

inti,j,temp;

//外层循环：控制排序轮数，共n-1轮

for(i=0;i<n-1;i++){

//内层循环：每轮对比相邻元素，将大的元素“冒泡”到末尾

for(j=0;j<n-1-i;j++){

if(arr[j]>arr[j+1]){

//交换相邻元素

temp=arr[j];

arr[j]=arr[j+1];

arr[j+1]=temp;

}

}

}

}

intmain(void){

intarr[N],i;

printf("请输入%d个整数：\n",N);

for(i=0;i<N;i++){

scanf("%d",&arr[i]);

}

bubbleSort(arr,N);//调用冒泡排序函数

printf("冒泡排序（升序）后：");

for(i=0;i<N;i++){

printf("%d",arr[i]);

}

printf("\n");

return0;

}

说明：掌握冒泡排序的核心原理（相邻元素对比交换，逐步将最大值/最小值移动到数组末尾），理解双重循环的作用，注意内层循环的边界优化（每轮减少一次对比）。例22：选择排序（升序，简洁排序算法）c

#include<stdio.h>

#defineN10

voidselectSort(intarr[],intn){

inti,j,minIndex,temp;

//外层循环：控制待排序元素的起始位置

for(i=0;i<n-1;i++){

minIndex=i;//假设当前位置是最小值的索引

//内层循环：找到待排序区间的最小值索引

for(j=i+1;j<n;j++){

if(arr[j]<arr[minIndex]){

minIndex=j;//更新最小值索引

}

}

//交换当前位置与最小值位置的元素

temp=arr[i];

arr[i]=arr[minIndex];

arr[minIndex]=temp;

}

}

intmain(void){

intarr[N],i;

printf("请输入%d个整数：\n",N);

for(i=0;i<N;i++){

scanf("%d",&arr[i]);

}

selectSort(arr,N);

printf("选择排序（升序）后：");

for(i=0;i<N;i++){

printf("%d",arr[i]);

}

printf("\n");

return0;

}

说明：掌握选择排序的核心原理（找到待排序区间的最值，与当前位置交换），对比冒泡排序，理解选择排序交换次数更少的优势。例23：插入排序（升序，适合小规模数据）c

#include<stdio.h>

#defineN10

voidinsertSort(intarr[],intn){

inti,j,temp;

//外层循环：从第二个元素开始（第一个元素默认有序）

for(i=1;i<n;i++){

temp=arr[i];//保存当前待插入的元素

j=i-1;

//内层循环：找到待插入位置（比temp大的元素后移）

while(j>=0&&arr[j]>temp){

arr[j+1]=arr[j];

j--;

}

arr[j+1]=temp;//将temp插入到正确位置

}

}

intmain(void){

intarr[N],i;

printf("请输入%d个整数：\n",N);

for(i=0;i<N;i++){

scanf("%d",&arr[i]);

}

insertSort(arr,N);

printf("插入排序（升序）后：");

for(i=0;i<N;i++){

printf("%d",arr[i]);

}

printf("\n");

return0;

}

说明：掌握插入排序的核心原理（将待插入元素插入到已排序区间的正确位置），理解“元素后移”的逻辑，适合小规模数据排序，效率高于冒泡和选择排序。例24：快速排序（升序，高效排序算法）c

#include<stdio.h>

//交换两个整数的值

voidswap(int*a,int*b){

inttemp=*a;

*a=*b;

*b=temp;

}

//分区函数：返回基准值的正确索引

intpartition(intarr[],intleft,intright){

intpivot=arr[right];//选择最右侧元素作为基准值

inti=left-1;//i指向小于基准值的区域末尾

for(intj=left;j<right;j++){

//找到小于基准值的元素，交换到左侧区域

if(arr[j]<=pivot){

i++;

swap(&arr[i],&arr[j]);

}

}

//将基准值放到正确位置（左侧全小于，右侧全大于）

swap(&arr[i+1],&arr[right]);

returni+1;

}

//快速排序递归函数

voidquickSort(intarr[],intleft,intright){

if(left<right){

intpivotIndex=partition(arr,left,right);//分区，得到基准值索引

quickSort(arr,left,pivotIndex-1);//递归排序左半部分

quickSort(arr,pivotIndex+1,right);//递归排序右半部分

}

}

intmain(void){

intarr[]={12,35,8,7,2,10,4,9,15,6};

intn=sizeof(arr)/sizeof(arr[0]);//计算数组长度

printf("排序前：");

for(inti=0;i<n;i++){

printf("%d",arr[i]);

}

printf("\n");

quickSort(arr,0,n-1);

printf("快速排序（升序）后：");

for(inti=0;i<n;i++){

printf("%d",arr[i]);

}

printf("\n");

return0;

}

说明：掌握快速排序的核心原理（分治法+基准值分区），理解递归调用的逻辑，掌握指针传递实现元素交换的方法，快速排序是平均效率最高的基础排序算法。例25：顺序查找（基础查找算法，适合无序数组）c

#include<stdio.h>

#include<stdbool.h>

//顺序查找：返回目标元素的索引，未找到返回-1

intsequentialSearch(intarr[],intn,inttarget){

for(inti=0;i<n;i++){

if(arr[i]==target){

returni;//找到目标，返回索引

}

}

return-1;//未找到

}

intmain(void){

intarr[]={12,35,8,7,2,10,4,9,15,6};

intn=sizeof(arr)/sizeof(arr[0]);

inttarget;

printf("请输入要查找的整数：");

scanf("%d",&target);

intindex=sequentialSearch(arr,n,target);

if(index!=-1)

printf("找到目标元素，索引为：%d\n",index);

else

printf("未找到目标元素。\n");

return0;

}

说明：掌握顺序查找的核心原理（逐元素遍历对比），理解返回值的设计（索引/(-1)），适合无序数组，优点是逻辑简单，缺点是效率较低。例26：二分查找（高效查找算法，适合有序数组）c

#include<stdio.h>

#include<stdbool.h>

//二分查找：数组必须有序，返回目标元素的索引，未找到返回-1

intbinarySearch(intarr[],intn,inttarget){

intleft=0,right=n-1,mid;

while(left<=right){

mid=(left+right)/2;//计算中间索引（避免溢出可写为left+(right-left)/2）

if(arr[mid]==target){

returnmid;//找到目标，返回索引

}elseif(arr[mid]<target){

left=mid+1;//目标在右半部分，调整左边界

}else{

right=mid-1;//目标在左半部分，调整右边界

}

}

return-1;//未找到

}

intmain(void){

intarr[]={2,4,6,7,8,9,10,12,15,35};//必须是有序数组

intn=sizeof(arr)/sizeof(arr[0]);

inttarget;

printf("请输入要查找的整数：");

scanf("%d",&target);

intindex=binarySearch(arr,n,target);

if(index!=-1)

printf("找到目标元素，索引为：%d\n",index);

else

printf("未找到目标元素。\n");

return0;

}

说明：掌握二分查找的核心原理（分半缩小查找范围），注意前提条件（数组必须有序），理解边界条件的控制（left≤right），对比顺序查找，体会二分查找的高效性（时间复杂度更低）。例27：排序后去重（去除数组中的重复元素）c

#include<stdio.h>

#defineN10

//冒泡排序（升序）

voidbubbleSort(intarr[],intn){

inti,j,temp;

for(i=0;i<n-1;i++){

for(j=0;j<n-1-i;j++){

if(arr[j]>arr[j+1]){

temp=arr[j];

arr[j]=arr[j+1];

arr[j+1]=temp;

}

}

}

}

//去重：返回去重后的数组长度

intremoveDuplicates(intarr[],intn){

if(n==0)return0;

intindex=0;//去重后数组的索引

//遍历数组，跳过重复元素

for(inti=1;i<n;i++){

if(arr[i]!=arr[index]){

index++;

arr[index]=arr[i];

}

}

returnindex+1;//去重后的长度

}

intmain(void){

intarr[N]={1,2,2,3,3,3,4,5,5,6};

intn=N;

printf("去重前：");

for(inti=0;i<n;i++){

printf("%d",arr[i]);

}

printf("\n");

bubbleSort(arr,n);//先排序，便于去重

intnewLen=removeDuplicates(arr,n);

printf("去重后：");

for(inti=0;i<newLen;i++){

printf("%d",arr[i]);

}

printf("\n去重后的数组长度：%d\n",newLen);

return0;

}

说明：掌握“排序+去重”的思路，理解去重的核心逻辑（跳过重复元素，保留唯一元素），学会返回去重后的数组长度，便于后续操作。例28：合并两个有序数组（合并为一个有序数组）c

#include<stdio.h>

//合并两个有序数组（升序），result存储合并后的结果

voidmergeTwoSortedArrays(intarr1[],intlen1,intarr2[],intlen2,intresult[]){

inti=0,j=0,k=0;

//双指针法：分别遍历两个数组，对比元素大小，依次放入result

while(i<len1&&j<len2){

if(arr1[i]<=arr2[j]){

result[k++]=arr1[i++];

}else{

result[k++]=arr2[j++];

}

}

//处理arr1中剩余的元素

while(i<len1){

result[k++]=arr1[i++];

}

//处理arr2中剩余的元素

while(j<len2){

result[k++]=arr2[j++];

}

}

intmain(void){

intarr1[]={1,3,5,7,9};

intarr2[]={2,4,6,8,10};

intlen1=sizeof(arr1)/sizeof(arr1[0]);

intlen2=sizeof(arr2)/sizeof(arr2[0]);

intresult[len1+len2];//合并后的数组，长度为两个数组长度之和

mergeTwoSortedArrays(arr1,len1,arr2,len2,result);

printf("合并后的有序数组：");

for(inti=0;i<len1+len2;i++){

printf("%d",result[i]);

}

printf("\n");

return0;

}

说明：掌握双指针法合并有序数组的思路，理解三个循环的作用（对比合并、处理剩余元素），该思路是归并排序的核心基础。例29：求数组中出现次数最多的元素（众数）c

#include<stdio.h>

#defineN10

intmain(void){

intarr[N],i,j,count,maxCount=0,mode;

printf("请输入%d个整数：\n",N);

for(i=0;i<N;i++){

scanf("%d",&arr[i]);

}

//遍历每个元素，统计出现次数

for(i=0;i<N;i++){

count=1;//初始化为1（当前元素本身）

for(j=i+1;j<N;j++){

if(arr[j]==arr[i]){

count++;

}

}

//更新最大次数和众数

if(count>maxCount){

maxCount=count;

mode=arr[i];

}

}

printf("数组中出现次数最多的元素（众数）是：%d，出现了%d次\n",mode,maxCount);

return0;

}

说明：掌握双重循环统计元素出现次数的方法，理解计数器和最大次数变量的使用，注意若有多个元素出现次数相同，该方法返回第一个出现的众数。例30：数组元素的平移（右移k位，如右移2位：12345→45123）c

#include<stdio.h>

#defineN5

//反转数组的指定区间[left,right]

voidreverse(intarr[],intleft,intright){

inttemp;

while(left<right){

temp=arr[left];

arr[left]=arr[right];

arr[right]=temp;

left++;

right--;

}

}

//数组右移k位（高效方法，避免多次移动）

voidrightShift(intarr[],intn,intk){

k=k%n;//处理k大于n的情况（右移n位等于没移）

if(k==0)return;

//三步反转法：1.反转整个数组2.反转前k位3.反转后n-k位

reverse(arr,0,n-1);

reverse(arr,0,k-1);

reverse(arr,k,n-1);

}

intmain(void){

intarr[N]={1,2,3,4,5};

i