非常全的C语言常用算法
非常全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语言常用算法集合
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语言中，常见的算法程序包括排序算法、查找算法、递归算法等等。
以下是一些常用的C语言算法程序的汇总：1.排序算法：-冒泡排序：通过多次迭代比较相邻元素并交换位置，将最大的元素逐渐移动到正确的位置。
-插入排序：将待排序的元素与已排序的部分依次比较并插入到正确的位置。
-选择排序：每次从待排序的元素中选择最小的元素并与已排序的部分交换位置。
-快速排序：通过选择一个基准元素，将数组划分为两个子数组进行递归排序。
2.查找算法：-顺序查找：逐个比较数组中的元素，直到找到目标元素或到数组末尾。
-二分查找：通过比较目标元素与数组中间元素的大小，逐步缩小范围，直到找到目标元素。
-哈希查找：通过散列函数将目标元素映射到哈希表的索引位置进行查找。
3.递归算法：-阶乘：通过递归调用自身计算一个正整数的阶乘。
-斐波那契数列：通过递归调用自身计算斐波那契数列的第n个数。
-二叉树遍历：通过递归调用自身遍历二叉树的各个节点。
4.图算法：- 最短路径算法：如Dijkstra算法和Floyd算法，用于计算图中两个节点之间的最短路径。
-拓扑排序：通过对有向无环图进行排序，使得所有的边从排在前面的节点指向排在后面的节点。
- 最小生成树：如Prim算法和Kruskal算法，用于找到图中连接所有节点的最小子树。
5.动态规划：-最长公共子序列：通过寻找两个字符串中的最长公共子序列，解决字符串匹配问题。
-背包问题：通过动态规划解决在给定容量下选取物品使得总价值最大的问题。
-最大子序列和：通过动态规划解决一个数组中选取连续子序列使得和最大的问题。
以上只是一些C语言中常用的算法程序的汇总，实际上，还有很多其他的算法，如逆波兰表达式、霍夫曼编码、最小割等等。
通过学习这些算法，可以更好地理解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语言常用算法集
以下是一些常用的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语言来实现。
本文将为您总结C语言中常用的算法，包括排序算法、查找算法和图算法。
一、排序算法排序算法是将一组元素按照特定的顺序重新排列的算法。
常见的排序算法包括冒泡排序、选择排序、插入排序、快速排序和归并排序。
这些算法的核心思想是通过比较和交换元素的位置来进行排序。
1.冒泡排序冒泡排序通过多次比较和交换相邻元素的位置来实现排序。
它的基本思想是将最大的元素不断地往后移动，直到整个序列有序。
2.选择排序选择排序通过每次选择最小的元素来实现排序。
它的基本思想是通过比较找到最小元素的位置，然后将其与第一个元素交换，接着在剩下的元素中继续找到最小元素并进行交换，如此重复直到整个序列有序。
3.插入排序插入排序通过构建有序序列，对未排序序列逐个元素进行插入，从而实现排序。
它的基本思想是将当前元素插入到前面已经排好序的序列中的适当位置。
4.快速排序快速排序是一种分治算法，通过选择一个基准元素，将其他元素划分为小于基准元素和大于基准元素的两部分，然后递归地对这两部分进行排序，最终实现整个序列有序。
5.归并排序归并排序也是一种分治算法，将序列分成两个子序列，分别对这两个子序列进行排序，然后将排序后的子序列合并成一个有序序列，从而达到整个序列有序的目的。
二、查找算法查找算法是在一个数据集合中寻找特定元素的算法。
常见的查找算法包括线性查找、二分查找和散列查找。
这些算法的核心思想是通过比较元素的值来确定待查找元素的位置。
1.线性查找线性查找是从数据集合的开头开始，依次比较每个元素的值，直到找到目标元素为止。
它的时间复杂度为O(n)，其中n为数据集合的大小。
2.二分查找二分查找是针对有序序列进行查找的算法，它的基本思想是通过不断缩小查找范围，将目标元素与中间元素进行比较，从而确定待查找元素的位置。
C语言常用算法程序汇总
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语言程序设计的常用算法
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语言常用算法.doc
非常全的c语言常用算法.doc
C语言是一门广泛应用于编程领域的语言，它不仅可以实现各种各样的程序功能，还
可以实现各种算法。
下面是一些常用的C语言算法。
1. 快速排序算法
快速排序算法是一种基于分治思想的排序算法，它的时间复杂度为O(nlogn)。
其基本思路是选择一个基准值，通过一次排序将数据分成两部分，分别对这两部分数据再进行排序。
3. 二分查找算法
二分查找算法是一种基于比较的查找算法，它的时间复杂度为O(logn)。
其基本思路
是在有序的数据集合中查找某个值，每次将查找范围缩小一半。
4. 简单选择排序算法
简单选择排序算法是一种直接选择排序算法，其时间复杂度为O(n^2)。
其基本思路是在序列中选择最小的元素放到序列的起始位置，然后从剩余的元素中选择最小的放到已排
序序列的末尾。
5. 直接插入排序算法
直接插入排序算法是一种基于比较的排序算法，其时间复杂度为O(n^2)。
其基本思路是将待排序序列分为已排序部分和未排序部分，将未排序部分的元素一个一个插入到已排
序部分的合适位置。
堆排序算法是一种基于堆的排序算法，其时间复杂度为O(nlogn)。
其基本思路是将待排序序列看做完全二叉树，将其转化为最大堆或最小堆，不断取出堆顶元素并重新调整堆，直到所有元素都被排序。
C语言经典算法大全精选
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求最小公倍数：找到两个数的最小公倍数。
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语言常用算法
一、 .累加累乘 基本知识：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 语言中，算法是非常重要的部分，因为它们能够帮助我们解决许多实际问题。
本文将介绍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.十进制数转二进制数#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.排序算法排序算法是将一组数据按照一定的顺序重新排列的过程。
常见的排序算法包括冒泡排序、选择排序、插入排序、快速排序、归并排序等。
-冒泡排序：该算法比较相邻的两个元素，并将较大的元素向后移动，重复此过程直到序列有序。
-选择排序：该算法通过不断选择最小的元素，并放到已排序部分的末尾，重复此过程直到整个序列有序。
-插入排序：该算法将元素逐个插入到已排好序的序列中，重复此过程直到整个序列有序。
-快速排序：该算法通过选择一个基准元素，将元素分为两个分区，并对每个分区递归地快速排序，最终将整个序列有序。
-归并排序：该算法将序列分为两个部分，并对每个部分递归地归并排序，最后将两个有序的部分归并。
上述排序算法中，冒泡排序和选择排序的时间复杂度为O(n^2)，插入排序的时间复杂度为O(n^2)或O(n)，快速排序和归并排序的平均时间复杂度为O(nlogn)。
2.查找算法查找算法是在一组数据中找到指定的元素的过程。
常见的查找算法包括线性查找、二分查找、哈希查找等。
-线性查找：该算法从序列的首个元素开始，逐个比较元素，直到找到指定元素或遍历完整个序列。
-二分查找：该算法通过比较中间元素和目标元素的大小关系，逐渐缩小查找范围，最终找到目标元素。
-哈希查找：该算法通过将元素与哈希函数的运算结果关联，将元素存储在哈希表中；查询时，通过哈希函数确定元素的位置，从而快速查找。
二分查找的时间复杂度为O(logn)，哈希查找的平均时间复杂度为O(1)。
3.字符串算法字符串算法是对字符串进行处理和操作的一系列算法。
常见的字符串算法包括字符串复制、字符串连接、字符串比较、字符串截取等。
- 字符串复制：可以使用strcpy函数实现字符串复制。
例如，strcpy(dest, src)将将src字符串复制到dest字符串中。
C语言常用算法归纳
C语言常用算法归纳C语言作为一种非常流行的编程语言，拥有丰富的算法库和常用算法。
在本篇文章中，我将为您介绍C语言中常用的算法分类，以及每个分类中的常用算法。
希望这篇文章能对您学习C语言算法有所帮助。
1.排序算法：排序算法用于将一组数据按照一定的顺序进行排列。
C语言中常用的排序算法有以下几种：-冒泡排序：通过依次比较相邻元素的大小，将较大的元素逐渐向后移动，实现排序。
-插入排序：将未排序的元素一个个插入到已经排序的序列中，使得整个序列有序。
-选择排序：每次从待排序的序列中选择最小（或最大）的元素，放到已排序序列的末尾。
-快速排序：通过一趟排序将待排序的数据分割成独立的两部分，然后再按照该方法对两部分数据分别进行快速排序，递归实现排序。
-归并排序：将待排序的数据递归地分成两部分，分别进行排序，然后将两个有序的子序列合并成一个有序的序列。
2.查找算法：查找算法用于在一组数据中寻找指定的元素。
C语言中常用的查找算法有以下几种：-顺序查找：从序列的起始位置依次遍历，直到找到目标元素。
-二分查找：对于已经排序的序列，通过每次将查找范围减半的方式进行查找，提高查找效率。
-插值查找：对于有序的序列，根据目标元素在序列中的分布情况，通过插值计算来确定查找位置。
3.字符串处理算法：字符串处理算法用于对字符串进行处理和操作。
C语言中常用的字符串处理算法有以下几种：-字符串比较：用于比较两个字符串是否相等。
-字符串拼接：将两个字符串合并成一个字符串。
-字符串查找：在一个字符串中寻找指定的子串。
-字符串替换：将字符串中指定的子串替换为新的子串。
4.图算法：图算法用于研究图结构的相关问题。
C语言中常用的图算法有以下几种：-广度优先：从图的其中一个顶点开始，按广度优先的原则依次访问与该顶点相邻的未访问的顶点。
-深度优先：从图的其中一个顶点开始，按深度优先的原则访问与该顶点相邻的未访问的顶点，直到无法继续访问为止。
- 最短路径算法：用于寻找两个顶点之间最短路径的算法，常见的最短路径算法有Dijkstra算法和Floyd算法。
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 等值的数。