经典C语言程序100例

经典C语言程序100例说明：本文档包含100例经典C语言程序，按基础语法、字符串与数组、排序算法、数据结构等模块分类，每例均提供完整可运行代码、题目说明及核心思路解析，适配C99及以上标准编译器（如GCC，编译命令：gcc文件名.c-std=c99-o文件名），适合C语言初学者入门练习及进阶者巩固提升，可直接复制到Word文档中编辑使用。第一部分：基础语法（例1-10）例1：HelloWorld（最基础程序）题目：输出"Hello,World!"，熟悉C语言基本结构。代码：c

#include<stdio.h>

intmain(void){

printf("Hello,World!\n");//输出语句，\n表示换行

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

}说明：C语言入门第一个程序，包含头文件stdio.h（提供输入输出功能）、主函数main（程序入口），printf函数用于屏幕输出，分号表示语句结束。例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;//此时b=(a^b)^b=a^0=a

a=a^b;//此时a=(a^b)^a=b^0=b

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

return0;

}说明：异或运算符（^）的核心特性是“相同为0，不同为1”，无需临时变量即可完成交换，适用于整数交换场景，效率较高。例3：递归实现阶乘题目：从键盘输入一个整数，使用递归函数计算其阶乘（n!=n×(n-1)×...×1，0!=1）。代码：c

#include<stdio.h>

//递归函数：计算n的阶乘

longlongfactorial(intn){

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

}

intmain(void){

intn;

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

scanf("%d",&n);

//使用longlong类型，避免阶乘值过大导致溢出（适用于n≤20）

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

return0;

}说明：递归函数即自身调用自身，需明确终止条件（否则会陷入死循环）；longlong类型可存储更大的整数，避免阶乘计算溢出。例4：迭代实现斐波那契数列题目：从键盘输入斐波那契数列的项数，使用迭代方式输出该数列（斐波那契数列：0,1,1,2,3,5,...，前两项为0和1，后续每项为前两项之和）。代码：c

#include<stdio.h>

intmain(void){

intn;

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

scanf("%d",&n);

longlonga=0,b=1,temp;//a存储前一项，b存储后一项，temp临时变量

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

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

printf("%lld",a);

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

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

b=temp;//更新b为计算出的下一项

}

printf("\n");

return0;

}说明：迭代方式相比递归，效率更高（避免重复计算），适合计算项数较多的斐波那契数列；同样使用longlong类型防止溢出。例5：判断一个整数是否为质数题目：从键盘输入一个整数，判断该数是否为质数（质数：大于1的整数，除了1和自身外，不能被其他整数整除）。代码：c

#include<stdio.h>

#include<math.h>//提供sqrt函数（求平方根）

#include<stdbool.h>//提供bool类型（true/false）

//判断n是否为质数，是则返回true，否则返回false

boolisPrime(intn){

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

//优化：只需判断到sqrt(n)，因为大于sqrt(n)的因子会与小于sqrt(n)的因子成对出现

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

if(n%i==0)//能被i整除，不是质数

returnfalse;

}

returntrue;

}

intmain(void){

intn;

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

scanf("%d",&n);

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

return0;

}说明：利用math.h头文件中的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("区间内的质数有：\n");

//遍历区间内的所有数，逐个判断是否为质数

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

if(isPrime(i))

printf("%d",i);

}

printf("\n");

return0;

}说明：复用例5的isPrime函数，通过循环遍历指定区间，筛选出所有质数，体现函数的复用性，代码结构更清晰。例7：计算两个正整数的最大公约数和最小公倍数题目：从键盘输入两个正整数，利用欧几里得算法（辗转相除法）计算它们的最大公约数（GCD），并根据公式计算最小公倍数（LCM=两数乘积/最大公约数）。代码：c

#include<stdio.h>

//欧几里得算法：求a和b的最大公约数

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);

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

//最小公倍数=两数乘积/最大公约数，先除后乘避免溢出

printf("最小公倍数：%d\n",a/g*b);

return0;

}说明：欧几里得算法的核心是“gcd(a,b)=gcd(b,a%b)”，递归实现简洁高效；最小公倍数计算采用“先除后乘”，避免两数乘积过大导致溢出。例8：反转一个整数题目：从键盘输入一个整数，将其各位数字反转（如输入123，输出321；输入-456，输出-654）。代码：c

#include<stdio.h>

intmain(void){

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

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

scanf("%d",&n);

intoriginal=n;//保存原始值，用于判断正负

//循环提取n的最后一位数字，拼接至rev

while(n!=0){

rev=rev*10+n%10;//提取最后一位，拼接

n/=10;//去掉最后一位

}

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

return0;

}说明：利用循环提取整数的最后一位（n%10），通过“rev=rev*10+最后一位”实现反转，无需判断正负（负号会自动保留）。例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&&original>=0)

printf("是回文数。\n");

else

printf("不是回文数。\n");

return0;

}说明：基于整数反转的逻辑，通过比较原始值与反转后的值，判断是否为回文数；注意负数一定不是回文数（如-121反转后为-121，但负号导致正读与反读不同）。例10：计算一个整数的各位数字之和题目：从键盘输入一个整数，计算其各位数字之和（如输入123，输出6；输入-456，输出15）。代码：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>//提供strlen函数（计算字符串长度）

intmain(void){

charstr[100];//定义字符数组，存储字符串（最多99个字符+1个结束符'\0'）

printf("请输入一个字符串（不含空格）：");

scanf("%s",str);//输入字符串，无需加&（数组名本身就是地址）

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

//strlen函数计算字符串长度（不包含结束符'\0'）

printf("字符串的长度是：%zu\n",strlen(str));

return0;

}说明：字符串在C语言中以字符数组形式存储，结束标志为'\0'（自动添加）；scanf输入字符串时，遇到空格、回车会停止输入；strlen函数用于计算字符串有效长度。例12：字符串反转题目：从键盘输入一个字符串，将其反转后输出（如输入"abcde"，输出"edcba"）。代码：c

#include<stdio.h>

#include<string.h>

intmain(void){

charstr[100],temp;

intlen,i;

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

scanf("%s",str);

len=strlen(str);//获取字符串长度

//首尾交换：i从0开始，j从len-1开始，直到i<j

for(i=0;i<len/2;i++){

temp=str[i];

str[i]=str[len-1-i];

str[len-1-i]=temp;

}

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

return0;

}说明：通过首尾指针（或索引）交换字符，循环次数为字符串长度的一半，效率较高；无需额外数组，直接在原数组上修改，节省内存。例13：判断一个字符串是否为回文字符串题目：从键盘输入一个字符串，判断该字符串是否为回文字符串（正读和反读相同，如"abba"、"abcba"）。代码：c

#include<stdio.h>

#include<string.h>

intmain(void){

charstr[100];

intlen,i,flag=1;//flag=1表示是回文，0表示不是

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

scanf("%s",str);

len=strlen(str);

//首尾对比，只要有一对字符不相等，就不是回文

for(i=0;i<len/2;i++){

if(str[i]!=str[len-1-i]){

flag=0;

break;//提前退出循环，提升效率

}

}

if(flag==1)

printf("是回文字符串。\n");

else

printf("不是回文字符串。\n");

return0;

}说明：利用首尾对比的逻辑，一旦发现不相等的字符，立即设置flag为0并退出循环，避免无效计算；适用于判断短字符串的回文属性。例14：统计字符串中大写字母、小写字母、数字和其他字符的个数题目：从键盘输入一个字符串，统计其中大写字母、小写字母、数字和其他字符（如标点、空格）的个数。代码：c

#include<stdio.h>

#include<string.h>

intmain(void){

charstr[100];

intlen,i;

intupper=0,lower=0,digit=0,other=0;//分别统计四类字符个数

printf("请输入一个字符串（可包含空格）：");

getchar();//吸收scanf残留的回车符

fgets(str,100,stdin);//读取包含空格的字符串

len=strlen(str);

//遍历字符串，判断每个字符的类型

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

if(str[i]>='A'&&str[i]<='Z')

upper++;

elseif(str[i]>='a'&&str[i]<='z')

lower++;

elseif(str[i]>='0'&&str[i]<='9')

digit++;

elseif(str[i]!='\n')//排除fgets读取的换行符

other++;

}

printf("大写字母：%d个\n",upper);

printf("小写字母：%d个\n",lower);

printf("数字：%d个\n",digit);

printf("其他字符：%d个\n",other);

return0;

}说明：使用fgets函数读取包含空格的字符串（scanf无法读取空格）；通过ASCII码范围判断字符类型，注意排除fgets自动读取的换行符'\n'。例15：拼接两个字符串题目：从键盘输入两个字符串，将第二个字符串拼接在第一个字符串后面，输出拼接后的结果（模拟strcat函数功能）。代码：c

#include<stdio.h>

#include<string.h>

intmain(void){

charstr1[200],str2[100];//str1需足够大，容纳两个字符串

inti=0,j=0;

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

scanf("%s",str1);

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

scanf("%s",str2);

//找到str1的结束符'\0'的位置

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

i++;

}

//将str2的字符逐个复制到str1的结束符后面

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

str1[i]=str2[j];

i++;

j++;

}

str1[i]='\0';//拼接后添加结束符，避免字符串乱码

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

return0;

}说明：手动模拟strcat函数的实现逻辑，先定位第一个字符串的结束符，再将第二个字符串的字符逐个复制，最后添加结束符；注意str1的数组大小要足够，避免溢出。例16：比较两个字符串的大小（模拟strcmp函数）题目：从键盘输入两个字符串，比较它们的大小（按ASCII码顺序，相同返回0，第一个大于第二个返回1，否则返回-1）。代码：c

#include<stdio.h>

#include<string.h>

intstrCompare(charstr1[],charstr2[]){

inti=0;

//遍历两个字符串，直到遇到不同字符或结束符

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

if(str1[i]>str2[i])

return1;

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

return-1;

i++;

}

//若前面字符都相同，比较字符串长度

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

return0;//长度相同，字符相同

elseif(str1[i]=='\0')

return-1;//str1更短

else

return1;//str2更短

}

intmain(void){

charstr1[100],str2[100];

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

scanf("%s",str1);

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

scanf("%s",str2);

intresult=strCompare(str1,str2);

if(result==0)

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

elseif(result==1)

printf("第一个字符串大于第二个字符串。\n");

else

printf("第一个字符串小于第二个字符串。\n");

return0;

}说明：手动实现strcmp函数的核心逻辑，先比较对应位置的字符，再比较字符串长度；返回值与标准strcmp函数一致，便于理解字符串比较的原理。例17：查找字符串中指定字符的出现次数题目：从键盘输入一个字符串和一个指定字符，统计该字符在字符串中出现的次数（区分大小写）。代码：c

#include<stdio.h>

#include<string.h>

intmain(void){

charstr[100],ch;

intlen,i,count=0;

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

scanf("%s",str);

printf("请输入要查找的字符：");

getchar();//吸收scanf残留的回车符

scanf("%c",&ch);

len=strlen(str);

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

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

if(str[i]==ch)

count++;

}

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

return0;

}说明：通过循环遍历字符串的每个字符，与指定字符对比，累加匹配次数；注意区分大小写（如'A'和'a'视为不同字符），若需不区分大小写，可先将字符串和指定字符统一转为大写或小写。例18：删除字符串中指定的字符题目：从键盘输入一个字符串和一个指定字符，删除字符串中所有该字符，输出删除后的字符串。代码：c

#include<stdio.h>

#include<string.h>

intmain(void){

charstr[100],ch;

inti=0,j=0;

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

scanf("%s",str);

printf("请输入要删除的字符：");

getchar();

scanf("%c",&ch);

//遍历字符串，将不等于ch的字符保留，覆盖原数组

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

if(str[i]!=ch){

str[j]=str[i];

j++;

}

i++;

}

str[j]='\0';//添加结束符，避免乱码

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

return0;

}说明：利用双指针（i遍历原字符串，j记录保留字符的位置），将不需要删除的字符复制到原数组的前面，最后添加结束符；无需额外数组，直接在原数组上修改，效率较高。例19：一维数组的遍历与求和题目：从键盘输入10个整数，存入一维数组，遍历数组并计算所有元素的和、平均值。代码：c

#include<stdio.h>

intmain(void){

intarr[10];//定义一维数组，存储10个整数

inti,sum=0;

floatavg;//平均值可能为小数，用float类型

printf("请输入10个整数：\n");

//输入10个整数，存入数组

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

printf("请输入第%d个整数：",i+1);

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

sum+=arr[i];//累加求和

}

//遍历数组，输出所有元素

printf("数组中的元素为：");

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

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

}

printf("\n");

avg=sum/10.0;//除以10.0，确保结果为小数

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

printf("数组元素的平均值为：%.2f\n",avg);//保留2位小数

return0;

}说明：一维数组的基本操作，包括输入、遍历、求和、求平均值；注意除以10.0（而非10），避免整数除法导致结果失真；保留2位小数使输出更规范。例20：查找一维数组中的最大值和最小值题目：从键盘输入10个整数，存入一维数组，查找并输出数组中的最大值和最小值及其所在的索引（索引从0开始）。代码：c

#include<stdio.h>

intmain(void){

intarr[10];

inti,max,min,max_idx,min_idx;

printf("请输入10个整数：\n");

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

printf("请输入第%d个整数：",i+1);

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

}

//初始化最大值、最小值为数组第一个元素，索引为0

max=arr[0];

min=arr[0];

max_idx=0;

min_idx=0;

//遍历数组，更新最大值和最小值及其索引

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

if(arr[i]>max){

max=arr[i];

max_idx=i;

}

if(arr[i]<min){

min=arr[i];

min_idx=i;

}

}

printf("数组中的最大值为：%d，所在索引为：%d\n",max,max_idx);

printf("数组中的最小值为：%d，所在索引为：%d\n",min,min_idx);

return0;

}说明：先将最大值和最小值初始化为数组第一个元素，再通过循环遍历数组，逐个对比更新；同时记录最大值和最小值的索引，满足题目要求，逻辑清晰易懂。第三部分：排序与搜索算法（例21-30）例21：冒泡排序（升序）题目：从键盘输入10个整数，存入一维数组，使用冒泡排序算法将数组按升序排列并输出。代码：c

#include<stdio.h>

intmain(void){

intarr[10];

inti,j,temp;

//输入10个整数

printf("请输入10个整数：\n");

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

printf("请输入第%d个整数：",i+1);

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

}

//冒泡排序：外层循环控制排序轮数，内层循环控制每轮比较次数

for(i=0;i<9;i++){//10个元素，需要9轮排序

for(j=0;j<9-i;j++){//每轮后，最大的元素已“冒泡”到末尾，减少比较次数

if(arr[j]>arr[j+1]){//相邻元素比较，逆序则交换

temp=arr[j];

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

arr[j+1]=temp;

}

}

}

//输出排序后的数组

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

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

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

}

printf("\n");

return0;

}说明：冒泡排序的核心是“相邻元素对比，逆序则交换”，每轮排序将最大的元素移动到数组末尾；外层循环控制轮数，内层循环控制每轮的比较次数，逐步减少比较次数，提升效率。例22：冒泡排序（降序）题目：从键盘输入10个整数，存入一维数组，使用冒泡排序算法将数组按降序排列并输出。代码：c

#include<stdio.h>

intmain(void){

intarr[10];

inti,j,temp;

printf("请输入10个整数：\n");

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

printf("请输入第%d个整数：",i+1);

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

}

//降序排序：只需将相邻元素比较的条件改为arr[j]<arr[j+1]

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

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

if(arr[j]<arr[j+1]){//逆序（升序）则交换，实现降序

temp=arr[j];

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

arr[j+1]=temp;

}

}

}

printf("冒泡排序（降序）后的数组：");

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

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

}

printf("\n");

return0;

}说明：与升序冒泡排序相比，仅修改相邻元素的比较条件（将“>”改为“<”），即可实现降序排列；逻辑简单，适合初学者理解排序算法的灵活性。例23：选择排序（升序）题目：从键盘输入10个整数，存入一维数组，使用选择排序算法将数组按升序排列并输出。代码：c

#include<stdio.h>

intmain(void){

intarr[10];

inti,j,temp,min_idx;//min_idx存储每轮最小值的索引

printf("请输入10个整数：\n");

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

printf("请输入第%d个整数：",i+1);

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

}

//选择排序：外层循环控制排序轮数，内层循环查找最小值索引

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

min_idx=i;//假设当前索引为最小值索引

//查找从i到9的最小值索引

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

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

min_idx=j;

}

}

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

temp=arr[i];

arr[i]=arr[min_idx];

arr[min_idx]=temp;

}

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

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

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

}

printf("\n");

return0;

}说明：选择排序的核心是“每轮找到最小值（或最大值），与当前位置元素交换”，相比冒泡排序，减少了交换次数，效率更高；通过记录最小值索引，避免无效交换。例24：插入排序（升序）题目：从键盘输入10个整数，存入一维数组，使用插入排序算法将数组按升序排列并输出。代码：c

#include<stdio.h>

intmain(void){

intarr[10];

inti,j,temp;

printf("请输入10个整数：\n");

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

printf("请输入第%d个整数：",i+1);

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

}

//插入排序：从第二个元素开始，将其插入到前面已排序的合适位置

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

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

j=i-1;//j指向已排序部分的最后一个元素

//找到插入位置：将大于temp的元素向后移动

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

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

j--;

}

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

}

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

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

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

}

printf("\n");

return0;

}说明：插入排序的核心是“将未排序元素插入到已排序部分的合适位置”，模拟手工排序的过程；适合数据量较小、接近有序的场景，效率较高。例25：二分查找（有序数组）题目：将10个整数按升序存入一维数组，从键盘输入一个目标值，使用二分查找算法查找该值是否存在，若存在输出其索引，否则输出“不存在”。代码：c

#include<stdio.h>

intbinarySearch(intarr[],intlen,inttarget){

intleft=0,right=len-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;//未找到目标值，返回-1

}

intmain(void){

intarr[10]={1,3,5,7,9,11,13,15,17,19};//升序排列的数组

inttarget,index;

printf("请输入要查找的目标值：");

scanf("%d",&target);

index=binarySearch(arr,10,target);

if(index!=-1)

printf("目标值%d存在，所在索引为：%d\n",target,index);

else

printf("目标值%d不存在。\n",target);

return0;

}说明：二分查找的前提是数组有序，核心是“每次缩小一半查找范围”，效率远高于顺序查找；适用于数据量较大的有序数组，时间复杂度为O(log₂n)。例26：顺序查找（无序/有序数组）题目：从键盘输入10个整数，存入一维数组，再输入一个目标值，使用顺序查找算法查找该值是否存在，若存在输出其第一次出现的索引，否则输出“不存在”。代码：c

#include<stdio.h>

intsequentialSearch(intarr[],intlen,inttarget){

inti;

//遍历数组，逐个对比查找目标值

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

if(arr[i]==target)

returni;//找到目标值，返回第一次出现的索引

}

return-1;//未找到，返回-1

}

intmain(void){

intarr[10];

inti,target,index;

printf("请输入10个整数：\n");

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

printf("请输入第%d个整数：",i+1);

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

}

printf("请输入要查找的目标值：");

scanf("%d",&target);

index=sequentialSearch(arr,10,target);

if(index!=-1)

printf("目标值%d存在，第一次出现的索引为：%d\n",target,index);

else

printf("目标值%d不存在。\n",target);

return0;

}说明：顺序查找的核心是“逐个遍历数组，对比目标值”，无需数组有序，逻辑简单；但效率较低（时间复杂度为O(n)），适合数据量较小的场景。例27：快速排序（升序，递归实现）题目：从键盘输入10个整数，存入一维数组，使用快速排序算法将数组按升序排列并输出。代码：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){

intpivot_idx=partition(arr,left,right);//分区，获取基准值索引

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

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

}

}

intmain(void){

intarr[10];

inti;

printf("请输入10个整数：\n");

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

printf("请输入第%d个整数：",i+1);

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

}

quickSort(arr,0,9);//调用快速排序