非常全的C语言常用算法
C语言七大算法

C语言七大算法一、概述算法是计算机程序设计中解决问题的方法和步骤的描述,是计算机科学的重要基础。
在计算机科学中,有许多经典的算法被广泛应用,并成为不可或缺的工具。
本文将介绍C语言中的七大经典算法,包括排序算法、查找算法、图算法、字符串算法、动态规划算法、贪心算法和分治算法。
二、排序算法排序是将一组元素按照特定规则进行重新排列的过程。
常见的排序算法包括冒泡排序、选择排序、插入排序、快速排序、归并排序等。
这些排序算法在C语言中都有相应的实现,并且各有特点和适用场景。
三、查找算法查找算法用于在一组数据中查找特定值的位置或判断是否存在。
常见的查找算法有线性查找、二分查找、哈希查找等。
这些算法在C语言中的实现可以帮助我们快速地定位目标值。
四、图算法图算法用于解决与图相关的问题,包括最短路径问题、最小生成树问题、拓扑排序等。
在C语言中,我们可以利用图的邻接矩阵或邻接表来实现相关的图算法。
五、字符串算法字符串算法主要用于解决字符串匹配、替换、拼接等问题。
在C语言中,我们可以使用字符串库函数来完成一些基本的字符串操作,例如字符串比较、复制、连接等。
六、动态规划算法动态规划算法是解决一类最优化问题的常用方法,它将问题分解为多个子问题,并通过保存已解决子问题的结果来避免重复计算。
在C语言中,我们可以使用动态规划算法来解决背包问题、最长公共子序列问题等。
七、贪心算法贪心算法是一种通过每一步的局部最优选择来达到全局最优的方法。
贪心算法通常在解决最优化问题时使用,它快速、简单,并且可以给出近似最优解。
C语言中可以使用贪心算法来解决霍夫曼编码、最小生成树等问题。
八、分治算法分治算法是一种将问题分解为多个相同或类似的子问题然后递归解决的方法。
常见的分治算法有快速排序、归并排序等。
在C语言中,我们可以使用分治算法来提高程序的效率和性能。
总结:本文介绍了C语言中的七大经典算法,包括排序算法、查找算法、图算法、字符串算法、动态规划算法、贪心算法和分治算法。
C语言常用算法集合

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);}。
C语言常用算法

1.迭代法:
一般的一元五次方程或更高次的方程,以及几乎所有的微分方程、超越方程问题都无法用解析方法通过求根公式来求解,人们只能用数值方法求其近似值。
用事先估计的一个根的初始值X0,通过迭代算式X K+1=G(X K)求出一个近似的X1,再由求出X2,从而或得一个求解序列{ X0, X1, X2,…..X n,…}来逼近方程f(x)=0根。
这种求解过程成为迭代。
X1 x2=G(x1)
X3=G(x2)
X4=G(x3)
………
Xn=G(XN-1)
fabs(xn- xn-1)<1e-6
Xn+1=G(XN)
2.递归法:
递归是指一个过程直接或间接的调用它自身,递归过程必须有一个终止条件
3.递推法:
算法从递推的初始条件出发,应用递推公式对问题进行求解。
如Fibonacci 数列存在递推关系:
F(1)=1, F(2)=1, F(3)=2,
F(n)= F(n-1)+ F(n-2), (n>2)
若需求第30项的值,则依据公式,从初始条件F(1)=1,F(2)=1出发,逐步求出F(3),F(4),……,直到求出F(30)。
C语言常用算法总结

C语言常用算法总结1、冒泡排序算法:冒泡排序是一种简单的排序算法,它重复地遍历要排序的序列,一次比较两个相邻的元素如果他们的顺序错误就把他们交换过来。
时间复杂度为O(n^2)。
2、快速排序算法:快速排序是一种基于分治的排序算法,通过递归的方式将数组划分为两个子数组,然后对子数组进行排序最后将排好序的子数组合并起来。
时间复杂度为O(nlogn)。
3、插入排序算法:插入排序是一种简单直观的排序算法,通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描找到相应位置并插入。
时间复杂度为O(n^2)。
4、选择排序算法:选择排序是一种简单的排序算法,每次循环选择未排序部分的最小元素,并放置在已排序部分的末尾。
时间复杂度为O(n^2)。
5、归并排序算法:归并排序是一种稳定的排序算法,基于分治思想,将数组递归地分为两个子数组,将子数组排序后再进行合并最终得到有序的数组。
时间复杂度为O(nlogn)。
6、堆排序算法:堆排序是一种基于完全二叉堆的排序算法,通过构建最大堆或最小堆,然后依次将堆顶元素与末尾元素交换再调整堆,得到有序的数组。
时间复杂度为O(nlogn)。
7、二分查找算法:二分查找是一种在有序数组中查找目标元素的算法,每次将待查找范围缩小一半,直到找到目标元素或范围为空。
时间复杂度为O(logn)。
8、KMP算法:KMP算法是一种字符串匹配算法,通过利用模式字符串的自重复性,避免不必要的比较提高匹配效率。
时间复杂度为O(m+n),其中m为文本串长度,n为模式串长度。
9、动态规划算法:动态规划是一种通过将问题分解为子问题,并通过组合子问题的解来求解原问题的方法。
动态规划算法通常使用内存空间来存储中间结果,从而避免重复计算。
时间复杂度取决于问题规模。
10、贪心算法:贪心算法是一种通过选择局部最优解来构建全局最优解的算法并以此构建最终解。
时间复杂度取决于问题规模。
11、最短路径算法:最短路径算法用于求解图中两个节点之间的最短路径,常见的算法包括Dijkstra算法和Floyd-Warshall算法。
非常全的C语言常用算法

一、基本算法1.交换(两量交换借助第三者)例1、任意读入两个整数,将二者的值交换后输出。
main(){int a,b,t;scanf("%d%d",&a,&b);printf("%d,%d\n",a,b);t=a; a=b; b=t;printf("%d,%d\n",a,b);}【解析】程序中加粗部分为算法的核心,如同交换两个杯子里的饮料,必须借助第三个空杯子。
假设输入的值分别为3、7,则第一行输出为3,7;第二行输出为7,3。
其中t为中间变量,起到“空杯子”的作用。
注意:三句赋值语句赋值号左右的各量之间的关系!【应用】例2、任意读入三个整数,然后按从小到大的顺序输出。
main(){int a,b,c,t;scanf("%d%d%d",&a,&b,&c);/*以下两个if语句使得a中存放的数最小*/if(a>b){ t=a; a=b; b=t; }if(a>c){ t=a; a=c; c=t; }/*以下if语句使得b中存放的数次小*/if(b>c) { t=b; b=c; c=t; }printf("%d,%d,%d\n",a,b,c);}2.累加累加算法的要领是形如“s=s+A”的累加式,此式必须出现在循环中才能被反复执行,从而实现累加功能。
“A”通常是有规律变化的表达式,s在进入循环前必须获得合适的初值,通常为0。
例1、求1+2+3+……+100的和。
main(){int i,s;s=0; i=1;while(i<=100){s=s+i; /*累加式*/i=i+1; /*特殊的累加式*/}printf("1+2+3+...+100=%d\n",s);}【解析】程序中加粗部分为累加式的典型形式,赋值号左右都出现的变量称为累加器,其中“i = i + 1”为特殊的累加式,每次累加的值为1,这样的累加器又称为计数器。
C语言入门必学—10个经典C语言算法

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)斐波那契数列是一列数字,其中每个数字都是前两个数字的和。
C语言常用算法总结

C语言常用算法模块的总结一、最大值,最小值问题教材page13/1.6、page36/2.4(2)、(3)、page98例5.1、5.2二、连乘连加问题 page113、114、115 page129/6.3 page129/6.4、6.5三、闰年算法 page17、 page107四、连续小数相加减 page18、 page124五、素数、整除问题 page18、 page124、 page126、 page127六、大小写字母转换、密码问题 page51、 page87、 page89/4.9、 page104、 page67、 page128七、格式化字符提醒起于page 76八、三角形面积问题 page86九、一元二次方程 page87、 page89/4.8、 page108十、分段一元函数 page100、 page110、 page111/5.5、5.6十一、位运算 page112/5.7、 page129/6.2、6.3十二、公约数公倍数 page129/6.1十三、迭代法、二分法 page129-130/6.11-13C语言常用算法模块的总结一、最大值,最小值问题教材page13/1.6、page36/2.4(2)、(3)、page98例5.1、5.2主要思想:替换+中转关联习语: if句int a,b,c,max; 多余的一个max是承载中转的容器scanf(“%d,%d,%d”,&a,&b,&c);max=a; 定初值if(max<b)Max=b; 分别取a、 b、c相互比较,由于只需输if(max<c) 出最大或者最小值,所以只需将最大值存Max=c; 储在max中即可printf(“……”);如果需要依次输出所给的数值,则须在比较大小之后进行替换赋值int a,b,t;scanf(“%d,%d”,&a,&b)if(a>b){ 此步的依次赋值体现了赋值运算自右向左的结合次序t=a; 先将a的值赋给t,此时a的值空出a=b; 将b的值赋给a,b值空出b=t; 将t中存储的a的值赋给b,此时t仍回复空值} 若混淆其中赋值规律则产生混乱printf(“……”);二、连乘连加问题page113、114、115 page129/6.3 page129/6.4、6.5主要思想:容器+循环关联习语:while(do……while)、for、(goto)int i,sum=0; 循环第一步,定初值,sum可视作是承载运算结果的容器,初为空i=1;while(i<=100) 构设循环条件,注意必须是有限循环,否则程序无终止{sum=sum+I; 循环第二步,累计结果i++; 循环第三步,循环量自增。
C语言程序设计的常用算法

C语言程序设计的常用算法1.排序算法-冒泡排序:通过多次比较和交换来将最大(小)的数移到最后(前),时间复杂度为O(n^2)。
适用于数据较少、数据基本有序的情况。
- 快速排序:通过一趟排序将待排序序列分隔成独立的两部分,其中一部分的所有元素都比另一部分的所有元素小。
然后递归地对两部分进行排序,时间复杂度为O(nlogn)。
适用于大规模数据的排序。
-插入排序:将待排序序列分为已排序和未排序两部分,每次从未排序部分取一个元素插入到已排序部分的适当位置,时间复杂度为O(n^2)。
适用于数据量较小的排序场景。
- 归并排序:将待排序序列分为若干个子序列,分别进行排序,然后再将排好序的子序列合并成整体有序的序列,时间复杂度为O(nlogn)。
适用于需要稳定排序且对内存空间要求不高的情况。
2.查找算法-顺序查找:从头到尾依次对每个元素进行比较,直到找到目标元素或者遍历完整个序列。
时间复杂度为O(n)。
- 二分查找:对于有序序列,将序列的中间元素与目标元素进行比较,根据比较结果缩小查找范围,直到找到目标元素或者查找范围为空。
时间复杂度为O(logn)。
3.图算法-广度优先(BFS):从给定的起始顶点开始,按照“先访问当前顶点的所有邻接顶点,再依次访问这些邻接顶点的所有未访问过的邻接顶点”的顺序逐层访问图中的所有顶点。
适用于寻找最短路径、连通性等问题。
-深度优先(DFS):从给定的起始顶点开始,按照“先递归访问当前顶点的一个邻接顶点,再递归访问这个邻接顶点的一个邻接顶点,直到无法再继续递归”的方式遍历图中的所有顶点。
适用于寻找路径、判断连通性等问题。
4.动态规划算法-背包问题:给定一个背包容量和一组物品的重量和价值,选择一些物品装入背包,使得装入的物品总重量不超过背包容量,且总价值最大。
利用动态规划的思想可以通过构建二维数组来解决该问题。
-最长公共子序列(LCS):给定两个序列,找出一个最长的子序列,且该子序列在两个原序列中的顺序保持一致。
C语言常用算法大全

C语言常用算法大全1.排序算法-冒泡排序:依次比较相邻的两个元素,如果顺序不对则交换,每轮找出一个最大或最小的元素-选择排序:从未排序的元素中选择最小或最大的放到已排序的最后,以此类推-插入排序:将未排序的元素插入到已排序的合适位置,从后向前进行比较和交换-快速排序:选择一个基准元素,将小于基准元素的放在左边,大于基准元素的放在右边,然后对左右两边递归地进行快速排序-归并排序:将待排序的序列不断划分为左右两部分,分别排序后再将排序好的左右两部分按顺序合并-堆排序:构建大顶堆,将堆顶元素与末尾元素交换,然后重新调整堆,重复这个过程直到排序完成2.查找算法-顺序查找:从给定的元素序列中逐个比较,直到找到目标元素或遍历完整个序列-二分查找:对于有序序列,在序列的中间位置比较目标元素和中间元素的大小关系,通过每次缩小一半的范围来查找目标元素-插值查找:根据目标元素与有序序列的最小值和最大值的比例推测目标元素所在的位置,然后递归地进行查找-斐波那契查找:根据斐波那契数列的性质来确定目标元素所在的位置,然后递归地进行查找3.图算法-深度优先(DFS):从图的一些顶点出发,依次访问其未被访问过的邻接顶点,直到所有顶点都被访问过为止-广度优先(BFS):从图的一些顶点出发,逐层遍历图的顶点,直到所有顶点都被访问过为止- 最小生成树算法:Prim算法和Kruskal算法,用于找到连接图中所有顶点的最小权值边,构成一棵包含所有顶点的生成树- 最短路径算法:Dijkstra算法和Floyd-Warshall算法,用于找到图中两个顶点之间的最短路径-拓扑排序:用于有向无环图(DAG)中的顶点排序,确保排序后的顶点满足所有依赖关系-关键路径算法:找出网络中的关键路径,即使整个工程完成的最短时间4.字符串算法- KMP算法:通过预处理模式串构建next数组,利用next数组在匹配过程中跳过一部分不可能匹配的子串- Boyer-Moore算法:从模式串的末尾开始匹配,利用坏字符和好后缀规则进行跳跃匹配- Rabin-Karp算法:利用哈希函数对主串和匹配串的子串进行哈希计算,然后比较哈希值是否相等- 字符串匹配算法:BM算法、Shift-And算法、Sunday算法等,用于寻找模式串在主串中的出现位置5.动态规划算法-最长公共子序列(LCS):用于寻找两个序列中最长的公共子序列-最长递增子序列(LIS):用于寻找给定序列中最长的递增子序列-0-1背包问题:将有限的物品放入容量为C的背包中,使得物品的总价值最大-最大子数组和:用于求解给定数组中连续子数组的最大和-最大正方形:在给定的0-1矩阵中,找出只包含1的最大正方形的边长这些算法是在C语言中常用的算法,它们涵盖了排序、查找、图、字符串和动态规划等多个领域。
C语言的六种常用算法

C语言的六种常用算法C语言是一种非常流行的编程语言,广泛应用于各种领域中。
在C语言中,有许多常用的算法,可以用来解决各种问题。
下面我们将详细介绍C语言中的六种常用算法。
1.排序算法:排序算法可以将一组数据按照一定的规则进行排序。
常见的排序算法有冒泡排序、选择排序、插入排序、快速排序等。
这些排序算法的原理各有不同,但都可以实现对数据的排序。
排序算法对于处理大量数据的应用非常重要,可以提高查找、统计等操作的效率。
2.查找算法:查找算法是指在一组数据中寻找特定元素的过程。
常见的查找算法有线性查找、二分查找、哈希查找等。
这些算法的实现方式不同,但都可以高效地找到目标元素。
查找算法广泛应用于数据库查询、引擎等需要快速查找数据的场景中。
3.图算法:图算法是针对图结构进行的一系列操作。
图是由顶点和边组成的数据结构,可以用来表示各种关系。
在图算法中,常见的操作包括遍历、连通性判断、最短路径查找等。
图算法在网络分析、社交网络分析、运输规划等领域中有着广泛的应用。
4.动态规划算法:动态规划算法是一种解决多阶段决策问题的方法。
它将问题划分为若干个阶段,每个阶段都有一系列可选的决策。
通过求解每个阶段的最优决策,最终得到整个问题的最优解。
动态规划算法在最短路径问题、背包问题、序列比对等领域中有着重要的地位。
5.深度优先算法:深度优先算法是一种遍历图或树的方法。
它从一个起始节点开始,沿着一条路径尽可能远地,直到遇到死路才返回并尝试其他路径。
深度优先算法常用于解决迷宫问题、图的连通性判断等。
6.广度优先算法:广度优先算法是一种遍历图或树的方法。
它从一个起始节点开始,首先访问所有相邻节点,然后再访问它们的相邻节点,以此类推,直到遍历完所有节点。
广度优先算法常用于寻找最短路径、社交网络分析等。
以上就是C语言中的六种常用算法。
这些算法在各自的领域中有着广泛的应用,对于解决各种问题起到了重要的作用。
对于想要学习C语言的人来说,掌握这些算法是非常重要的一步。
c语言常用算法

123456789 13579
使用循环
例如:把分离出来的奇数,组成新的数
s=0
i=1
while(n!=0)
{
a=n%10;
if(a%2==1)
{
s=s+a*i;
i=i*10;
}
n=n/10;
}
6.求最大值和最小值(使用数组+循环)
假设第一个数是最大的或最小值,然后与后面的每一个数进行比较,如果后面比它大或比它小,就把这个数作为目前的最大值或最小值,直到比较完最后一个元素
a[j+1]=t;
}
讲50、
break;
if(i>=n-1)
说明是素数
5.整数的分离 :
(1)四位数的分离
例如:1234
4=1234%10
3=1234/10%10
2=1234/100%10
1=1234/1000
例如:统计出1~100范围内偶数的个数
n=0;
for(i=1;i<=100;i++)
if(i%2==0)
n=n+1;
4.素数:只能被1和本身整除的数是素数
例如:判断n是否是素数
for(i=2;i<n;i++)
if(n%i==0)
常用算法:
1.两数交换
引入中间变量,通过三条语句=a
a=b
b=c
2.累加和累乘
累加的基本格式 :s=s+i
保存累加和的变量初值为0,通过循环实现
例如:求1+2+3...+100
C语言的六种常用算法

C语言的六种常用算法C语言是一种广泛使用的编程语言,它不仅支持基本的算术运算,还提供了一些常用的高级算法来解决各种问题。
下面将介绍C语言中的六种常用算法。
1.排序算法:排序算法用于按特定的顺序重新排列一组数据。
常见的排序算法包括冒泡排序、插入排序、选择排序、快速排序和归并排序。
这些算法的时间复杂度和空间复杂度各不相同,可以根据不同的需求选择合适的排序算法。
2.算法:算法用于在一组数据中查找特定的元素。
常见的算法包括线性、二分和哈希。
线性从列表的一端开始逐个比对,直到找到目标元素或完整个列表。
二分是一种高效的算法,它将目标元素与列表的中间元素进行比较,然后根据比较结果将范围缩小一半,重复此过程,直到找到目标元素。
3.图算法:图算法用于解决与图相关的问题,如最短路径问题、最小生成树问题和网络流问题。
常见的图算法包括广度优先(BFS)和深度优先(DFS),它们用于遍历图的节点。
Dijkstra算法用于求解最短路径问题,Prim算法用于求解最小生成树问题。
4.动态规划算法:动态规划算法用于解决最优化问题,将原始问题分解为子问题,并记录子问题的解,以避免重复计算。
常见的动态规划算法包括0/1背包问题、最长公共子序列问题和矩阵链乘法问题。
这些问题都可以通过建立递推关系和使用动态规划表格求解。
5.贪心算法:贪心算法每次取最优解,然后将剩余的子问题交给下一次迭代。
它通常适用于解决一些具有最优子结构的问题。
常见的贪心算法包括霍夫曼编码、最小生成树问题和拟阵问题。
6.分治算法:分治算法将问题分解为若干个规模较小且相互独立的子问题,然后分别解决子问题,最后合并子问题的结果得到原始问题的解。
常见的分治算法包括快速排序、归并排序和大整数乘法。
这些算法利用递归的思想,将问题逐层分解,直到问题规模足够小,可以直接解决。
以上是C语言中的六种常用算法。
每种算法都有其适用的场景和特点,根据实际需求选择合适的算法可以提高程序的效率和性能。
单片机常用的14个C语言算法

引言概述:在单片机的开发中,C语言是最常用的编程语言之一。
掌握一些常用的C语言算法对于单片机的开发非常重要。
本文将介绍单片机常用的14个C语言算法之二,包括排序算法、查找算法、递归算法、动态规划算法和图算法。
正文内容:一、排序算法1. 冒泡排序:通过不断地交换相邻元素的位置,将大的元素冒泡到数组的末尾。
2. 快速排序:通过选择一个基准元素,将小于基准元素的数移动到基准元素左边,将大于基准元素的数移动到基准元素右边,然后分别对左右两部分递归地进行快速排序。
3. 插入排序:将数组分为已排序和未排序两部分,每次从未排序部分取一个元素,将其插入已排序部分的合适位置。
4. 选择排序:每次从未排序部分选择最小的元素,将其放在已排序部分的末尾。
5. 归并排序:将数组不断划分为更小的子数组,然后将子数组合并为有序数组。
二、查找算法1. 顺序查找:逐个比较数组中的元素,直到找到目标元素或者遍历完整个数组。
2. 二分查找:对于已排序的数组,通过不断将目标值与中间元素比较,并缩小搜索范围,最终找到目标元素的位置。
3. 插值查找:与二分查找类似,不同之处在于确定中间元素的位置时使用插值公式,使得查找范围更接近目标元素。
4. 哈希查找:使用哈希函数将关键字映射到一个唯一的哈希值,通过查找哈希值对应的位置来获取关键字。
5. 递归查找:通过递归地划分问题的规模,从而减小查找范围,最终找到目标元素。
三、递归算法1. 递归定义:在函数的定义中使用函数本身的方式称为递归。
2. 递归函数的特点:包含一个递归结束的条件和一个递归调用的表达式。
3. 递归算法的实现:通过不断把原问题转化为更小规模的子问题,直到满足递归结束的条件。
4. 递归算法的应用:在树、图等数据结构的遍历、搜索等问题中,递归算法被广泛使用。
5. 递归算法的优化:如尾递归优化、记忆化搜索等方法可以避免递归算法中的重复计算。
四、动态规划算法1. 动态规划的思想:将一个问题划分为多个子问题,并保存每个子问题的解,避免重复计算。
C语言常用9种算法

C语言常用9种算法C语言是一门广泛应用于编程领域的语言,具有丰富的算法库和功能。
在C语言中,有许多常用的算法可以帮助程序员解决各种问题。
本文将介绍C语言中常用的9种算法,以帮助读者深入了解和应用这些算法。
1.顺序算法:顺序算法是一种简单但有效的方法,通过逐个比较目标元素和数组中的元素来寻找指定值。
该算法适用于小规模的数据集,时间复杂度为O(n)。
2.二分算法:二分算法是一种高效的方法,适用于已排序的数组。
该算法通过将目标值与数组的中间元素进行比较,并根据比较结果将范围缩小一半。
时间复杂度为O(log n)。
3.冒泡排序算法:冒泡排序算法是一种简单但低效的排序方法,通过反复交换相邻的元素将较大的元素逐渐移至数组的末尾。
时间复杂度为O(n^2)。
4.选择排序算法:选择排序算法是一种简单但较为高效的排序方法,通过找到最小元素并将其放置在数组的起始位置,逐个选择剩余元素中的最小值,直到完成排序。
时间复杂度为O(n^2)。
5.插入排序算法:插入排序算法是一种简单而且对小数据集很有效的排序方法,通过将未排序的元素依次插入已排序的序列中,逐步构建有序的序列。
时间复杂度为O(n^2)。
6.快速排序算法:快速排序算法是一种高效的排序方法,通过选择一个基准值将数组分割成两个子数组,较小的值放在基准值的左边,较大的值放在右边。
然后对子数组进行递归排序。
时间复杂度为O(n log n)。
7.归并排序算法:归并排序算法是一种稳定而且高效的排序方法,通过将数组递归地分成两个子数组,然后合并这些子数组以得到排序结果。
时间复杂度为O(n log n)。
8.哈希算法:哈希算法是一种用于将数据映射到特定位置的算法,可以快速访问数据。
C语言提供了多种哈希算法库,例如MD5和SHA1等,用于数据完整性校验和密码存储等应用场景。
9.图算法:图算法是一类用于处理图结构的算法,包括广度优先、深度优先和最短路径算法等。
通过这些算法,可以实现许多图相关的问题,如寻找社交网络中的最短路径或者查找网络拓扑结构等。
C语言常用算法大全

1.十进制数转二进制数#include<stdio.h>main(){int i,n,m;int a[16]={0};printf("please input the decimalism number(0~32767):\n"); scanf("%d",&n);for(m=0;m<15;m++){i=n%2;n=n/2;a[m]=i;}for(m=15;m>=0;m--){printf("%d",a[m]);if(m%4==0)printf("");}printf("\n");}2.十进制转十六进制数1)用格式控制的方式#include<stdio.h>main(){int i;printf("please input decimalism number:\n");scanf("%d",&i);printf("the hex number is %x\n",i);}2)除以基数取余法#include<stdio.h>main(){int i,n,m;int a[4]={0};printf("please input the decimalism number(0~32767):\n"); scanf("%d",&n);for(m=0;m<4;m++){i=n%16;n=n/16;a[m]=i;}for(m=3;m>=0;m--){printf("%d",a[m]);}printf("\n");}3.十进制转八进制数1)用格式控制的方式#include<stdio.h>main(){int i;printf("please input decimalism number:\n");scanf("%d",&i);printf("the hex number is %o\n",i);}2)除以基数取余法#include<stdio.h>main(){int i,n,m;int a[8]={0};printf("please input the decimalism number(0~32767):\n"); scanf("%d",&n);for(m=0;m<8;m++){i=n%8;n=n/8;a[m]=i;}for(m=7;m>=0;m--){printf("%d",a[m]);}printf("\n");}4.十进制转任意进制数#include<stdio.h>main(){int i,n,m,j;int a[8]={0};printf("please input the decimalism number(0~32767):\n"); scanf("%d",&n);printf("please input 基数:");scanf("%d",&j);for(m=0;m<8;m++){i=n%j;n=n/j;a[m]=i;}for(m=7;m>=0;m--){printf("%d",a[m]);}printf("\n");}5.n进制数转十进制数#include<stdio.h>#include<string.h>#include<stdlib.h>main(){long t1;int i,n,t,t3;char a[100];printf("please input a number string:\n");gets(a);strupr(a);//小写转大写t3=strlen(a);t1=0;printf("please input n(2or8or16):\n");scanf("%d",&n);for(i=0;i<t3;i++){if(a[i]-'0'>=n&&a[i]<'A'||a[i]-'A'+10>=n){printf("data error!!");exit(0);}if(a[i]>='0'&&a[i]<='9')t=a[i]-'0';else if(n>=11&&(a[i]>='A'&&a[i]<='A'+n-10))t=a[i]-'A'+10;t1=t1*n+t;}printf("the decimal is %ld\n",t1);}6.输入任意三个整数,按照从小到大的顺序排列并输出#include<stdio.h>main(){int a,b,c,t;printf("please input a,b,c,:\n");scanf("%d%d%d",&a,&b,&c);if(a>b){t=a;a=b;b=t;}if(a>c){t=a;a=c;c=t;}if(b>c){t=b;b=c;c=t;}printf("the order of the number is:\n");printf("%d,%d,%d",a,b,c);}7.判断闰年#include<stdio.h>main(){int year;printf("please input the year:\n");scanf("%d",&year);if((year%4==0&&year%100!=0)||year%400==0)printf("%d is a leap year",year);elseprintf("%d is not a leap year",year);}8.随机函数进行加减运算#include<stdio.h>#include<stdlib.h>#include<time.h>main(){int a,b,c,sign,max;char sign1;printf("please select sign(1 or other,1:-,other:+):\n");scanf("%d",&sign);printf("please select the max number(<10000):\n");scanf("%d",&max);srand((unsigned long)time(0));a=rand()%max;b=rand()%max;while((a<b)&&(sign==1)){a=rand()%max;b=rand()%max;}sign1=(sign==1?'-':'+');printf("\n%d%c%d=",a,sign1,b);scanf("%d",&c);if((sign==1)&&(a-b==c)||(sign!=1)&&(a+b==c))printf("OK!\n");elseprintf("The result is wrong\n");// getch();}9.模拟ATM机界面程序#include<stdio.h>#include<stdlib.h>#include<conio.h>int system(const char *string);main(){char Key,CMoney;int password,password1=123,i=0,a=1000;while(1){do{system("cls");printf("******************************\n");printf("* Please select key: *\n");printf("* 1.password *\n");printf("* 2.get money *\n");printf("* 3.Return *\n");printf("******************************\n");Key=getch();}while(Key!='1'&&Key!='2'&&Key!='3');/*当输入的值不是1,2,3中任意值时显示do循环体中的内容*/switch(Key){case'1':system("cls");do{i++;printf(" please input password: ");scanf("%d",&password);if(password1!=password){if(i>3){printf("Wrong!Press any key to exit... ");getch();exit(0);}elseputs("wrong,try again!");}}while(password1!=password&&i<3);/*如果密码不正确且输入次数小于等于3次,执行do循环体中的语句*/printf("OK!Press any key to continue...");//密码正确返回初始界面开始其他操作getch();break;case'2':do{system("cls");if(password1!=password)//如果在case1中密码输入不正确将无法进行后面操作{printf("please logging in,press any key to continue...");getch();break;}else{printf("******************************\n");printf(" Please select:\n");printf("* 1.$100 *\n");printf("* 2.$200 *\n");printf("* 3.$300 *\n");printf("* 4.Return *\n");printf("******************************\n");CMoney=getch();}}while(CMoney!='1'&&CMoney!='2'&&CMoney!='3'&&CMoney!='4'); //当输入值不是1,2,3,4中任意数将继续执行do循环体中语句switch(CMoney){case'1':system("cls");a=a-100;printf("**********************************************\n");printf("* Your Credit money is $100,Thank you! *\n");printf("* The balance is $%d. *\n",a);printf("* Press any key to return... *\n");getch();break;case'2':system("cls");a=a-200;printf("**********************************************\n");printf("* Your Credit money is $200,Thank you! *\n");printf("* The balance is $%d. *\n",a);printf("* Press any key to return... *\n");getch();break;case'3':system("cls");a=a-300;printf("**********************************************\n");printf("* Your Credit money is $300,Thank you! *\n");printf("* The balance is $%d. *\n",a);printf("* Press any key to return... *\n");getch();break;case'4':break;}break;case'3':printf("*****************************************\n");printf("* Thank you for using! *\n");printf("* Goodbye! *\n");printf("*****************************************\n");getch();exit(0);}continue;}}10.输出三角形图案#include<stdio.h>main(){int i,j,k;for(i=1;i<=5;i++){for(j=1;j<=5-i;j++)printf(" ");for(k=1;k<=2*i-1;k++)printf("#");printf("\n");}}//三重循环,最外层控制行数,次外层控制每行空格数,最里层控制输出的符号的个数11.输出菱形#include<stdio.h>main(){int i,j,k;for(i=1;i<=4;i++){for(j=1;j<=4-i;j++)printf(" ");for(k=1;k<=2*i-1;k++)printf("*");printf("\n");}for(i=1;i<=3;i++){for(j=1;j<=i;j++)printf(" ");for(k=1;k<=2*(4-i)-1;k++)printf("*");printf("\n");}}12.打印乘法口诀表#include<stdio.h>main(){int i,j;for(i=1;i<=9;i++){for(j=1;j<=i;j++)printf("%d*%d=%d ",i,j,i*j);printf("\n");}}13.打印杨辉三角下标从1开始#include<stdio.h>main(){int i,j,a[11][11];for(i=1;i<11;i++){a[i][i]=1;a[i][1]=1;}for(i=3;i<11;i++)for(j=2;j<=i-1;j++)a[i][j]=a[i-1][j-1]+a[i-1][j];for(i=1;i<11;i++){for(j=1;j<=i;j++)printf("%4d",a[i][j]);printf("\n");}}下标从0开始#include<stdio.h>main(){int i,j,a[11][11];for(i=0;i<11;i++){a[i][i]=1;a[i][0]=1;}for(i=2;i<11;i++)for(j=1;j<=i-1;j++)a[i][j]=a[i-1][j-1]+a[i-1][j];for(i=0;i<11;i++){for(j=0;j<=i;j++)printf("%4d",a[i][j]);printf("\n");}}14.求阶层1)用while循环:#include<stdio.h>main(){int i=2,n;float fac=1;printf("please input an interger>=0.\n");scanf("%d",&n);if(n==0||n==1){printf("factorial is 1.\n");return 0;}while(i<=n){fac=fac*i;i++;}printf("factorial of%d is:%.2f\n",n,fac);}2)用递归:#include<stdio.h>float f(int n){int i=1;if(n==0||n==1)return 1;elsereturn n*f(n-1);}main(){int n;printf("please input an interger>=0.\n");scanf("%d",&n);printf("factorial of%d is:%.2f\n",n,f(n));}15.求一个数的因子#include<stdio.h>main(){int i,j;printf("Please input:\n");scanf("%d",&i);for(j=1;j<=i;j++)if(i%j==0)printf("%d,",j);}16.一元钱兑换问题(兑换成一角两角五角)#include<stdio.h>main(){int i,j,k;for(i=0;i<=10;i++)for(j=0;j<=5;j++)for(k=0;k<=2;k++)if(i+2*j+5*k==10)printf("yijiao%d,liangjiao%d,wujiao%d\n",i,j,k); }17.对调数问题(找出两个正整数之和等于各自对调之后的数之和)#include<stdio.h>main(){int x,y,z,x1,y1,z1,i,k,n,j=0;while(1){printf("Please input an interger(11~99):\n");scanf("%d",&n);if(n<=10||n>=100)//当输入的数小于10或者大于100时输出错误{printf("data error!\n");continue;}else if(n%10==0){printf("data error!\n");continue;}else{x=n/10;y=n%10;z=10*y+x;break;}}for(i=11;i<100;i++){if(i%10==0)continue;else{x1=i/10;y1=i%10;z1=10*y1+x1;if(n+i==z+z1&&n!=z1)//当满足n加i等于n的对调数加i的对调数且n和i不互为对调数{printf("%d+%d=%d+%d\n",n,i,z,z1);j++;}elsecontinue;}}if(j==0)//j为0表示不存在这样的数printf("inexistance");}18.对调最大数和最小数#include<stdio.h>main(){int a[20],max,min,i,j,k,n;//j记录每次比较中较小的数的下标,k记录每次比较中较大的数的下标printf("please input the number of elements(<20):\n");scanf("%d",&n);printf("please input the element:\n");for(i=0;i<n;i++)scanf("%d",&a[i]);max=min=a[0];for(i=1;i<n;i++){if(a[i]<min){min=a[i];j=i;}if(a[i]>max){max=a[i];k=i;}}a[k]=min;//在最大数的位置放置最小数a[j]=max;//在最小数的位置放置最大数printf("the position of min is:%3d\n",j);printf("the position of max is:%3d\n",k);printf("Now the array is :\n");for(i=0;i<n;i++)printf("%5d",a[i]);}19.二维数组行列互换#include<stdio.h>main(){int i,j,i1,j1,a[100][100],b[100][100];//i1,j1用来存放行数和列数的最大值printf("please input the number of rows(<=100)\n:");scanf("%d",&i1);printf("please input the number of columns(<=100)\n:");scanf("%d",&j1);printf("please input the element:\n");for(i=0;i<i1;i++)for(j=0;j<j1;j++)scanf("%d",&a[i][j]);printf("array a:\n");for(i=0;i<i1;i++){for(j=0;j<j1;j++)printf("%5d ",a[i][j]);printf("\n");}for(i=0;i<i1;i++)for(j=0;j<j1;j++)b[j][i]=a[i][j];printf("array b:\n");for(i=0;i<j1;i++){for(j=0;j<i1;j++)printf("%5d",b[i][j]);printf("\n");}}20.打印五阶幻方(每一行、每一列和对角线之和均相等)按如下步骤:1)将1放在第一行中间一列。
c语言常见算法

c语言常见算法C语言是一种非常流行的编程语言,广泛应用于软件开发和计算机科学领域。
在C语言中,算法是解决问题的关键步骤。
本文将介绍一些常见的C语言算法,包括排序算法、搜索算法和递归算法。
一、排序算法1. 冒泡排序算法冒泡排序是一种简单的排序算法,它重复地遍历要排序的列表,比较相邻的两个元素,并交换它们的位置,直到整个列表排序完成。
2. 插入排序算法插入排序算法通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。
3. 快速排序算法快速排序是一种高效的排序算法,它通过选择一个元素作为基准,将列表分为两部分,一部分小于基准,一部分大于基准,然后递归地对两部分进行排序。
二、搜索算法1. 线性搜索算法线性搜索算法逐个地检查列表中的元素,直到找到目标元素或者遍历完整个列表。
2. 二分搜索算法二分搜索算法适用于已排序的列表。
它通过比较目标元素和列表的中间元素,将列表分为两部分,然后在适当的部分继续搜索,直到找到目标元素或者确定目标元素不存在。
三、递归算法递归算法是一种自我调用的算法,它将问题分解成更小的子问题,然后在子问题上递归地调用自身,直到达到基本情况。
对于C语言中的算法来说,递归函数的编写非常重要。
需要确保递归的终止条件,并正确处理递归调用中传递的参数。
四、其他常见算法1. 图算法图算法是解决与图相关的问题的算法。
它可以解决最短路径问题、最小生成树问题等。
2. 动态规划算法动态规划算法是一种通过将问题分解成更小的子问题来解决复杂问题的算法。
它通常用于解决最优化问题。
3. 贪心算法贪心算法通过每一步选择当前最优解来构建问题的解决方案。
它通常不能保证找到全局最优解,但在某些情况下可以得到较好的近似解。
总结C语言常见算法涵盖了排序算法、搜索算法、递归算法以及其他常用的算法。
对于每个算法,我们都介绍了其基本原理和应用场景。
在实际编程中,根据具体的问题,选择合适的算法是非常重要的。
熟悉C语言中的常见算法,可以帮助程序员更好地解决问题,提高代码的效率与质量。
C语言常用算法归纳

C语言常用算法归纳C语言作为一种非常流行的编程语言,拥有丰富的算法库和常用算法。
在本篇文章中,我将为您介绍C语言中常用的算法分类,以及每个分类中的常用算法。
希望这篇文章能对您学习C语言算法有所帮助。
1.排序算法:排序算法用于将一组数据按照一定的顺序进行排列。
C语言中常用的排序算法有以下几种:-冒泡排序:通过依次比较相邻元素的大小,将较大的元素逐渐向后移动,实现排序。
-插入排序:将未排序的元素一个个插入到已经排序的序列中,使得整个序列有序。
-选择排序:每次从待排序的序列中选择最小(或最大)的元素,放到已排序序列的末尾。
-快速排序:通过一趟排序将待排序的数据分割成独立的两部分,然后再按照该方法对两部分数据分别进行快速排序,递归实现排序。
-归并排序:将待排序的数据递归地分成两部分,分别进行排序,然后将两个有序的子序列合并成一个有序的序列。
2.查找算法:查找算法用于在一组数据中寻找指定的元素。
C语言中常用的查找算法有以下几种:-顺序查找:从序列的起始位置依次遍历,直到找到目标元素。
-二分查找:对于已经排序的序列,通过每次将查找范围减半的方式进行查找,提高查找效率。
-插值查找:对于有序的序列,根据目标元素在序列中的分布情况,通过插值计算来确定查找位置。
3.字符串处理算法:字符串处理算法用于对字符串进行处理和操作。
C语言中常用的字符串处理算法有以下几种:-字符串比较:用于比较两个字符串是否相等。
-字符串拼接:将两个字符串合并成一个字符串。
-字符串查找:在一个字符串中寻找指定的子串。
-字符串替换:将字符串中指定的子串替换为新的子串。
4.图算法:图算法用于研究图结构的相关问题。
C语言中常用的图算法有以下几种:-广度优先:从图的其中一个顶点开始,按广度优先的原则依次访问与该顶点相邻的未访问的顶点。
-深度优先:从图的其中一个顶点开始,按深度优先的原则访问与该顶点相邻的未访问的顶点,直到无法继续访问为止。
- 最短路径算法:用于寻找两个顶点之间最短路径的算法,常见的最短路径算法有Dijkstra算法和Floyd算法。
最全最常用算法设计方法(C语言)

一、迭代法迭代法是用于求方程或方程组近似根的一种常用的算法设计方法。
设方程为f(x)=0,用某种数学方法导出等价的形式x=g(x),然后按以下步骤执行:(1)选一个方程的近似根,赋给变量x0;(2)将x0的值保存于变量x1,然后计算g(x1),并将结果存于变量x0;(3)当x0与x1的差的绝对值还小于指定的精度要求时,重复步骤(2)的计算。
若方程有根,并且用上述方法计算出来的近似根序列收敛,则按上述方法求得的x0就认为是方程的根。
上述算法用C程序的形式表示为:【算法】迭代法求方程的根{ x0=初始近似根;do {x1=x0;x0=g(x1);/*按特定的方程计算新的近似根*/} while ( fabs(x0-x1)>Epsilon);printf(“方程的近似根是%f\n”,x0);}迭代算法也常用于求方程组的根,令X=(x0,x1,…,x n-1)设方程组为:x i=g i(X) (I=0,1,…,n-1)则求方程组根的迭代算法可描述如下:【算法】迭代法求方程组的根{ for (i=0;i<n;i++)x[i]=初始近似根;do {for (i=0;i<n;i++)y[i]=x[i];for (i=0;i<n;i++)x[i]=gi(X);for (delta=0.0,i=0;i<n;i++)if (fabs(y[i]-x[i])>delta) delta=fabs(y[i]-x[i]);} while (delta>Epsilon);for (i=0;i<n;i++)printf(“变量x[%d]的近似根是%f”,I,x[i]);printf(“\n”);}具体使用迭代法求根时应注意以下两种可能发生的情况:(1)如果方程无解,算法求出的近似根序列就不会收敛,迭代过程会变成死循环,因此在使用迭代算法前应先考察方程是否有解,并在程序中对迭代的次数给予限制;(2)方程虽然有解,但迭代公式选择不当,或迭代的初始近似根选择不合理,也会导致迭代失败。
C语言算法大全

C语言经典算法目录一、单元加.................................... 错误!未定义书签。
1.erre ...................................... 错误!未定义书签。
2. erre2 ................................... 错误!未定义书签。
3. 数组完全单元........................ 错误!未定义书签。
4. 栈单元加.............................. 错误!未定义书签。
二、底层编程 ................................ 错误!未定义书签。
1. asm ..................................... 错误!未定义书签。
2. C标志符命名源程序............... 错误!未定义书签。
3. ping .................................... 错误!未定义书签。
4. winsock2 ............................. 错误!未定义书签。
5. 检测鼠标.............................. 错误!未定义书签。
6. 检出错误.............................. 错误!未定义书签。
7. 时间陷阱.............................. 错误!未定义书签。
三、汉诺塔.................................... 错误!未定义书签。
1. 非递归................................. 错误!未定义书签。
2. 汉诺塔................................. 错误!未定义书签。
3. 汉诺塔2 .............................. 错误!未定义书签。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
一、基本算法1.交换(两量交换借助第三者)例1、任意读入两个整数,将二者的值交换后输出。
main(){int a,b,t;scanf("%d%d",&a,&b);printf("%d,%d\n",a,b);t=a; a=b; b=t;printf("%d,%d\n",a,b);}【解析】程序中加粗部分为算法的核心,如同交换两个杯子里的饮料,必须借助第三个空杯子。
假设输入的值分别为3、7,则第一行输出为3,7;第二行输出为7,3。
其中t为中间变量,起到“空杯子”的作用。
注意:三句赋值语句赋值号左右的各量之间的关系!【应用】例2、任意读入三个整数,然后按从小到大的顺序输出。
main(){int a,b,c,t;scanf("%d%d%d",&a,&b,&c);/*以下两个if语句使得a中存放的数最小*/if(a>b){ t=a; a=b; b=t; }if(a>c){ t=a; a=c; c=t; }/*以下if语句使得b中存放的数次小*/if(b>c) { t=b; b=c; c=t; }printf("%d,%d,%d\n",a,b,c);}2.累加累加算法的要领是形如“s=s+A”的累加式,此式必须出现在循环中才能被反复执行,从而实现累加功能。
“A”通常是有规律变化的表达式,s在进入循环前必须获得合适的初值,通常为0。
例1、求1+2+3+……+100的和。
main(){int i,s;s=0; i=1;while(i<=100){s=s+i; /*累加式*/i=i+1; /*特殊的累加式*/}printf("1+2+3+...+100=%d\n",s);}【解析】程序中加粗部分为累加式的典型形式,赋值号左右都出现的变量称为累加器,其中“i = i + 1”为特殊的累加式,每次累加的值为1,这样的累加器又称为计数器。
累乘算法的要领是形如“s=s*A”的累乘式,此式必须出现在循环中才能被反复执行,从而实现累乘功能。
“A”通常是有规律变化的表达式,s在进入循环前必须获得合适的初值,通常为1。
例1、求10![分析]10!=1×2×3×……×10main(){int i; long c;c=1; i=1;while(i<=10){c=c*i; /*累乘式*/i=i+1;}printf("1*2*3*...*10=%ld\n",c);}二、非数值计算常用经典算法1.穷举也称为“枚举法”,即将可能出现的每一种情况一一测试,判断是否满足条件,一般采用循环来实现。
例1、用穷举法输出所有的水仙花数(即这样的三位正整数:其每位数位上的数字的立方和与该数相等,比如:13+53+33=153)。
[法一]main(){int x,g,s,b;for(x=100;x<=999;x++){g=x%10; s=x/10%10; b=x/100;if(b*b*b+s*s*s+g*g*g==x)printf("%d\n",x);}}【解析】此方法是将100到999所有的三位正整数一一考察,即将每一个三位正整数的个位数、十位数、百位数一一求出(各数位上的数字的提取算法见下面的“数字处理”),算出三者的立方和,一旦与原数相等就输出。
共考虑了900个三位正整数。
[法二]main(){int g,s,b;for(b=1;b<=9;b++)for(s=0;s<=9;s++)for(g=0;g<=9;g++)if(b*b*b+s*s*s+g*g*g==b*100+s*10+g) printf("%d\n",b*100+s*10+g);}【解析】此方法是用1到9做百位数字、0到9做十位和个位数字,将组成的三位正整数与每一组的三个数的立方和进行比较,一旦相等就输出。
共考虑了900个组合(外循环单独执行的次数为9,两个内循环单独执行的次数分别为10次,故if语句被执行的次数为9×10×10=900),即900个三位正整数。
与法一判断的次数一样。
(1)冒泡排序(起泡排序)假设要对含有n个数的序列进行升序排列,冒泡排序算法步骤是:①从存放序列的数组中的第一个元素开始到最后一个元素,依次对相邻两数进行比较,若前者大后者小,则交换两数的位置;②第①趟结束后,最大数就存放到数组的最后一个元素里了,然后从第一个元素开始到倒数第二个元素,依次对相邻两数进行比较,若前者大后者小,则交换两数的位置;③重复步骤①n-1趟,每趟比前一趟少比较一次,即可完成所求。
例1、任意读入10个整数,将其用冒泡法按升序排列后输出。
#define n 10main(){int a[n],i,j,t;for(i=0;i<n;i++) scanf("%d",&a[i]);for(j=1;j<=n-1;j++) /*n个数处理n-1趟*/for(i=0;i<=n-1-j;i++) /*每趟比前一趟少比较一次*/if(a[i]>a[i+1]){t=a[i];a[i]=a[i+1];a[i+1]=t;}for(i=0;i<n;i++) printf("%d\n",a[i]);}(2)选择法排序选择法排序是相对好理解的排序算法。
假设要对含有n个数的序列进行升序排列,算法步骤是:①从数组存放的n个数中找出最小数的下标(算法见下面的“求最值”),然后将最小数与第1个数交换位置;②除第1个数以外,再从其余n-1个数中找出最小数(即n个数中的次小数)的下标,将此数与第2个数交换位置;③重复步骤①n-1趟,即可完成所求。
例1、任意读入10个整数,将其用选择法按升序排列后输出。
#define n 10main(){int a[n],i,j,k,t;for(i=0;i<n;i++) scanf("%d",&a[i]);for(i=0;i<n-1;i++) /*处理n-1趟*/{k = i; /*总是假设此趟处理的第一个(即全部数的第i个)数最小,k记录其下标*/ for(j=i+1;j<n;j++)if(a[j] < a[k]) k = j;if (k != i){t = a[i]; a[i] = a[k]; a[k] = t;}}for(i=0;i<n;i++)printf("%d\n",a[i]); }(3)插入法排序要想很好地掌握此算法,先请了解“有序序列的插入算法”,就是将某数据插入到一个有序序列后,该序列仍然有序。
插入算法参见下面的“数组元素的插入”。
例1、将任意读入的整数x插入一升序数列后,数列仍按升序排列。
#define n 10main(){ int a[n]={-1,3,6,9,13,22,27,32,49},x,j,k; /*注意留一个空间给待插数*/scanf("%d",&x);if(x>a[n-2]) a[n-1]=x ; /*比最后一个数还大就往最后一个元素中存放*/else /*查找待插位置*/{j=0;while( j<=n-2 && x>a[j]) j++;/*从最后一个数开始直到待插位置上的数依次后移一位*/for(k=n-2; k>=j; k- -) a[k+1]=a[k];a[j]=x; /*插入待插数*/ }for(j=0;j<=n-1;j++) printf("%d ",a[j]);}插入法排序的要领就是每读入一个数立即插入到最终存放的数组中,每次插入都使得该数组有序。
例2、任意读入10个整数,将其用插入法按降序排列后输出。
#define n 10main(){int a[n],i,j,k,x;scanf("%d",&a[0]); /*读入第一个数,直接存到a[0]中*/for(j=1;j<n;j++) /*将第2至第10个数一一有序插入到数组a中*/{scanf("%d",&x);if(x<a[j-1]) a[j]=x; /*比原数列最后一个数还小就往最后一个元素之后存放新读的数*/else /*以下查找待插位置*/{i=0;while(x<a[i]&&i<=j-1) i++;/*以下for循环从原最后一个数开始直到待插位置上的数依次后移一位*/for(k=j-1;k>=i;k--) a[k+1]=a[k];a[i]=x; /*插入待插数*/}}for(i=0;i<n;i++) printf("%d\n",a[i]);}(4)归并排序即将两个都升序(或降序)排列的数据序列合并成一个仍按原序排列的序列。
例1、有一个含有6个数据的升序序列和一个含有4个数据的升序序列,将二者合并成一个含有10个数据的升序序列。
#define m 6#define n 4main(){int a[m]={-3,6,19,26,68,100} ,b[n]={8,10,12,22};int i,j,k,c[m+n];i=j=k=0;while(i<m && j<n) /*将a、b数组中的较小数依次存放到c数组中*/{if(a[i]<b[j]){c[k]=a[i]; i++;}else {c[k]=b[j]; j++;}k++; }while(i>=m && j<n) /*若a中数据全部存放完毕,将b中余下的数全部存放到c中*/{c[k]=b[j]; k++; j++;}while(j>=n && i<m) /*若b中数据全部存放完毕,将a中余下的数全部存放到c中*/{c[k]=a[i]; k++; i++;}for(i=0;i<m+n;i++) printf("%d ",c[i]);}3.查找(1)顺序查找(即线性查找)顺序查找的思路是:将待查找的量与数组中的每一个元素进行比较,若有一个元素与之相等则找到;若没有一个元素与之相等则找不到。
例1、任意读入10个数存放到数组a中,然后读入待查找数值,存放到x中,判断a中有无与x 等值的数。