C语言100个经典算法

C程序经典算法50例1.二分查找算法：在有序数组中查找指定元素。

2.冒泡排序算法：通过不断比较相邻元素并交换位置，将较大的元素向后冒泡。

3.快速排序算法：通过选择一个基准元素，将数组分割为左右两部分，并递归地对两部分进行快速排序。

4.插入排序算法：将数组划分为已排序和未排序两部分，每次从未排序中选择一个元素插入到已排序的合适位置。

5.选择排序算法：遍历数组，每次选择最小元素并放置在已排序部分的末尾。

6.希尔排序算法：将数组按照一定间隔进行分组并分别进行插入排序，然后逐步减小间隔并重复这个过程。

7.归并排序算法：将数组递归地划分为两部分，然后将两个有序的部分进行合并。

8.桶排序算法：将元素根据特定的映射函数映射到不同的桶中，然后对每个桶分别进行排序。

9.计数排序算法：统计每个元素的出现次数，然后根据计数进行排序。

10.基数排序算法：从低位到高位依次对元素进行排序。

11.斐波那契数列算法：计算斐波那契数列的第n项。

12.阶乘算法：计算给定数字的阶乘。

13.排列问题算法：生成给定数组的全排列。

14.组合问题算法：生成给定数组的所有组合。

15.最大连续子序列和算法：找出给定数组中和最大的连续子序列。

16.最长递增子序列算法：找出给定数组中的最长递增子序列。

17.最长公共子序列算法：找出两个给定字符串的最长公共子序列。

18.最短路径算法：计算给定有向图的最短路径。

19.最小生成树算法：构建给定连通图的最小生成树。

20.汉诺塔算法：将n个圆盘从一个柱子移动到另一个柱子的问题。

21.BFS算法：广度优先算法，用于图的遍历和查找最短路径。

22.DFS算法：深度优先算法，用于图的遍历和查找连通分量。

23.KMP算法：字符串匹配算法，用于查找一个字符串是否在另一个字符串中出现。

24.贪心算法：每次都选择当前情况下最优的方案，适用于求解一些最优化问题。

25.动态规划算法：将一个大问题划分为多个子问题，并通过子问题的解求解整个问题，适用于求解一些最优化问题。

C语言程序设计习题授课对象：信息奥赛辅导成员授课时间：题目:古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子,假如兔子都不死，问每个月的兔子总数为多少？__________________________________________________________________ 程序分析：兔子的规律为数列1,1,2，3,5，8，13，21…。

___________________________________________________________________程序源代码：main（）{long f1，f2；int i；f1=f2=1;for（i=1;i〈=20;i++){ printf(“％12ld %12ld"，f1,f2);if(i%2==0）printf（“\n")；/＊控制输出,每行四个＊/f1=f1+f2;/*前两个月加起来赋值给第三个月＊/f2=f1+f2;/＊前两个月加起来赋值给第三个月＊/}｝上题还可用一维数组处理，you try!题目：判断101—200之间有多少个素数，并输出所有素数.__________________________________________________________________ 程序分析:判断素数的方法：用一个数分别去除2到sqrt（这个数），如果能被整除，则表明此数不是素数，反之是素数.___________________________________________________________________程序源代码:＃include “math.h”main（）{int m，i，k，h=0,leap=1；printf（“\n”）；for(m=101;m〈=200;m++)｛k=sqrt（m+1）;for（i=2；i〈=k；i++)if（m%i==0)｛leap=0;break；}if（leap) {printf（“%-4d",m）；h++;if（h％10==0）printf（“\n”)；｝leap=1；｝printf(“\nThe total is %d"，h）；}题目：打印出所有的“水仙花数”,所谓“水仙花数"是指一个三位数,其各位数字立方和等于该数本身。

C语言常用算法1）。

整数的各位分离void inte(int n){int i;While{i=n%10;i=n/10;}}2）。

求最大最小值例如查找a[]数组中的最小值，n为数组的大小int func(int a[]，int n){int min=a[0];for（int i=0;i<n;i++）{if (min>a[i]) min=a[i];}return min;}3). 求阶乘long func(int n){int i;long t=1;for(i=2;i<=n;i++)t=t*i;return t;}4).判断某数为素数int prim(int n){int m;for(m=2;m<=sqrt(n);m++) if(n%m==0) return 0; return 1;}5).求最大公约数gcd(int m,int n)int t,r;if(m<n) {t=m;m=n;n=t;}while (n!=0){r=m%n;m=n;n=r;}return m;}6).求最小公倍数，两数之积除以最大公约数gcd(int m,int n)int t,r;if(m<n) {t=m;m=n;n=t;}while (n!=0){r=m%n;m=n;n=r;}return (m*n)/m;}7).数组元素逆置第一个与最后一个交换，倒数第二个与第二个交换exchange (int a[],int n){int i,t;for(i=0;i<n/2;i++){t=a[i];a[i]=a[n-i-1];a[n-i-1]=t;}}8).累加与累乘用c语言实现1+2+3+4+5+6+7+8+9+10的累加方法1:#include <stdio.h>void main( ){int i,sum;sum=0;for(i=1;i<=10;i++){sum=sum+i;}printf(“%d”,sum);}方法2:#include <stdio.h>void main( ){int i,sum;sum=0;i=1; while(i<=10)sum=sum+i;i=i+1；}printf(“%d”,sum);}累乘是把加号变乘号9）。

1.定积分近似计算：/*梯形法*/double integral(double a,double b,long n) { long i;double s,h,x;h=(b-a)/n;s=h*(f(a)+f(b))/2;x=a;for(i=1;i<n;i++){x+=h;s+=h*f(x) ;}return(s);}/*矩形法*/double integral(double a,double b,long n) { long i;double t=0,h,x;h=(b-a)/n;x=a;for(i=0;i<n;i++){t+=h*f(x);x+=h;}return(t);}2. 生成斐波那契数列：/*直接计算*/int fib(int n){ int i,f1=1,f2=1,f;for(i=3;i<=n;i++){f=f1+f2;f1=f2;f2=f;}if(n==1||n==2) return 1;else return f;}/*递归调用*/void fib(int n,int*s){ int f1,f2;if(n==1||n==2) *s=1;else{ fib(n-1,&f1);fib(n-2,&f2);*s=f1+f2;}}3.素数的判断：/*方法一*/for (t=1,i=2;i<n; i++)if(n%i==0) t=0;if(t) printf("%d is prime",n);/*方法二*/for (t=1,i=2;i<n&&t; i++)if(n%i==0) t=0;if(t) printf("%d is prime",n);/*方法三*/for (i=2;i<n; i++)if(n%i==0) break;if(i==n) printf("%d is prime",n); /*方法四*/for(t=1,i=2; i<=(int)sqrt(n); i++)if(n%i==0){t=0;break;}if(t) printf("%d is prime",n);4.反序数：/*求反序数*/long fan(long n){ long k;for(k=0;n>0;n/=10)k=10*k+n%10;return k;}/*求回文数*/int f(long n){ long k,m=n;for(k=0;n>0;n/=10)k=10*k+n%10;if(m==k) return 1;return 0;}/*求整数位数*/int f(long n){ int count;for(count=0;n>0;n/=10)count++;return count;}5.求最大公约数：/*方法一*/int gcd(int x,int y){ int z;z=x<y?x:y;while(!(x%z==0&&y%z==0))/*x%z||y%z*/ z--;return z;}/*方法二*/int gcd(int x,int y){int r;while((r=x%y)!=0){x=y;y=r;}return y;}/*方法三*/int gcd(int a ,int b){ int r ;if((r=a%b)==0)return b;elsereturn gcd(b,r);}6.数组常用算法：查找：/*线性查找*/int find(int num,int x[],int key){ int i,m=-1;for(i=0;i<num;i++)if(x[i]==key){m=i;break;}return m;}/*折半查找*/int find(int x[],int num,int key){ int m=-1,low=0,high=num-1,mid;while(low<=high){mid=(low+high)/2;if(x[mid]==key){m=mid;break;}else if(x[mid]>key) high=mid-1;else low=mid+1;}return m;}/*折半查找（递归）*/int b_search(int x[ ],int low,int high,int key) {int mid;mid=(low+high)/2;if(x[mid]==key) return mid;if(low>=high) return -1;else if(key<x[mid])return b_search(x,low,mid-1,key);elsereturn b_search(x,mid+1,high,key); }/*寻找子串*/int find(char *s1,char *s2){ int i,k=0;while(s1[i]==s2[i]) i++;if(s2[i]==0) return k;s1++;k++;return -1;}分词：/*方法一*/void fen(char s[][10],char str){ int i,j,k;for(i=0,j=0,k=0;str[i]!=0;i++)if(isalpha(a[i]))s[j][k++]=str[i];else {s[j][k]=0;k=0;j++;}}}/*方法二*/#include<stdio.h>#include<string.h>void main(){ int i=0,n=0;char s[80],*p;strcpy(s,"It is a book.");for(p=s;p!='\0';p++)if(*p=='')i=0;elseif(i==0){n++;i=1;}printf("%d\n",n);getch();}排序：/*插入法排序*/void sort(int a[],int n){ int i,j,t;for(i=1;i<n;i++){t=a[i];for(j=i-1;j>=0&&t<a[j];j--)a[j+1]=a[j];a[j]=t;}}/*归并排序*/#define x 10#define y 10void com(int *a,int *b,int *c){ int i,j,k;for(i=0,j=0,k=0;i<=x&&j<=y;){if(a[i]<b[j]){c[k++]=a[i];i++;}else{c[k++]=b[j];j++;}}if(i<x) for(k=k-1;i<x;i++)c[k++]=a[i];if(j<x) for(k=k-1;j<y;j++)c[k++]=a[j]; }/*交换法排序1 冒泡排序*/void sort(int a[],int n){ int i,j,t,flag;for(i=0;i<n-1;i++){flag=1;for(j=0;j<n-1-i;j++)if(a[j]>a[j+1]){t=a[j];a[j]=a[j+1];a[j+1]=t;flag=0;}if(flag) break;}}/*交换法排序2*/void sort(int a[],int n){ int i,j,t;for(i=0;i<n-1;i++)for(j=i+1;j<n;j++)if(a[i]>a[j]){t=a[i];a[i]=a[j];a[j]=t;}}/*选择法排序*/void sort(int a[],int n){ int i,j,point,t;for(i=0;i<n-1;i++){point=i;for(j=i+1;j<n;j++)if(a[point]<a[j]) point=j;if(point!=i){t=a[point];a[point]=a[i];a[i]=t;}}}7.一元非线性方程求根：/*牛顿迭代法求函数跟*/#include <stdio.h>#include <math.h>int main(void){ double x,x1,eps=1e-6,f,f1; /*误差为eps*/x=1.0; /*x=1.0是初值*/do{x1=x;f=6-x1*(5-x1*(4-3*x1)); /*f为f(x)函数*/f1=-5+x1*(8-9*x1); /*f1为f(x)的导函数*/x=x1-f/f1;f=6-x*(5-x*(4-3*x));}while(fabs(f)>=eps &&fabs(x-x1)>=eps);printf("x=%f",x);}/*二分法求函数跟*/#include <stdio.h>#include <math.h>double f(double x){ return 6-x*(5-x*(4-3*x)); /*f(x)函数*/}int main(void){ double a,b,c,x,eps=1e-6;do{scanf("%lf%lf",&a,&b);}while(f(a)*f(b)>0);if(fabs(f(a))<1e-6)x=a;else if (fabs(f(b))<1e-6)x=b;else {c=(b+a)/2;while(fabs(f(c))>eps&&fabs(b-a)>eps){if(f(a)*f(c)<0)b=c;elsea=c;c=(b+a)/2;}x=c;}printf("x=%f",x);}/*弦截法求函数跟*/c=(a*f(b)-b*f(a))/ (f(b)-f(a));while(fabs(f(c))>eps){if(f(a)*f(c)<0)b=c;elsea=c;c=(a*f(b)-b*f(a))/ (f(b)-f(a));}#include <stdio.h>void f();int main(void){ int x, loop=0;do{for(x=1;x<5;x++) {int x=2;printf("%d",x);}printf("%d ",x);f();loop++;}while(loop<1);getch();}void f(){ printf("%d",x++); }8.汉诺塔：#include<stdio.h>void Hanoi(int n, char A, char B, char C){if(n==1)printf("\n move %d from %c to %c",n,A,C);else{Hanoi(n-1,A,C,B);printf("\nmove %d from %c to %c",n,A,C);Hanoi(n-1,B, A, C);}}int main(void){ Hanoi(3,'A','B','C');getch();}9.建立链表：NODE *creat(void) /* void表示无参函数*/{NODE *head=NULL,*p1=NULL,*p2=NULL;long num;unsigned score;int n=0;do{scanf(“%ld%u”,&num,&score);if(num==0) break;n++;p1=(NODE *)malloc(sizeof(NODE));p1->data.num=num,p1->data.score=score;p1->next=NULL;if(n==1)head=p2=p1;else{p2->next=p1;p2=p1;}}while(1);return head;}10.级数的近似计算:#include <stdio.h>#include <math.h>int main(void){ double s=1,a=1,x,eps,f;int n,m;printf("input x and eps:");scanf ("%lf%lf",&x,&eps);for(n=1;fabs(a)>eps; n++){for(f=1,m=1;m<=n;m++)f*=m;a=pow(x,n)/f;s+=a;}printf("%f",s);}。

注意：切勿先计算 xn 及 n!，然后计算 它们的商。因为它们均可能是非常大的 数，尤其是整数n!可能溢出；再做除法， 又可能出现更大的误差。
14
符号变量的设计与应用
例1-3 编程实现输入一个整数，判断
其是否能被 3, 5或7整除，并输出以下
信息之一
1.能同时被3, 5, 7整除。
2.能被两个数（要指出哪两个数）整除。
6
程序编译、连接生成可执行文件 可执行文件的运行结果
7
练习
题目描述：假设a、b、c均为整数，且满足a，b， c 大于1，并且小于等于100，找出所有符合条件： “a的平方 + b的平方 = c的平方”的整数组。 输出描述：按a从小到大的顺序输出所有满足条件 的整数组（若a相同，则按b从小到大的顺序输出）， 每行一组，每一组数据的输出样式为：3*3 + 4*4 = 5*5 注意：
方法2：将计算与输出相分离
先完成所有的判断然后输出，使计算与输出两 个环节相分离
设计一个标志量与整数n对应，记录n被3, 5, 7整除的
情况。我们约定标志量的
二进制最低位：1表示n能被3整除，0表示n不能被3整除
二进制第2位：1表示n能被5整除，0表示n不能被5整除 二进制第3位：1表示n能被7整除，0表示n不能被7整除
19
int main() { int n; while(1) { cout << ”\n请输入一个整数（负数退出）: ”; cin >> n;
if(n<0) break; show_result(n);
} return 0;
}
20
逻辑判断类题型解法
例1-4 夏日炎炎，空调机走俏。5家空调机厂的产 品在一次质量评比活动中分获前5名。评前大家就 已知道E厂的肯定不是第2名和第3名，B厂不是第2 名就是第3名。 A厂的代表猜：E厂的产品稳获第1名。 B厂的代表猜：我厂可能获得第2名。 C厂的代表猜：A厂的质量最差。 D厂的代表猜：C厂的产品不是最好的。 E厂的代表猜：D厂会获得第1名。 评比结果公布后发现，只有获得第1名和第2名的两 个厂的代表猜对了。请编程给出A，B，C，D，E 各是多少名？

行距大于列距，不进行调节显示出来的将是椭圆*/
for(x=1;x<30-m;x++) printf(" ");
/*图形左侧空白控制*/
printf("*");
/*圆的左侧*/
for(;x<30+m;x++) printf(" ");
/*图形的空心部分控制*/
printf("*\\n");
/*圆的右侧*/
-- 作者：huang01 -- 发布时间：2004-10-21 17:00:24
--
7． 8.借书方案知多少
小明有五本新书，要借给A，B，C 三位小朋友，若每人每次只能借一本，则可以有多少种不同的借法？
*问题分析与算法设计
本问题实际上是一个排列问题，即求从5 个中取3 个进行排列的方法的总数。首先对五本书从1 至5 进行编号，然后使用穷举的
5．求最大数
问555555 的约数中最大的三位数是多少？ *问题分析与算法设计
根据约数的定义，对于一个整数N，除去1 和它自身外，凡能整除N 的数即为N 的约数。因此，最简单的方法是用2 到N-1 之间 的所有数去除N，即可求出N 的全部约数。本题只要求取约数中最大的三位数，则其取值范围可限制在100 到999 之间。 *程序说明与注释 #include<stdio.h> void main() {
{
printf("Input number %d=",i);
scanf("%d",&integer);
/*输入评委的评分*/
sum+=integer;

目录第一章数值处理1.1 19头牛 (1)1.2 分钱 (1)1.3 儿子做题 (1)1.4 乐队人数 (2)1.5 靶子趣谈 (2)1.6 里程碑 (3)1.7 位等差 (4)1.8 岁数 (5)1.9 打碎的鸡蛋 (6)1.10 分糖 (7)1.11 奖牌 (7)1.12 同等遗产 (8)1.13 菜票问题 (8)1.14 出售金鱼 (9)1.15 取苹果 (10)1.16 狐狸追兔 (10)1.17 报数 (11)1.18 娶公主 (12)1.19 递增牛群 (12)1.20 徒子徒孙 (13)第二章图形输出2.1 左旋方阵 (15)2.2 旋方阵 (16)2.3 螺阵 (18)2.4 蛇阵 (21)2.5 对角矩阵 (22)2.6 魔方阵 (24)2.7 倒三角 (25)2.8 函数曲线 (27)2.9 菱形1 (29)2.10 菱形2 (30)2.11 杨辉三角 (30)2.12 字母矩形 (32)2.13 字母菱形 (34)第三章数据处理3.2 求素数 (36)3.3 亲密数 (36)3.4 三非零数 (37)3.5 平方和 (37)3.6 数目平方 (38)3.7 四方定理 (39)3.8 求最值 (40)3.9 数字反序 (40)3.10 数值1 (40)3.11 数值问题 (41)3.12 十进制转为二进制 (42)3.13 十六进制转为十进制 (42)3.14 进制2 (43)3.15 尾零个数 (44)3.16 求7的34次方 (45)3.17 印度国王 (45)3.18 找最值 (46)3.19 连续合数 (47)3.20 特殊数列 (47)3.21 同和偶数 (48)3.22 环状素数 (49)3.23 回文素数对 (50)3.24 求双百 (51)3.25 素数算式 (52)3.26 外围之和 (53)第四章过程模拟 (54)4.1 称小球 (54)4.2 字符滑落 (56)4.3 抽奖 (56)4.4 选举 (57)4.5 算术1 (58)4.6 算术2 (59)4.7 分牌 (60)4.8 八皇后 (63)4.9 摆棋子 (66)4.10过河 (69)第五章算式求值 (75)5.1 整数相减 (76)5.2 大数相减 (77)5.3 实数之和 (78)5.4 大数相加 (80)5.5 括号配对 (81)5.6 大、中、小括号配对 (83)5.7 数字重组 (83)5.8 计算1 (85)5.9 优先级 (85)5.10 计算2 (86)5.11 计算器 (88)5.12 化简 (90)第六章文件、字符、指针处理6.1 自定义TYPE (92)6.2 记录排名 (92)6.3 记录排序 (94)6.4 排名次 (95)6.5 自定义COMP (97)6.6 自定义COPY (98)6.7 统计字母 (99)6.8 统计行数单词 (99)6.9 语法检查 (100)6.10 长度个数 (101)6.11 统计单词 (102)6.12细胞数目 (103)6.13最长路径 (106)第七章数字组合 (108)7.1 特殊矩阵 (108)7.2 对角线和 (109)7.3 矩阵鞍点 (110)7.4 特殊三角形 (111)7.5 古诗算式 (111)7.6 填数2 (113)第一章数值处理1.1 有一个老人在临死前把三个儿子叫到跟前，告诉他们把19头牛分了，老大分1/2，老二分1/4，老三分1/5，说完就死了.按当地习俗，不能宰牛.问三个儿子各能分多少?(19头牛.c)(答案:10，5，4) 分析：由于19与2、4、5都不能整除，所以就不能用平常的方法来解决这个问题。

C语言入门必学—10个经典C语言算法C语言是一种广泛使用的编程语言，具有高效、灵活和易学的特点。

它不仅在软件开发中被广泛应用，也是计算机科学专业的必修课。

在学习C语言的过程中，掌握一些经典的算法是非常重要的。

本文将介绍10个经典C语言算法，帮助读者更好地了解和掌握C语言。

一、冒泡排序算法（Bubble Sort）冒泡排序算法是最简单、也是最经典的排序算法之一。

它通过不断比较相邻的元素并交换位置，将最大（或最小）的元素逐渐“冒泡”到数组的最后（或最前）位置。

二、选择排序算法（Selection Sort）选择排序算法是一种简单但低效的排序算法。

它通过不断选择最小（或最大）的元素，并与未排序部分的第一个元素进行交换，将最小（或最大）的元素逐渐交换到数组的前面（或后面）。

三、插入排序算法（Insertion Sort）插入排序算法是一种简单且高效的排序算法。

它通过将数组分为已排序和未排序两个部分，依次将未排序部分的元素插入到已排序部分的合适位置。

四、快速排序算法（Quick Sort）快速排序算法是一种高效的排序算法。

它采用了分治的思想，通过将数组分为较小和较大两部分，并递归地对两部分进行排序，最终达到整个数组有序的目的。

五、归并排序算法（Merge Sort）归并排序算法是一种高效的排序算法。

它采用了分治的思想，将数组一分为二，递归地对两个子数组进行排序，并将结果合并，最终得到有序的数组。

六、二分查找算法（Binary Search）二分查找算法是一种高效的查找算法。

它通过不断将查找范围折半，根据中间元素与目标值的大小关系，缩小查找范围，最终找到目标值所在的位置。

七、递归算法（Recursive Algorithm）递归算法是一种通过自我调用的方式解决问题的算法。

在C语言中，递归算法常用于解决树的遍历、问题分解等情况。

八、斐波那契数列算法（Fibonacci Sequence）斐波那契数列是一列数字，其中每个数字都是前两个数字的和。

17.求菲玻那契级数的第n项。级数的前n项为： 1，1，1， 3，5，9，17… 项值通过函数值返回 main ( )函数。 例如，若 n = 15，则应输出：The value is: 2209。 #include <conio.h> #include <stdio.h> long fun ( int n ) { long a=1, b=1, c=1, d=1, k; /**********FOUND**********/ for (k=4; k<n; k++) k<=n { d = a+b+c; /**********FOUND**********/ a=b; b=c; c=d; a=b; b=c; c=d } /**********FOUND**********/ return k; return d; } main( ) { int n = 15;clrscr( );printf( "The value is: %ld\n", fun ( n ) );}
50.在一个一维整型数组中找出其中最大的数及其下标。 #define n 10 int fun(int *a,int *b,int n) { int *c,max=*a; for(c=a+1;c<a+n;c++) if(*c>max) { max=*c; /*******space*******/ *b=【?】;} c-a return max; } main() { int a[n],i,max,p=0; printf("please enter 10 integers:\n"); for(i=0;i<n;i++) /*******space*******/ scanf("%d",【?】); &a[i]或a+i /*******space*******/ max=fun(a,【?】,n); &p printf("max=%d,position=%d",max,p);

C语言程序设计的常用算法1.排序算法-冒泡排序：通过多次比较和交换来将最大（小）的数移到最后（前），时间复杂度为O(n^2)。

适用于数据较少、数据基本有序的情况。

- 快速排序：通过一趟排序将待排序序列分隔成独立的两部分，其中一部分的所有元素都比另一部分的所有元素小。

然后递归地对两部分进行排序，时间复杂度为O(nlogn)。

适用于大规模数据的排序。

-插入排序：将待排序序列分为已排序和未排序两部分，每次从未排序部分取一个元素插入到已排序部分的适当位置，时间复杂度为O(n^2)。

适用于数据量较小的排序场景。

- 归并排序：将待排序序列分为若干个子序列，分别进行排序，然后再将排好序的子序列合并成整体有序的序列，时间复杂度为O(nlogn)。

适用于需要稳定排序且对内存空间要求不高的情况。

2.查找算法-顺序查找：从头到尾依次对每个元素进行比较，直到找到目标元素或者遍历完整个序列。

时间复杂度为O(n)。

- 二分查找：对于有序序列，将序列的中间元素与目标元素进行比较，根据比较结果缩小查找范围，直到找到目标元素或者查找范围为空。

时间复杂度为O(logn)。

3.图算法-广度优先（BFS）：从给定的起始顶点开始，按照“先访问当前顶点的所有邻接顶点，再依次访问这些邻接顶点的所有未访问过的邻接顶点”的顺序逐层访问图中的所有顶点。

适用于寻找最短路径、连通性等问题。

-深度优先（DFS）：从给定的起始顶点开始，按照“先递归访问当前顶点的一个邻接顶点，再递归访问这个邻接顶点的一个邻接顶点，直到无法再继续递归”的方式遍历图中的所有顶点。

适用于寻找路径、判断连通性等问题。

4.动态规划算法-背包问题：给定一个背包容量和一组物品的重量和价值，选择一些物品装入背包，使得装入的物品总重量不超过背包容量，且总价值最大。

利用动态规划的思想可以通过构建二维数组来解决该问题。

-最长公共子序列（LCS）：给定两个序列，找出一个最长的子序列，且该子序列在两个原序列中的顺序保持一致。

c语言经典算法解析C语言作为一种广泛使用的编程语言，拥有许多经典算法，这些算法不仅在解决实际问题上非常高效，而且对于理解计算机科学的基本原理也至关重要。

本文将介绍一些C语言中常见的经典算法，并解析其实现原理。

1. 排序算法：排序是计算机科学中最基本的问题之一，C语言提供了多种排序算法的实现，例如冒泡排序、选择排序、插入排序、快速排序等。

这些算法以不同的方式对元素进行比较和交换，最终将数据按照一定的顺序排列。

2. 查找算法：查找算法用于在给定数据集中寻找特定的值。

C语言中常见的查找算法包括线性查找、二分查找、哈希查找等。

这些算法的实现原理各不相同，但都能在不同的数据规模下高效地找到目标值。

3. 图算法：图是由节点和边组成的一种数据结构，图算法用于解决与图相关的问题，例如最短路径查找、拓扑排序、最小生成树等。

C语言中可以使用邻接矩阵或邻接表等数据结构来表示图，并通过深度优先搜索或广度优先搜索等算法来进行相应的操作。

4. 字符串匹配算法：字符串匹配算法用于在一个长字符串中查找某个子串出现的位置。

常见的算法包括朴素字符串匹配算法、KMP算法、Boyer-Moore算法等。

这些算法通过不同的方式在给定的字符串中寻找匹配，从而提高查找的效率。

5. 动态规划算法：动态规划算法用于解决有重叠子问题和最优子结构特征的问题。

C语言中常用的动态规划算法有背包问题、最长公共子序列问题、最短路径问题等。

这些算法通过将大问题分解为小问题，并使用查表或记忆化搜索等技术来避免重复计算，从而提高算法的效率。

以上仅是C语言中一些经典算法的简要介绍和解析。

随着计算机科学的不断发展，还有许多其他算法可以探索和应用。

掌握这些经典算法的原理和实现有助于提高编程技能，同时也能够帮助理解计算机科学的核心概念。

通过不断学习和实践，我们可以在编程中灵活运用这些算法，解决实际问题。

c语言经典算法题
C语言经典算法题目涵盖了多个领域，包括排序、查找、递归、动态规划等。

以下是一些经典的C语言算法题目，它们对于提高编程能力和理解算法思想都是很有帮助的：
1. 冒泡排序：
实现冒泡排序算法，对一个数组进行升序或降序排序。

2. 快速排序：
实现快速排序算法，对一个数组进行升序或降序排序。

3. 选择排序：
实现选择排序算法，对一个数组进行升序或降序排序。

4. 二分查找：
实现二分查找算法，在有序数组中查找一个特定的元素。

5. 递归：
编写一个递归函数，计算斐波那契数列的第n 个数字。

6. 动态规划：
解决经典的动态规划问题，比如背包问题、最长公共子序列等。

7. 链表反转：
反转一个单链表或双链表。

8. 树的遍历：
实现二叉树的前序、中序和后序遍历。

9. 图的深度优先搜索（DFS）和广度优先搜索（BFS）：
实现图的深度优先搜索和广度优先搜索算法。

10. 最短路径算法：
实现Dijkstra算法或Floyd-Warshall算法来求解图中的最短路径。

11. 素数判断：
编写一个函数判断一个给定的数是否是素数。

12. 最大公约数和最小公倍数：
实现求两个数的最大公约数和最小公倍数的算法。

这些题目旨在帮助你熟悉常见的算法思想和数据结构，提高编程和问题求解的能力。

解决这些题目时，不仅要注重正确性，还要考虑算法的效率和优化。

c语言常用算法一、前言C语言是一种高效、快速的编程语言，被广泛应用于各种领域。

在C 语言中，算法是非常重要的部分，因为它们能够帮助我们解决许多实际问题。

本文将介绍C语言中常用的算法。

二、排序算法1.冒泡排序冒泡排序是一种简单的排序算法，它通过不断交换相邻两个元素的位置来将最大的元素放到最后。

具体实现如下：```void bubble_sort(int arr[], int n) {for (int i = 0; i < n - 1; i++) {for (int j = 0; j < n - i - 1; j++) {if (arr[j] > arr[j + 1]) {int temp = arr[j];arr[j] = arr[j + 1];}}}}```2.选择排序选择排序也是一种简单的排序算法，它通过不断选择最小元素并放到前面来完成排序。

具体实现如下：```void selection_sort(int arr[], int n) {for (int i = 0; i < n - 1; i++) {int min_index = i;for (int j = i + 1; j < n; j++) {if (arr[j] < arr[min_index]) {min_index = j;}}int temp = arr[i];arr[i] = arr[min_index];}}```3.插入排序插入排序是一种简单的排序算法，它通过将元素逐个插入到已排好序的序列中来完成排序。

具体实现如下：```void insertion_sort(int arr[], int n) {for (int i = 1; i < n; i++) {int key = arr[i];int j = i - 1;while (j >= 0 && arr[j] > key) {arr[j + 1] = arr[j];j--;}arr[j + 1] = key;}}```4.快速排序快速排序是一种高效的排序算法，它通过选取一个基准元素并将数组分为两部分来完成排序。

C语言常考算法一．累加与累乘(1) 累加与累乘例如1+2+3+4+5+6 (100)int add(int n){int sum=1;for(int i=1;i<=100;i++){sum=sum+i}return sum}例如1*2*3*4*+5*6 (100)int add(int n){int sum=1;for(int i=1;i<=100;i++){sum=sum*i}return sum}二．求最大、最小值(1) 求最大、最小值例如：查找a[ ]数组中的最小值,n为数组的大小 int func(int a[ ], int n) {int max=a[0];for(int i=0;i<n;i++){if(min>a[i]) min=a[i];}return min;}例如：查找a[ ]数组中的最大值 int func(int a[ ], int n){int max=a[0];for(int i=0;i<n;i++){if(max>a[i]) max=a[i];}return max;}三．求阶乘(1) 求阶乘long func(int n){int i;long t=1;for(i=2;i<=n;i++)t*=i;return t;}四．判断某数为素数(1) 判断某数为素数素数是指只能被自己和1整除的数int prime(int n){int m;for(m=2;m<=sqrt(n);m++)if(n%m==0) return 0; return 1;}五．求最大公约数(1) 求最大公约数欧几里得算法:gcd( int m, int n){int t,r;if(m<n) {t=m; m=n; n=t;} while(n!=0) {r=m%n;m=n;n=r;}return m;}六．求最小公倍数算法：两数之积除以最大公约数所得的值即为最小公倍数 gcd( int m, int n){int t,r;while(n!=0){r=m%n;m=n;n=r;}return （m*n）/m;}七．累加与累乘累加就是对若干个数求和,其最基本的思想就是”反复的做加法”,一般来说,计算机每次只处理两个数的相加运算,所以多个数相加必须通过多次的两两相加来实现例1:用c语言实现1+2+3+4+5+6+7+8+9+10的累加方法1:#include <stdio.h>void main( ){int i,sum;sum=0;for(i=1;i<=10;i++){sum=sum+i;}printf(“%d”,sum);}方法2:#include <stdio.h>void main( ){int i,sum;sum=0;i=1;while( i<=10){sum=sum+ii=i+1;}printf(“%d”,sum);}用c语言实现1*2*3*4*5*6*7*8*9*10的累加方法1:#include <stdio.h>void main( ){int i,sum;sum=1;for(i=1;i<=10;i++){sum=sum*i;}printf(“%f”,sum);}方法2:#include <stdio.h>void main( ){int i,sum;sum=1;i=1;while( i<=10){sum=sum*ii=i+1;}printf(“%f”,sum);}八．冒泡排序思想：相临的两个数两两比较，如果第一个数大于第二个数，两者交换位置，既将小的排前面，大的排后面sort(int a[ ], int n){int i,j, t;for(i=n-1;i>0;i--){for(j=0; j<=i; j++)if(a[j]>a[j+1]){t=a[j];a[j]=a[j+1];a[j+1]=t;}}九．整数的各位分离void inte(int n){int i;while(n){i=n%10;n=n/10;}}十．数组元素逆置第一个与最后一个交换，第二个与倒数第二个交换 exchange(int a[ ], int n){int i, t;for(i=0;i<n/2;i++) {t=a[i];a[i]=a[n-i-1];a[n-i-1]=t;}}。

C语言常用算法归纳C语言是一种常用的编程语言，广泛应用于各种计算机领域。

在C语言中，算法是一种解决问题的方法论，是实现程序的关键所在。

本文将介绍C语言常用的算法，并对其进行归纳总结。

1.排序算法排序算法是将一组数据按照一定的顺序重新排列的过程。

常见的排序算法包括冒泡排序、选择排序、插入排序、快速排序、归并排序等。

-冒泡排序：该算法比较相邻的两个元素，并将较大的元素向后移动，重复此过程直到序列有序。

-选择排序：该算法通过不断选择最小的元素，并放到已排序部分的末尾，重复此过程直到整个序列有序。

-插入排序：该算法将元素逐个插入到已排好序的序列中，重复此过程直到整个序列有序。

-快速排序：该算法通过选择一个基准元素，将元素分为两个分区，并对每个分区递归地快速排序，最终将整个序列有序。

-归并排序：该算法将序列分为两个部分，并对每个部分递归地归并排序，最后将两个有序的部分归并。

上述排序算法中，冒泡排序和选择排序的时间复杂度为O(n^2)，插入排序的时间复杂度为O(n^2)或O(n)，快速排序和归并排序的平均时间复杂度为O(nlogn)。

2.查找算法查找算法是在一组数据中找到指定的元素的过程。

常见的查找算法包括线性查找、二分查找、哈希查找等。

-线性查找：该算法从序列的首个元素开始，逐个比较元素，直到找到指定元素或遍历完整个序列。

-二分查找：该算法通过比较中间元素和目标元素的大小关系，逐渐缩小查找范围，最终找到目标元素。

-哈希查找：该算法通过将元素与哈希函数的运算结果关联，将元素存储在哈希表中；查询时，通过哈希函数确定元素的位置，从而快速查找。

二分查找的时间复杂度为O(logn)，哈希查找的平均时间复杂度为O(1)。

3.字符串算法字符串算法是对字符串进行处理和操作的一系列算法。

常见的字符串算法包括字符串复制、字符串连接、字符串比较、字符串截取等。

- 字符串复制：可以使用strcpy函数实现字符串复制。

例如，strcpy(dest, src)将将src字符串复制到dest字符串中。

第 1 页 c语言经典算法设计方法 经典算法设计方法 一、什么是算法 算法是一系列解决问题的清晰指令，也就是说，能够对一定规范的输入，在有限时间内获得所要求的输出。算法常常含有重复的步骤和一些比较或逻辑判断。如果一个算法有缺陷，或不适合于某个问题，执行这个算法将不会解决这个问题。不同的算法可能用不同的时间、空间或效率来完成同样的任务。一个算法的优劣可以用空间复杂度与时间复杂度来衡量。

算法的时间复杂度是指算法需要消耗的时间资源。一般来说，计算机算法是问题规模n的函数f(n)，算法执行的时间的增长率与f(n)的增长率正相关，称作渐进时间复杂度(Asymptotic Time Complexity)。时间复杂度用"O(数量级)"来表示，称为"阶"。常见的时间复杂度有：O(1)常数阶；O(log2n)对数阶；O(n)线性阶；O(n2)平方阶。

算法的空间复杂度是指算法需要消耗的空间资源。其计算和表示方法与时间复杂度类似，一般都用复杂度的渐近性来表示。同时间复杂度相比，空间复杂度的分析要简单得多。

二、算法设计的方法 1.递推法 递推法是利用问题本身所具有的一种递推关系求问题解的一种方法。设要求问题规模为N的解，当N=1时，解或为已知，或能非常方便地得到解。能采用递推法构造算法的问题有重要的递推性质，即当得到问题规模为i-1的解后，由问题的递推性质，能从已求得的规模为1，2，…，i-1的一系列解，构造出问题规模为I的解。这样，程序可从i=0或i=1出发，重复地，由已知至i-1规模的解，通过递推，获得规模为i的解，直至得到规模为N的解。

【问题】阶乘计算 问题描述：编写程序，对给定的n(n≦ 100)，计算并输出k的阶乘k！(k=1，2，…，n)的全部有效数字。

由于要求的整数可能大大超出一般整数的位数，程序用一维数组存储长整数，存储长整数数组的每个元素只存储长整数的一位数字。如有m位成整数N用数组a[]存储： 第 2 页