非常全的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，这样的累加器又称为计数器。

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语言常用算法程序汇总C语言是一门广泛应用于计算机编程的语言，具有较高的效率和灵活性。

在C语言中，常见的算法程序包括排序算法、查找算法、递归算法等等。

以下是一些常用的C语言算法程序的汇总：1.排序算法：-冒泡排序：通过多次迭代比较相邻元素并交换位置，将最大的元素逐渐移动到正确的位置。

-插入排序：将待排序的元素与已排序的部分依次比较并插入到正确的位置。

-选择排序：每次从待排序的元素中选择最小的元素并与已排序的部分交换位置。

-快速排序：通过选择一个基准元素，将数组划分为两个子数组进行递归排序。

2.查找算法：-顺序查找：逐个比较数组中的元素，直到找到目标元素或到数组末尾。

-二分查找：通过比较目标元素与数组中间元素的大小，逐步缩小范围，直到找到目标元素。

-哈希查找：通过散列函数将目标元素映射到哈希表的索引位置进行查找。

3.递归算法：-阶乘：通过递归调用自身计算一个正整数的阶乘。

-斐波那契数列：通过递归调用自身计算斐波那契数列的第n个数。

-二叉树遍历：通过递归调用自身遍历二叉树的各个节点。

4.图算法：- 最短路径算法：如Dijkstra算法和Floyd算法，用于计算图中两个节点之间的最短路径。

-拓扑排序：通过对有向无环图进行排序，使得所有的边从排在前面的节点指向排在后面的节点。

- 最小生成树：如Prim算法和Kruskal算法，用于找到图中连接所有节点的最小子树。

5.动态规划：-最长公共子序列：通过寻找两个字符串中的最长公共子序列，解决字符串匹配问题。

-背包问题：通过动态规划解决在给定容量下选取物品使得总价值最大的问题。

-最大子序列和：通过动态规划解决一个数组中选取连续子序列使得和最大的问题。

以上只是一些C语言中常用的算法程序的汇总，实际上，还有很多其他的算法，如逆波兰表达式、霍夫曼编码、最小割等等。

通过学习这些算法，可以更好地理解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. 排序算法：
- 冒泡排序(Bubble Sort)
- 选择排序(Selection Sort)
- 插入排序(Insertion Sort)
- 归并排序(Merge Sort)
- 快速排序(Quick Sort)
2. 搜索算法：
- 二分查找(Binary Search)
- 线性搜索(Linear Search)
3. 图算法：
- 深度优先搜索(Depth First Search, DFS)
- 广度优先搜索(Breadth First Search, BFS)
- 最短路径算法(例如：Dijkstra算法、Floyd-Warshall算法) - 最小生成树算法(例如：Prim算法、Kruskal算法)
4. 动态规划：
- 背包问题(Knapsack Problem)
- 最长公共子序列(Longest Common Subsequence)
- 最长递增子序列(Longest Increasing Subsequence)
5. 数学算法：
- 斐波那契数列(Fibonacci Sequence)
- 素数判断(Prime Number Check)
- 阶乘(Factorial)
- 快速幂算法(Fast Exponentiation)
这些算法只是常用的一部分，还有很多其他种类的算法。

掌握这些基本的算法可以帮助你更好地理解和解决各种问题。

C语言算法全总结C语言是一种广泛应用于计算机科学领域的编程语言，具有高效、可移植和灵活的特点。

在程序设计中，算法是解决问题的一系列有序步骤，可以通过C语言来实现。

本文将为您总结C语言中常用的算法，包括排序算法、查找算法和图算法。

一、排序算法排序算法是将一组元素按照特定的顺序重新排列的算法。

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

这些算法的核心思想是通过比较和交换元素的位置来进行排序。

1.冒泡排序冒泡排序通过多次比较和交换相邻元素的位置来实现排序。

它的基本思想是将最大的元素不断地往后移动，直到整个序列有序。

2.选择排序选择排序通过每次选择最小的元素来实现排序。

它的基本思想是通过比较找到最小元素的位置，然后将其与第一个元素交换，接着在剩下的元素中继续找到最小元素并进行交换，如此重复直到整个序列有序。

3.插入排序插入排序通过构建有序序列，对未排序序列逐个元素进行插入，从而实现排序。

它的基本思想是将当前元素插入到前面已经排好序的序列中的适当位置。

4.快速排序快速排序是一种分治算法，通过选择一个基准元素，将其他元素划分为小于基准元素和大于基准元素的两部分，然后递归地对这两部分进行排序，最终实现整个序列有序。

5.归并排序归并排序也是一种分治算法，将序列分成两个子序列，分别对这两个子序列进行排序，然后将排序后的子序列合并成一个有序序列，从而达到整个序列有序的目的。

二、查找算法查找算法是在一个数据集合中寻找特定元素的算法。

常见的查找算法包括线性查找、二分查找和散列查找。

这些算法的核心思想是通过比较元素的值来确定待查找元素的位置。

1.线性查找线性查找是从数据集合的开头开始，依次比较每个元素的值，直到找到目标元素为止。

它的时间复杂度为O(n)，其中n为数据集合的大小。

2.二分查找二分查找是针对有序序列进行查找的算法，它的基本思想是通过不断缩小查找范围，将目标元素与中间元素进行比较，从而确定待查找元素的位置。

C程序设计的常用算法算法（Algorithm）：计算机解题的基本思想方法和步骤。

算法的描述：是对要解决一个问题或要完成一项任务所采取的方法和步骤的描述，包括需要什么数据（输入什么数据、输出什么结果）、采用什么结构、使用什么语句以及如何安排这些语句等。

通常使用自然语言、结构化流程图、伪代码等来描述算法。

一、简单数值类算法此类问题都要使用循环，要注意根据问题确定循环变量的初值、终值或结束条件，更要注意用来表示计数、和、阶乘的变量的初值。

1、求阶乘：n!=1*2*384…..*n; n!= n*(n-1)!=下列程序用于求n的阶乘.在累乘之前,一定要将用于存放乘积的变量的值初始化为1.long func(int n){int i;long t=1;for(i=2;i<=n;i++)t*=i;return t;}printf("\n");}main(){ int n;scanf("%d", &n);printf("n!=%ld\n", fac(n));}2、整数拆分问题：把一个整数各个位上的数字存到数组中#define N 4 /* N代表整数位数*/viod split(int n, int a[ ]）/* 1478: a[ 3]=8, a[2 ]=7, a[1 ]=4…*/{int i;for(i=N-1;i!=0; i--){ a[i]=n%10;n=n/10;}}main(){int i,m=1478,b[N-1];split(m, b）;for(i=0;i<4; i++)printf(“%5d”, b[i]);}3、求整数的因子之和12=1*2*3*4 long factor(int n){int i;long sum=0;for(i=1;i<=n;i++)if(n%i= =0)sum+=i;return sum;}注意：因子包括1和自身。

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

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

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

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

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

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

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

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

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

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

时间复杂度为O(n)。

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

时间复杂度为O(logn)。

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

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

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

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

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

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

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

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语言中的六种常用算法。

1.排序算法：排序算法可以将一组数据按照一定的规则进行排序。

常见的排序算法有冒泡排序、选择排序、插入排序、快速排序等。

这些排序算法的原理各有不同，但都可以实现对数据的排序。

排序算法对于处理大量数据的应用非常重要，可以提高查找、统计等操作的效率。

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

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

这些算法的实现方式不同，但都可以高效地找到目标元素。

查找算法广泛应用于数据库查询、引擎等需要快速查找数据的场景中。

3.图算法：图算法是针对图结构进行的一系列操作。

图是由顶点和边组成的数据结构，可以用来表示各种关系。

在图算法中，常见的操作包括遍历、连通性判断、最短路径查找等。

图算法在网络分析、社交网络分析、运输规划等领域中有着广泛的应用。

4.动态规划算法：动态规划算法是一种解决多阶段决策问题的方法。

它将问题划分为若干个阶段，每个阶段都有一系列可选的决策。

通过求解每个阶段的最优决策，最终得到整个问题的最优解。

动态规划算法在最短路径问题、背包问题、序列比对等领域中有着重要的地位。

5.深度优先算法：深度优先算法是一种遍历图或树的方法。

它从一个起始节点开始，沿着一条路径尽可能远地，直到遇到死路才返回并尝试其他路径。

深度优先算法常用于解决迷宫问题、图的连通性判断等。

6.广度优先算法：广度优先算法是一种遍历图或树的方法。

它从一个起始节点开始，首先访问所有相邻节点，然后再访问它们的相邻节点，以此类推，直到遍历完所有节点。

广度优先算法常用于寻找最短路径、社交网络分析等。

以上就是C语言中的六种常用算法。

这些算法在各自的领域中有着广泛的应用，对于解决各种问题起到了重要的作用。

对于想要学习C语言的人来说，掌握这些算法是非常重要的一步。

非常全的c语言常用算法.doc
C语言是一门广泛应用于编程领域的语言，它不仅可以实现各种各样的程序功能，还
可以实现各种算法。

下面是一些常用的C语言算法。

1. 快速排序算法
快速排序算法是一种基于分治思想的排序算法，它的时间复杂度为O(nlogn)。

其基本思路是选择一个基准值，通过一次排序将数据分成两部分，分别对这两部分数据再进行排序。

3. 二分查找算法
二分查找算法是一种基于比较的查找算法，它的时间复杂度为O(logn)。

其基本思路
是在有序的数据集合中查找某个值，每次将查找范围缩小一半。

4. 简单选择排序算法
简单选择排序算法是一种直接选择排序算法，其时间复杂度为O(n^2)。

其基本思路是在序列中选择最小的元素放到序列的起始位置，然后从剩余的元素中选择最小的放到已排
序序列的末尾。

5. 直接插入排序算法
直接插入排序算法是一种基于比较的排序算法，其时间复杂度为O(n^2)。

其基本思路是将待排序序列分为已排序部分和未排序部分，将未排序部分的元素一个一个插入到已排
序部分的合适位置。

堆排序算法是一种基于堆的排序算法，其时间复杂度为O(nlogn)。

其基本思路是将待排序序列看做完全二叉树，将其转化为最大堆或最小堆，不断取出堆顶元素并重新调整堆，直到所有元素都被排序。

C语言经典算法大全精选1.排序算法1.1冒泡排序：通过不断交换相邻元素的位置，将最大（最小）值“冒泡”到序列的末尾（开头）。

1.2插入排序：将未排序的元素逐个插入已排序的序列中，保持序列始终有序。

1.3选择排序：每次从未排序的元素中选择最小（最大）的元素，放到已排序序列的末尾（开头）。

1.4快速排序：通过递归地将序列分割为较小和较大的两部分，然后分别对两部分进行排序。

1.5归并排序：将序列递归地分割为两个子序列，分别排序后再将结果合并。

1.6堆排序：构建最大（最小）堆，然后逐步将堆顶元素与最后一个元素交换，并调整堆结构。

2.查找算法2.1顺序查找：逐个比较元素，直到找到目标元素或遍历完整个序列。

2.2二分查找：在有序序列中，通过不断缩小查找范围，找到目标元素。

2.3插值查找：根据目标元素与序列中最大、最小元素的关系，按比例选择查找范围。

2.4哈希查找：利用哈希函数将目标元素映射到一个唯一的位置，从而快速定位目标元素。

3.字符串算法3.1字符串匹配算法：在文本串中查找给定的模式串，并返回匹配位置。

3.2字符串翻转：将一个字符串逆序输出。

3.3字符串压缩：将连续出现多次的字符压缩为一个字符，并输出压缩后的字符串。

3.4字符串拆分：按照指定的分隔符将字符串拆分为多个子串，并返回子串列表。

3.5字符串反转单词：将一个句子中的单词顺序逆序输出。

4.图算法4.1深度优先：从起始顶点出发，递归地访问所有能到达的未访问顶点。

4.2广度优先：从起始顶点出发，逐层地访问与当前层相邻的未访问顶点。

4.3最小生成树：找到连接所有顶点的具有最小权值的无环边集合。

4.4最短路径：找到两个顶点之间最短路径的权值和。

4.5拓扑排序：找到一个顶点的线性序列，满足所有有向边的起点在终点之前。

5.数学算法5.1质数判断：判断一个数是否为质数（只能被1和自身整除）。

5.2求最大公约数：找到两个数的最大公约数。

5.3求最小公倍数：找到两个数的最小公倍数。

(2)任意位数的分离：
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

一、 .累加累乘 基本知识：S=S+X 累加 0 X=X+1 计数 0 T=T*X 累乘 求X n 1 T=T*I 累乘 求N ！ 1应用：级数求和1．输入x 、n 后输出下列算式的值。

(次数控制)!)1(!4!3!21432n x x x x x n --+⋯+-+-[程序1] #include <stdio.h> void main( ) { float s, t, x,t1=1.0,t2=1.0; int i, n; scanf("%f%d", &x, &n);s=0, t=-1;for(i=1; i<=n; i++) { t1=t1*x; t2=t2*i;t=-t; s=s+t*t1/t2;} printf (“%f ”,s);} [程序2]#include <stdio.h> float f1(float x , int n) { float y=1.0; int k; for(k=0;k<n;k++)y=y*x;return y; }long f2(int n){ long m=1; int k; for(k=1;k<=n;k++)m=m*k;return m; }void main( ){ float s, t, x; int i, n; scanf("%f%d", &x, &n);s=0, t=-1;for(i=1; i<=n; i++){ t=-t; s=s+t*f1(x,i)/f2(i);}printf (“%f ”,s);}二、 整除性 基本知识： x%y==0(int)(x/y)==x/y fmod(x,y)==0应用：1.素数(质数)#include <stdio.h> #include<math.h> void main(){int m,i,n=0;do {scanf(“%d”,&m);n=sqrt(m);for(i=2;i<=n;i++)if(m%i==0) break;if(i>n)printf(“ %d”,m);}while(m!=0);/*输入0结束*/ }[素数2]#include <stdio.h>#include<math.h>int prime(int m){ int k,p;p=sqrt(m);for(k=2;k<=p;k++)if(m%k==0) break;if(k>p) return 1;else return 0;}void main(){int m,i,n=0;do {scanf(“%d”,&m);if(prime(m))printf(“ %d是素数.”,m);elseprintf(“%d不是素数.”,m);}2.水仙花数：若某数等于各位数字的立方和，则称该数为水仙花数for(i=100;i<=999;i++){a=i%10;b=i/10%10;c=i/100;if(a*a*a+b*b*b+c*c*c==i)printf(“%d”,&i);}输入一个整数判断是否是水仙花数.scanf(“%d”,&m);t=0; n=m;while(n>0){ k=n%10; t=t+k*k*k; n=n/10;}if(m==t) printf(“%d是水仙花数.”,m);[水仙花数]#include <stdio.h>int f(int m){ int k,n,t;n=m; t=0;while(n>0){ k=n%10; t=t+k*k*k; n=n/10;}if(m==t) return 1;else return 0;}void main(){int m;do{ scanf(“%d”,&m);if(f(m)) printf(“%d是水仙花数.”,m);else printf(“%d不是水仙花数.”,m);}while(m!=0);}3.完数：某数等于其诸因子之和则该数为完数，如6=1+2+3，28=1+2+4+7+14 则6、28就是完数。

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.快速排序快速排序是一种高效的排序算法，它通过选取一个基准元素并将数组分为两部分来完成排序。

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语言算法，包括排序算法、搜索算法和递归算法。

一、排序算法1. 冒泡排序算法冒泡排序是一种简单的排序算法，它重复地遍历要排序的列表，比较相邻的两个元素，并交换它们的位置，直到整个列表排序完成。

2. 插入排序算法插入排序算法通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

3. 快速排序算法快速排序是一种高效的排序算法，它通过选择一个元素作为基准，将列表分为两部分，一部分小于基准，一部分大于基准，然后递归地对两部分进行排序。

二、搜索算法1. 线性搜索算法线性搜索算法逐个地检查列表中的元素，直到找到目标元素或者遍历完整个列表。

2. 二分搜索算法二分搜索算法适用于已排序的列表。

它通过比较目标元素和列表的中间元素，将列表分为两部分，然后在适当的部分继续搜索，直到找到目标元素或者确定目标元素不存在。

三、递归算法递归算法是一种自我调用的算法，它将问题分解成更小的子问题，然后在子问题上递归地调用自身，直到达到基本情况。

对于C语言中的算法来说，递归函数的编写非常重要。

需要确保递归的终止条件，并正确处理递归调用中传递的参数。

四、其他常见算法1. 图算法图算法是解决与图相关的问题的算法。

它可以解决最短路径问题、最小生成树问题等。

2. 动态规划算法动态规划算法是一种通过将问题分解成更小的子问题来解决复杂问题的算法。

它通常用于解决最优化问题。

3. 贪心算法贪心算法通过每一步选择当前最优解来构建问题的解决方案。

它通常不能保证找到全局最优解，但在某些情况下可以得到较好的近似解。

总结C语言常见算法涵盖了排序算法、搜索算法、递归算法以及其他常用的算法。

对于每个算法，我们都介绍了其基本原理和应用场景。

在实际编程中，根据具体的问题，选择合适的算法是非常重要的。

熟悉C语言中的常见算法，可以帮助程序员更好地解决问题，提高代码的效率与质量。