非常全的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语言的人来说，掌握这些算法是非常重要的一步。
- 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 等值的数。