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和自身。
二、求两个整数的最大公约数、最小公倍数分析：求最大公约数的算法为辗转相除法。
(最小公倍数=两个整数之积/最大公约数)求最大公约数的算法步骤：(1) 对于已知两数m，n，使得m>n；(2) m除以n得余数r；r=m%n;(3) 若r= =0，则n为求得的最大公约数，算法结束；否则执行(4)；(4) m←n，n←r，再重复执行(2)。
例如: 求m=14 ,n=6 的最大公约数. m n r14 %6= 26 %2= 0 输出2void 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 t,r;if(m<n) { t=m;m=n;n=t; }do{ r=m%n;m=n; n=r; } while(n!=0)return m;}如果求最小公倍数，其函数形式稍作调整：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 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次后，这个数列已按升序排列。
程序代码如下：Array void main(){ int i,j,imin,s,a[10];printf("\n input 10 numbers:\n");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次两两比较。
程序段如下{ int a[10];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\，",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：存放找到元素的下void main(){ 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 want find:\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。
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语言算法程序的汇总：1.排序算法：-冒泡排序：通过多次迭代比较相邻元素并交换位置，将最大的元素逐渐移动到正确的位置。
-插入排序：将待排序的元素与已排序的部分依次比较并插入到正确的位置。
-选择排序：每次从待排序的元素中选择最小的元素并与已排序的部分交换位置。
-快速排序：通过选择一个基准元素，将数组划分为两个子数组进行递归排序。
2.查找算法：-顺序查找：逐个比较数组中的元素，直到找到目标元素或到数组末尾。
-二分查找：通过比较目标元素与数组中间元素的大小，逐步缩小范围，直到找到目标元素。
-哈希查找：通过散列函数将目标元素映射到哈希表的索引位置进行查找。
3.递归算法：-阶乘：通过递归调用自身计算一个正整数的阶乘。
-斐波那契数列：通过递归调用自身计算斐波那契数列的第n个数。
-二叉树遍历：通过递归调用自身遍历二叉树的各个节点。
4.图算法：- 最短路径算法：如Dijkstra算法和Floyd算法，用于计算图中两个节点之间的最短路径。
-拓扑排序：通过对有向无环图进行排序，使得所有的边从排在前面的节点指向排在后面的节点。
- 最小生成树：如Prim算法和Kruskal算法，用于找到图中连接所有节点的最小子树。
5.动态规划：-最长公共子序列：通过寻找两个字符串中的最长公共子序列，解决字符串匹配问题。
-背包问题：通过动态规划解决在给定容量下选取物品使得总价值最大的问题。
-最大子序列和：通过动态规划解决一个数组中选取连续子序列使得和最大的问题。
以上只是一些C语言中常用的算法程序的汇总，实际上，还有很多其他的算法，如逆波兰表达式、霍夫曼编码、最小割等等。
通过学习这些算法，可以更好地理解C语言的应用和开发。
C语言常用算法总结
C语言常用算法总结1、冒泡排序算法：冒泡排序是一种简单的排序算法，它重复地遍历要排序的序列，一次比较两个相邻的元素如果他们的顺序错误就把他们交换过来。
时间复杂度为O(n^2)。
2、快速排序算法：快速排序是一种基于分治的排序算法，通过递归的方式将数组划分为两个子数组，然后对子数组进行排序最后将排好序的子数组合并起来。
时间复杂度为O(nlogn)。
3、插入排序算法：插入排序是一种简单直观的排序算法，通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描找到相应位置并插入。
时间复杂度为O(n^2)。
4、选择排序算法：选择排序是一种简单的排序算法，每次循环选择未排序部分的最小元素，并放置在已排序部分的末尾。
时间复杂度为O(n^2)。
5、归并排序算法：归并排序是一种稳定的排序算法，基于分治思想，将数组递归地分为两个子数组，将子数组排序后再进行合并最终得到有序的数组。
时间复杂度为O(nlogn)。
6、堆排序算法：堆排序是一种基于完全二叉堆的排序算法，通过构建最大堆或最小堆，然后依次将堆顶元素与末尾元素交换再调整堆，得到有序的数组。
时间复杂度为O(nlogn)。
7、二分查找算法：二分查找是一种在有序数组中查找目标元素的算法，每次将待查找范围缩小一半，直到找到目标元素或范围为空。
时间复杂度为O(logn)。
8、KMP算法：KMP算法是一种字符串匹配算法，通过利用模式字符串的自重复性，避免不必要的比较提高匹配效率。
时间复杂度为O(m+n)，其中m为文本串长度，n为模式串长度。
9、动态规划算法：动态规划是一种通过将问题分解为子问题，并通过组合子问题的解来求解原问题的方法。
动态规划算法通常使用内存空间来存储中间结果，从而避免重复计算。
时间复杂度取决于问题规模。
10、贪心算法：贪心算法是一种通过选择局部最优解来构建全局最优解的算法并以此构建最终解。
时间复杂度取决于问题规模。
11、最短路径算法：最短路径算法用于求解图中两个节点之间的最短路径，常见的算法包括Dijkstra算法和Floyd-Warshall算法。
非常全的C语言常用算法
一、基本算法1．交换（两量交换借助第三者）例1、任意读入两个整数，将二者的值交换后输出。
main(){int a,b,t;scanf("%d%d",&a,&b);printf("%d,%d\n",a,b);t=a; a=b; b=t;printf("%d,%d\n",a,b);}【解析】程序中加粗部分为算法的核心，如同交换两个杯子里的饮料，必须借助第三个空杯子。
假设输入的值分别为3、7，则第一行输出为3，7；第二行输出为7，3。
其中t为中间变量，起到“空杯子”的作用。
注意：三句赋值语句赋值号左右的各量之间的关系！【应用】例2、任意读入三个整数，然后按从小到大的顺序输出。
main(){int a,b,c,t;scanf("%d%d%d",&a,&b,&c);/*以下两个if语句使得a中存放的数最小*/if(a>b){ t=a; a=b; b=t; }if(a>c){ t=a; a=c; c=t; }/*以下if语句使得b中存放的数次小*/if(b>c) { t=b; b=c; c=t; }printf("%d,%d,%d\n",a,b,c);}2．累加累加算法的要领是形如“s=s+A”的累加式，此式必须出现在循环中才能被反复执行，从而实现累加功能。
“A”通常是有规律变化的表达式，s在进入循环前必须获得合适的初值，通常为0。
例1、求1+2+3+……+100的和。
main(){int i,s;s=0; i=1;while(i<=100){s=s+i; /*累加式*/i=i+1; /*特殊的累加式*/}printf("1+2+3+...+100=%d\n",s);}【解析】程序中加粗部分为累加式的典型形式，赋值号左右都出现的变量称为累加器，其中“i = i + 1”为特殊的累加式，每次累加的值为1，这样的累加器又称为计数器。
C语言常用算法大全
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");
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语言入门必学—10个经典C语言算法
C语言入门必学—10个经典C语言算法C语言是一种广泛使用的编程语言，具有高效、灵活和易学的特点。
它不仅在软件开发中被广泛应用，也是计算机科学专业的必修课。
在学习C语言的过程中，掌握一些经典的算法是非常重要的。
本文将介绍10个经典C语言算法，帮助读者更好地了解和掌握C语言。
一、冒泡排序算法（Bubble Sort）冒泡排序算法是最简单、也是最经典的排序算法之一。
它通过不断比较相邻的元素并交换位置，将最大（或最小）的元素逐渐“冒泡”到数组的最后（或最前）位置。
二、选择排序算法（Selection Sort）选择排序算法是一种简单但低效的排序算法。
它通过不断选择最小（或最大）的元素，并与未排序部分的第一个元素进行交换，将最小（或最大）的元素逐渐交换到数组的前面（或后面）。
三、插入排序算法（Insertion Sort）插入排序算法是一种简单且高效的排序算法。
它通过将数组分为已排序和未排序两个部分，依次将未排序部分的元素插入到已排序部分的合适位置。
四、快速排序算法（Quick Sort）快速排序算法是一种高效的排序算法。
它采用了分治的思想，通过将数组分为较小和较大两部分，并递归地对两部分进行排序，最终达到整个数组有序的目的。
五、归并排序算法（Merge Sort）归并排序算法是一种高效的排序算法。
它采用了分治的思想，将数组一分为二，递归地对两个子数组进行排序，并将结果合并，最终得到有序的数组。
六、二分查找算法（Binary Search）二分查找算法是一种高效的查找算法。
它通过不断将查找范围折半，根据中间元素与目标值的大小关系，缩小查找范围，最终找到目标值所在的位置。
七、递归算法（Recursive Algorithm）递归算法是一种通过自我调用的方式解决问题的算法。
在C语言中，递归算法常用于解决树的遍历、问题分解等情况。
八、斐波那契数列算法（Fibonacci Sequence）斐波那契数列是一列数字，其中每个数字都是前两个数字的和。
c语言18个经典程序
c语言18个经典程序1. Hello, World! - 这是经典的C语言第一个程序，用于输出"Hello, World!"。
2. 求两个整数的和 - 用户输入两个整数，程序将计算并输出它们的和。
3. 判断一个数是奇数还是偶数 - 用户输入一个整数，程序将判断并输出该数是奇数还是偶数。
4. 求一个数的平方 - 用户输入一个数，程序将计算并输出该数的平方。
5. 求两个数的最大公约数 - 用户输入两个整数，程序将计算并输出它们的最大公约数。
6. 判断一个数是否为质数 - 用户输入一个正整数，程序将判断并输出该数是否为质数。
7. 求一个数的阶乘 - 用户输入一个正整数，程序将计算并输出该数的阶乘。
8. 生成斐波那契数列 - 用户输入一个正整数n，程序将生成并输出前n个斐波那契数。
9. 判断一个数是否为完全数 - 用户输入一个正整数，程序将判断并输出该数是否为完全数。
10. 判断一个字符串是否为回文字符串 - 用户输入一个字符串，程序将判断并输出该字符串是否为回文字符串。
11. 求一个数的倒数 - 用户输入一个非零实数，程序将计算并输出该数的倒数。
12. 求两个数的最小公倍数 - 用户输入两个正整数，程序将计算并输出它们的最小公倍数。
13. 判断一个年份是否为闰年 - 用户输入一个年份，程序将判断并输出该年份是否为闰年。
14. 生成九九乘法表 - 程序将生成并输出九九乘法表。
15. 判断一个数是否为负数、零或正数 - 用户输入一个实数，程序将判断并输出该数是负数、零还是正数。
16. 判断一个数是否为偶数的平方 - 用户输入一个整数，程序将判断并输出该数是否为偶数的平方。
17. 判断一个数是否为回文数 - 用户输入一个正整数，程序将判断并输出该数是否为回文数。
18. 判断一个字符串是否为回文句子 - 用户输入一个句子，程序将判断并输出该句子是否为回文句子。
这些经典的C语言程序涵盖了基本的输入输出、数学运算、条件判断、循环、字符串处理等方面的知识点。
C语言常用算法总结
C语言常用算法模块的总结一、最大值，最小值问题教材page13/1.6、page36/2.4（2）、（3）、page98例5.1、5.2二、连乘连加问题 page113、114、115 page129/6.3 page129/6.4、6.5三、闰年算法 page17、 page107四、连续小数相加减 page18、 page124五、素数、整除问题 page18、 page124、 page126、 page127六、大小写字母转换、密码问题 page51、 page87、 page89/4.9、 page104、 page67、 page128七、格式化字符提醒起于page 76八、三角形面积问题 page86九、一元二次方程 page87、 page89/4.8、 page108十、分段一元函数 page100、 page110、 page111/5.5、5.6十一、位运算 page112/5.7、 page129/6.2、6.3十二、公约数公倍数 page129/6.1十三、迭代法、二分法 page129-130/6.11-13C语言常用算法模块的总结一、最大值，最小值问题教材page13/1.6、page36/2.4（2）、（3）、page98例5.1、5.2主要思想：替换+中转关联习语： if句int a,b,c,max; 多余的一个max是承载中转的容器scanf(“%d,%d,%d”,&a,&b,&c);max=a; 定初值if(max<b)Max=b; 分别取a、 b、c相互比较，由于只需输if(max<c) 出最大或者最小值，所以只需将最大值存Max=c; 储在max中即可printf(“……”);如果需要依次输出所给的数值，则须在比较大小之后进行替换赋值int a,b,t;scanf(“%d,%d”,&a,&b)if(a>b){ 此步的依次赋值体现了赋值运算自右向左的结合次序t=a; 先将a的值赋给t，此时a的值空出a=b; 将b的值赋给a,b值空出b=t; 将t中存储的a的值赋给b，此时t仍回复空值} 若混淆其中赋值规律则产生混乱printf(“……”);二、连乘连加问题page113、114、115 page129/6.3 page129/6.4、6.5主要思想：容器+循环关联习语：while（do……while）、for、（goto）int i,sum=0; 循环第一步，定初值，sum可视作是承载运算结果的容器，初为空i=1;while(i<=100) 构设循环条件，注意必须是有限循环，否则程序无终止{sum=sum+I; 循环第二步，累计结果i++; 循环第三步，循环量自增。
C语言程序设计的常用算法
C语言程序设计的常用算法1.排序算法-冒泡排序：通过多次比较和交换来将最大（小）的数移到最后（前），时间复杂度为O(n^2)。
适用于数据较少、数据基本有序的情况。
- 快速排序：通过一趟排序将待排序序列分隔成独立的两部分，其中一部分的所有元素都比另一部分的所有元素小。
然后递归地对两部分进行排序，时间复杂度为O(nlogn)。
适用于大规模数据的排序。
-插入排序：将待排序序列分为已排序和未排序两部分，每次从未排序部分取一个元素插入到已排序部分的适当位置，时间复杂度为O(n^2)。
适用于数据量较小的排序场景。
- 归并排序：将待排序序列分为若干个子序列，分别进行排序，然后再将排好序的子序列合并成整体有序的序列，时间复杂度为O(nlogn)。
适用于需要稳定排序且对内存空间要求不高的情况。
2.查找算法-顺序查找：从头到尾依次对每个元素进行比较，直到找到目标元素或者遍历完整个序列。
时间复杂度为O(n)。
- 二分查找：对于有序序列，将序列的中间元素与目标元素进行比较，根据比较结果缩小查找范围，直到找到目标元素或者查找范围为空。
时间复杂度为O(logn)。
3.图算法-广度优先（BFS）：从给定的起始顶点开始，按照“先访问当前顶点的所有邻接顶点，再依次访问这些邻接顶点的所有未访问过的邻接顶点”的顺序逐层访问图中的所有顶点。
适用于寻找最短路径、连通性等问题。
-深度优先（DFS）：从给定的起始顶点开始，按照“先递归访问当前顶点的一个邻接顶点，再递归访问这个邻接顶点的一个邻接顶点，直到无法再继续递归”的方式遍历图中的所有顶点。
适用于寻找路径、判断连通性等问题。
4.动态规划算法-背包问题：给定一个背包容量和一组物品的重量和价值，选择一些物品装入背包，使得装入的物品总重量不超过背包容量，且总价值最大。
利用动态规划的思想可以通过构建二维数组来解决该问题。
-最长公共子序列（LCS）：给定两个序列，找出一个最长的子序列，且该子序列在两个原序列中的顺序保持一致。