C语言常用算法程序汇总
C程序经典算法50例
C程序经典算法50例1.二分查找算法：在有序数组中查找指定元素。
2.冒泡排序算法：通过不断比较相邻元素并交换位置，将较大的元素向后冒泡。
3.快速排序算法：通过选择一个基准元素，将数组分割为左右两部分，并递归地对两部分进行快速排序。
4.插入排序算法：将数组划分为已排序和未排序两部分，每次从未排序中选择一个元素插入到已排序的合适位置。
5.选择排序算法：遍历数组，每次选择最小元素并放置在已排序部分的末尾。
6.希尔排序算法：将数组按照一定间隔进行分组并分别进行插入排序，然后逐步减小间隔并重复这个过程。
7.归并排序算法：将数组递归地划分为两部分，然后将两个有序的部分进行合并。
8.桶排序算法：将元素根据特定的映射函数映射到不同的桶中，然后对每个桶分别进行排序。
9.计数排序算法：统计每个元素的出现次数，然后根据计数进行排序。
10.基数排序算法：从低位到高位依次对元素进行排序。
11.斐波那契数列算法：计算斐波那契数列的第n项。
12.阶乘算法：计算给定数字的阶乘。
13.排列问题算法：生成给定数组的全排列。
14.组合问题算法：生成给定数组的所有组合。
15.最大连续子序列和算法：找出给定数组中和最大的连续子序列。
16.最长递增子序列算法：找出给定数组中的最长递增子序列。
17.最长公共子序列算法：找出两个给定字符串的最长公共子序列。
18.最短路径算法：计算给定有向图的最短路径。
19.最小生成树算法：构建给定连通图的最小生成树。
20.汉诺塔算法：将n个圆盘从一个柱子移动到另一个柱子的问题。
21.BFS算法：广度优先算法，用于图的遍历和查找最短路径。
22.DFS算法：深度优先算法，用于图的遍历和查找连通分量。
23.KMP算法：字符串匹配算法，用于查找一个字符串是否在另一个字符串中出现。
24.贪心算法：每次都选择当前情况下最优的方案，适用于求解一些最优化问题。
25.动态规划算法：将一个大问题划分为多个子问题，并通过子问题的解求解整个问题，适用于求解一些最优化问题。
C语言经典算法C语言代码大全
C语言经典算法C语言代码大全以下是一个非常简单的C语言代码示例，实现了冒泡排序算法。
冒泡排序是一种简单的排序算法，也是最经典和常用的排序算法之一```c#include <stdio.h>//冒泡排序函数void bubbleSort(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];arr[j+1] = temp;}}}int maiint n, i;printf("请输入数组中元素的个数：");scanf("%d", &n);int arr[n];printf("请输入数组元素：");for (i = 0; i < n; i++)scanf("%d", &arr[i]);}bubbleSort(arr, n);printf("排序后的数组为：");for (i = 0; i < n; i++)printf("%d ", arr[i]);}return 0;```这段代码实现了一个简单的冒泡排序算法。
用户可以输入一个整数数组，然后使用冒泡排序对数组进行排序，并打印出结果。
注意事项：1.该代码需要在支持C语言的编译器或集成开发环境中运行。
2. 在代码中使用了`scanf`函数来从用户输入获取数组元素，请确保输入的格式匹配。
3.该代码中的冒泡排序算法是一种基本的算法，适用于小规模数据，对于大规模数据可能效率较低，不适用于高性能要求的场景。
非常全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语言经典算法大全
C语言经典算法大全1.冒泡排序算法冒泡排序是一种简单但低效的排序算法，它通过多次遍历列表，比较相邻元素并交换位置，直到整个列表有序。
冒泡排序的时间复杂度为O(n^2)。
```void bubbleSort(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];arr[j+1] = temp;}}}```2.选择排序算法选择排序是一种简单但高效的排序算法，它通过多次遍历列表，找到最小元素并将其放置在正确的位置上。
选择排序的时间复杂度也为O(n^2)。
```void selectionSort(int arr[], int n)int minIndex, temp;for (int i = 0; i < n-1; i++)minIndex = i;for (int j = i+1; j < n; j++)if (arr[j] < arr[minIndex])minIndex = j;}}//交换元素temp = arr[i];arr[i] = arr[minIndex];arr[minIndex] = temp;}```3.插入排序算法插入排序是一种简单但高效的排序算法，它通过将未排序的元素插入到已排序的列表中，逐步构建排序好的列表。
插入排序的时间复杂度为O(n^2)。
```void insertionSort(int arr[], int n)int i, key, j;for (i = 1; i < n; i++)key = arr[i];j=i-1;while (j >= 0 && arr[j] > key)arr[j + 1] = arr[j];j=j-1;}arr[j + 1] = key;}```4.快速排序算法快速排序是一种高效的排序算法，它通过选择一个主元，将列表分割为两个子列表，其中一个子列表的所有元素都小于主元，另一个子列表的所有元素都大于主元。
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语言算法全总结
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.排序算法-冒泡排序：依次比较相邻的两个元素，如果顺序不对则交换，每轮找出一个最大或最小的元素-选择排序：从未排序的元素中选择最小或最大的放到已排序的最后，以此类推-插入排序：将未排序的元素插入到已排序的合适位置，从后向前进行比较和交换-快速排序：选择一个基准元素，将小于基准元素的放在左边，大于基准元素的放在右边，然后对左右两边递归地进行快速排序-归并排序：将待排序的序列不断划分为左右两部分，分别排序后再将排序好的左右两部分按顺序合并-堆排序：构建大顶堆，将堆顶元素与末尾元素交换，然后重新调整堆，重复这个过程直到排序完成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.交换(两量交换借助第三者)例1、任意读入两个整数，将二者的值交换后输出。
main(){int a,b,t;scanf("%d%d",&a,&b);printf("%d,%d ",a,b);t=a; a=b; b=t;printf("%d,%d ",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>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("%d,%d,%d ",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 ",s);}【解析】程序中加粗部分为累加式的典型形式，赋值号左右都出现的变量称为累加器，其中“i = i + 1”为特殊的累加式，每次累加的值为1，这样的累加器又称为计数器。
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常用算法程序集
c常用算法程序集C常用算法程序集一、排序算法排序算法是计算机科学中最基本、最常用的算法之一，常用于按照一定的规则将一组数据进行有序排列。
常见的排序算法有：冒泡排序、插入排序、选择排序、快速排序、归并排序等。
1. 冒泡排序：通过相邻元素的比较和交换来实现排序。
每一轮将最大的元素逐渐“冒泡”到末尾。
时间复杂度为O(n^2)。
2. 插入排序：将待排序的元素插入已排好序的部分，从而达到排序的目的。
时间复杂度为O(n^2)，但在部分有序的情况下表现较好。
3. 选择排序：每一轮从待排序的元素中选出最小（或最大）的元素放到已排序的末尾。
时间复杂度为O(n^2)，性能较差。
4. 快速排序：通过一趟排序将待排序的序列分割成两部分，其中一部分的所有元素都比另一部分小。
再分别对两部分进行排序，递归地进行下去。
时间复杂度为O(nlogn)，性能较好。
5. 归并排序：将待排序的序列分成若干个子序列，分别进行排序，然后再将排好序的子序列合并。
时间复杂度为O(nlogn)，稳定且效率较高。
二、查找算法查找算法是在给定的数据集中寻找特定元素的过程，常用于在大规模数据中快速定位目标元素。
常见的查找算法有：顺序查找、二分查找、哈希查找等。
1. 顺序查找：逐个遍历待查找的元素，直到找到目标元素或遍历完整个数据集。
时间复杂度为O(n)，适用于小规模数据集。
2. 二分查找：在有序的数据集中，将目标元素与中间元素进行比较，缩小查找范围，直到找到目标元素或范围为空。
时间复杂度为O(logn)，适用于大规模数据集。
3. 哈希查找：利用哈希函数将元素映射到一个确定的位置，通过该位置快速查找目标元素。
时间复杂度为O(1)，但需要额外的空间存储哈希表。
三、图算法图算法用于解决图论中的问题，常用于描述事物之间的关系和网络结构。
常见的图算法有：深度优先搜索（DFS）、广度优先搜索（BFS）、最短路径算法（Dijkstra算法、Floyd-Warshall算法）等。
(完整word版)C语言必背18个经典程序
C语言必背18个经典程序1、/*输出9*9口诀。
共9行9列，i控制行，j控制列。
*/#include "stdio.h"main(){int i,j,result;for (i=1;i<10;i++){ for(j=1;j<10;j++){result=i*j;printf("%d*%d=%-3d",i,j,result);/*-3d表示左对齐，占3位*/}printf("\n");/*每一行后换行*/}system("pause");}2、/*古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？兔子的规律为数列1,1,2,3,5,8,13,21....*/main(){long f1,f2;int i;f1=f2=1;for(i=1;i<=20;i++){ printf("%12ld %12ld",f1,f2);if(i%2==0) printf("\n");/*控制输出，每行四个*/f1=f1+f2; /*前两个月加起来赋值给第三个月*/f2=f1+f2; /*前两个月加起来赋值给第三个月*/}}3、/*判断101-200之间有多少个素数，并输出所有素数及素数的个数。
程序分析：判断素数的方法：用一个数分别去除2到sqrt(这个数)，如果能被整除，则表明此数不是素数，反之是素数。
*/#include "math.h"main(){int m,i,k,h=0,leap=1;printf("\n");for(m=101;m<=200;m++){ k=sqrt(m);for(i=2;i<=k;i++)if(m%i==0){leap=0;break;}if(leap) /*内循环结束后，leap依然为1，则m是素数*/{printf("%-4d",m);h++;if(h%10==0)printf("\n");}leap=1;}printf("\nThe total is %d",h);system("pause");}4、/*一个数如果恰好等于它的因子之和，这个数就称为“完数”。
C语言经典算法大全
C语言经典算法大全1. 冒泡排序（Bubble Sort）：比较相邻的元素，如果顺序错误就交换位置，直到整个序列有序。
2. 快速排序（Quick Sort）：选择一个中间元素作为基准，将序列分成两部分，左边的元素都小于等于基准，右边的元素都大于等于基准，然后递归地对两个子序列进行排序。
3. 插入排序（Insertion Sort）：将元素逐个插入到已经排序的序列中，直到整个序列有序。
4. 选择排序（Selection Sort）：每次选择一个最小（或最大）的元素放到有序序列的末尾（或开头），直到整个序列有序。
5. 归并排序（Merge Sort）：将序列分成若干个子序列，对每个子序列进行排序，然后再将已排好序的子序列合并成一个有序序列。
6. 希尔排序（Shell Sort）：将序列划分成若干个小的子序列分别进行直接插入排序，然后逐渐减小子序列的间隔直到整个序列有序。
7. 堆排序（Heap Sort）：利用堆这种数据结构进行排序，构建一个大（或小）根堆，依次将根节点（最大或最小值）和最后一个节点交换位置，然后重新调整堆。
8. 计数排序（Counting Sort）：统计每个元素的出现次数，然后根据统计结果，将元素按照顺序放入相应位置，从而实现排序。
9. 桶排序（Bucket Sort）：将元素分到不同的桶中，桶内元素进行排序，然后按照桶的顺序将元素取出，从而实现排序。
10.基数排序（Radix Sort）：根据元素的位数进行排序，首先排个位，然后排十位，以此类推，直到排完最高位。
除了上述排序算法之外，C语言中还有许多其他经典算法，例如二分查找、递归、深度优先、广度优先、贪心算法、动态规划等等。
这些算法都有各自的特点和应用场景，对于提高编程水平和解决实际问题都有很大的帮助。
总结起来，掌握C语言的经典算法对于编程爱好者来说是非常重要的。
它们可以帮助我们更好地理解计算机科学的基本原理和数据结构，提高我们编写程序的能力和效率。
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语言代码大全一、排序算法1、冒泡排序它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。
设数组为a[0…n-1]C语言实现如下：//冒泡排序void bubbleSort(int arr[], int n)int i, j, temp;bool flag;//表示n次排序过程for(i = 0; i < n - 1; i++)//每次排序将最大的数放到最右边flag = false;for(j= 0; j< n-1-i; j++)if(arr[j] > arr[j+1])temp = arr[j];arr[j] = arr[j+1];arr[j+1] = temp;flag = true;}}//如果趟排序没有进行数据交换，说明数据已经有序if (flag == false)break;}}2、快速排序它采用了分治法的思想，基于快速排序的思想，可以对数组进行非常快速的排序。
设数组为a[0…n-1]C语言实现如下：//快速排序// arr[left] 为起始值，arr[right] 为末尾值void quickSort(int arr[], int left, int right)int i, j, base;if (left > right)return;}i = left;j = right;base = arr[left];//定义基准值，可以是数组的第一个值while (i != j)// 因为基准值是 arr[left],所以左边右移，直到找到小于基准值的值while (arr[j] >= base && i < j)j--;}// 因为基准值是 arr[left],所以右边左移while (arr[i] <= base && i < j)i++;}//如果i<j，表示找到了，交换位置if (i < j)int temp = arr[i];arr[i] = arr[j];arr[j] = temp;}}//将基准值放到i位置arr[left] = arr[i];。
单片机常用的14个C语言算法2024
引言概述：在单片机的开发中，C语言是最常用的编程语言之一。
掌握一些常用的C语言算法对于单片机的开发非常重要。
本文将介绍单片机常用的14个C语言算法之二，包括排序算法、查找算法、递归算法、动态规划算法和图算法。
正文内容：一、排序算法1. 冒泡排序：通过不断地交换相邻元素的位置，将大的元素冒泡到数组的末尾。
2. 快速排序：通过选择一个基准元素，将小于基准元素的数移动到基准元素左边，将大于基准元素的数移动到基准元素右边，然后分别对左右两部分递归地进行快速排序。
3. 插入排序：将数组分为已排序和未排序两部分，每次从未排序部分取一个元素，将其插入已排序部分的合适位置。
4. 选择排序：每次从未排序部分选择最小的元素，将其放在已排序部分的末尾。
5. 归并排序：将数组不断划分为更小的子数组，然后将子数组合并为有序数组。
二、查找算法1. 顺序查找：逐个比较数组中的元素，直到找到目标元素或者遍历完整个数组。
2. 二分查找：对于已排序的数组，通过不断将目标值与中间元素比较，并缩小搜索范围，最终找到目标元素的位置。
3. 插值查找：与二分查找类似，不同之处在于确定中间元素的位置时使用插值公式，使得查找范围更接近目标元素。
4. 哈希查找：使用哈希函数将关键字映射到一个唯一的哈希值，通过查找哈希值对应的位置来获取关键字。
5. 递归查找：通过递归地划分问题的规模，从而减小查找范围，最终找到目标元素。
三、递归算法1. 递归定义：在函数的定义中使用函数本身的方式称为递归。
2. 递归函数的特点：包含一个递归结束的条件和一个递归调用的表达式。
3. 递归算法的实现：通过不断把原问题转化为更小规模的子问题，直到满足递归结束的条件。
4. 递归算法的应用：在树、图等数据结构的遍历、搜索等问题中，递归算法被广泛使用。
5. 递归算法的优化：如尾递归优化、记忆化搜索等方法可以避免递归算法中的重复计算。
四、动态规划算法1. 动态规划的思想：将一个问题划分为多个子问题，并保存每个子问题的解，避免重复计算。
C语言常见算法代码集锦
{ do
{ Sleep(1000);printf("\n\n");
for (i=0;i<54;i++) 4);
if (check(b,54)) { for(i=0;i<heap;i++)
for(j=0;j<num;j++) printf("%s%c",a[b[i*num+j]],j<num-1?' ':'\n');
④选择排序
#include <stdio.h> #include <stdlib.h> int main() {
int a[100]; int i,j,k,t,n; printf("输 入 需 要 排 序 的 数 的 个 数 :"); scanf("%d",&n); printf("\n 输 入 %d 个 需 要 排 序 的 数 :",n); for(i=0;i<n;i++)
{ for(j=0;j<n;j++) printf("%d ",a[i][j]); printf("\n");
} for(i=0;i<n;i++)
for(j=i;j<n;j++) {
t=a[i][j]; a[i][j]=a[j][i]; a[j][i]=t; } printf("转 置 后 的 行 列 式 :\n"); for(i=0;i<n;i++) { for(j=0;j<n;j++) printf("%d ",a[i][j]); printf("\n"); }
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
C程序设计的常用算法算法（Algorithm）：计算机解题的基本思想方法和步骤。
算法的描述：是对要解决一个问题或要完成一项任务所采取的方法和步骤的描述，包括需要什么数据（输入什么数据、输出什么结果）、采用什么结构、使用什么语句以及如何安排这些语句等。
通常使用自然语言、结构化流程图、伪代码等来描述算法。
一、简单数值类算法此类问题都要使用循环，要注意根据问题确定循环变量的初值、终值或结束条件，更要注意用来表示计数、和、阶乘的变量的初值。
1、求阶乘下列程序用于求n的阶乘.在累乘之前,一定要将用于存放乘积的变量的值初始化为1.long func(int n){int i;long t=1;for(i=2;i<=n;i++)t*=i;return t;}printf("\n");}2、整数拆分问题：把一个整数各个位上的数字存到数组中#define N 4 /* N代表整数位数*/viod split(int n, int a[ ]）{int i;for(i=N-1;n!=0; i--){ a[i]=n%10;n=n/10;}}3、求整数的因子之和long factor(int n){int i;long sum=0;for(i=1;i<=n;i++)if(n%i= =0)sum+=i;return sum;}注意：因子包括1和自身。
二、求两个整数的最大公约数、最小公倍数分析：求最大公约数的算法为辗转相除法。
(最小公倍数=两个整数之积/最大公约数)求最大公约数的算法步骤：(1) 对于已知两数m，n，使得m>n；(2) m除以n得余数r；(3) 若r=0，则n为求得的最大公约数，算法结束；否则执行(4)；(4) m←n，n←r，再重复执行(2)。
例如: 求m=14 ,n=6 的最大公约数. m n r14 %6= 26 %2= 0void main(){ int nm,r,n,m,t;printf("please input two numbers:\n");scanf("%d,%d",&m,&n);nm=n*m;if (m<n){ t=n; n=m; m=t; }r=m%n;while (r!=0){ m=n; n=r; r=m%n; }printf("最大公约数:%d\n",n);printf("最小公倍数:%d\n",nm/n);}将其写成一函数,返回最大公约数。
int gcd(int m,int n){ int t,r;if(m<n) { t=m;m=n;n=t; }r=m%n;while(r!=0){ m=n; n=r; r=m%n; }return n;}如果求最小公倍数，其函数形式稍作调整：int gcd(int m,int n){ int a=m, b=n;int t,r;if(m<n) { t=m;m=n;n=t; }r=m%n;while(r!=0){ m=n; n=r; r=m%n; }return (a*b)/n;}三、判断素数只能被1和本身整除的正整数称为素数。
基本思想：在判断数m是否为素数时，首先把m作为被除数，将2—sqrt(m)的所有数字依次作为除数，去除m，只要有一个数能将m整除，则m不是素数；否则，如果都除不尽，则m就是素数。
（可用以下程序段实现）#include <math.h>void main(){ int m,i,k;printf("please input a number:\n");scanf("%d",&m);k=sqrt(m); /*使用此函数一定要加头文件#include <math.h>*/ for(i=2;i<k;i++)if(m%i==0) break;if(i>=k)printf("该数是素数");elseprintf("该数不是素数");}将其写成一函数,若为素数返回1，不是则返回0int prime( int m){int i,k;k=sqrt(m); /*使用此函数一定要加头文件#include <math.h>*/for(i=2;i<k;i++)if(m%i==0) return 0; return 1; }四、求最值例如求最小值算法思想：定义变量min 用于存放当前所有找到的最小数，a 为已知数组。
算法步骤如下：1）在min 中存放第1个数，比较从数组中的第二个元素开始。
2）数组a 中每个元素依次与min 中的数组相比，小者放入min 中。
3）比较完数组的最后一个元素，算法结束。
Min 中数为所求。
程序如下：int minvalue(int a[],int n) {int i,min; min=a[0]; for(i=0;i<n;i++)if(a[i]<min) min=a[i]; return min; } main(){ int a[10]={12,45,7,8,96,4,10,48,2,46},i,min; for(i=0;i<10;i++) printf(“%3d ”,a[i]);printf(“\n ”); min=minvalue(a,10); printf(“the result is:%d ”, min); }五：排序问题1．选择法排序（升序）基本思想：1）对有n个数的序列（存放在数组a(n)中），从中选出最小的数，与第1个数交换位置；2）除第1 个数外，其余n-1个数中选最小的数，与第2个数交换位置；3）依次类推，选择了n-1次后，这个数列已按升序排列。
void main(){ int i,j,imin,s,a[10];for(i=0;i<10;i++)scanf("%d",&a[i]);for(i=0;i<9;i++){ imin=i;for(j=i+1;j<10;j++)if(a[imin]>a[j]) imin=j;if(i!=imin){s=a[i]; a[i]=a[imin]; a[imin]=s; }printf("%d\n",a[i]);}}2．冒泡法排序（升序）基本思想：(将相邻两个数比较，小的调到前头)1）有n个数（存放在数组a(n)中），第一趟将每相邻两个数比较，小的调到前头，经n-1次两两相邻比较后，最大的数已“沉底”，放在最后一个位置，小数上升“浮起”；2）第二趟对余下的n-1个数（最大的数已“沉底”）按上法比较，经n-2次两两相邻比较后得次大的数；3）依次类推，n个数共进行n-1趟比较，在第j趟中要进行n-j次两两比较。
程序段如下void main()int i,j,t;printf("input 10 numbers\n");for(i=0;i<10;i++)scanf("%d",&a[i]);printf("\n");for(j=0;j<=8;j++)for(i=0;i<9-j;i++)if(a[i]>a[i+1]){t=a[i];a[i]=a[i+1];a[i+1]=t;}printf("the sorted numbers:\n");for(i=0;i<10;i++)printf("%d\n",a[i]);}3．合并法排序（将两个有序数组A、B合并成另一个有序的数组C，升序）基本思想：1）先在A、B数组中各取第一个元素进行比较，将小的元素放入C数组；2）取小的元素所在数组的下一个元素与另一数组中上次比较后较大的元素比较，重复上述比较过程，直到某个数组被先排完；3）将另一个数组剩余元素抄入C数组，合并排序完成。
程序段如下：void main(){ int a[10],b[10],c[20],i,ia,ib,ic;printf("please input the first array:\n");for(i=0;i<10;i++)scanf("%d",&a[i]);for(i=0;i<10;i++)scanf("%d",&b[i]);printf("\n");ia=0;ib=0;ic=0;while(ia<10&&ib<10){ if(a[ia]<b[ib]){ c[ic]=a[ia];ia++;}else{ c[ic]=b[ib];ib++;} ic++;}while(ia<=9){ c[ic]=a[ia];ia++;ic++;}while(ib<=9){ c[ic]=b[ib];ib++;ic++;}for(i=0;i<20;i++) printf("%d\n",c[i]); }六、查找问题1．①顺序查找法（在一列数中查找某数x）思考：将上面程序改写一查找函数Find，若找到则返回下标值，找不到返回-1②基本思想：一列数放在数组a[1]---a[n]中，待查找的关键值为key，把key 与a数组中的元素从头到尾一一进行比较查找，若相同，查找成功，若找不到，则查找失败。
(查找子过程如下。
index：存放找到元素的下标。
){ int a[10],index,x,i;printf("please input the array:\n");for(i=0;i<10;i++)scanf("%d",&a[i]);printf("please input the number you wantfind:\n");scanf("%d",&x);printf("\n");index=-1;for(i=0;i<10;i++)if(x==a[i]){ index=i; break;}if(index==-1)printf("the number is not found!\n");elseprintf("the number is found the no%d!\n",index);}2．折半查找法（只能对有序数列进行查找）基本思想：设n个有序数（从小到大）存放在数组a[1]----a[n]中，要查找的数为x。