C语言常用算法集合

合集下载

C语言七大算法

C语言七大算法

C语言七大算法一、概述算法是计算机程序设计中解决问题的方法和步骤的描述,是计算机科学的重要基础。

在计算机科学中,有许多经典的算法被广泛应用,并成为不可或缺的工具。

本文将介绍C语言中的七大经典算法,包括排序算法、查找算法、图算法、字符串算法、动态规划算法、贪心算法和分治算法。

二、排序算法排序是将一组元素按照特定规则进行重新排列的过程。

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

这些排序算法在C语言中都有相应的实现,并且各有特点和适用场景。

三、查找算法查找算法用于在一组数据中查找特定值的位置或判断是否存在。

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

这些算法在C语言中的实现可以帮助我们快速地定位目标值。

四、图算法图算法用于解决与图相关的问题,包括最短路径问题、最小生成树问题、拓扑排序等。

在C语言中,我们可以利用图的邻接矩阵或邻接表来实现相关的图算法。

五、字符串算法字符串算法主要用于解决字符串匹配、替换、拼接等问题。

在C语言中,我们可以使用字符串库函数来完成一些基本的字符串操作,例如字符串比较、复制、连接等。

六、动态规划算法动态规划算法是解决一类最优化问题的常用方法,它将问题分解为多个子问题,并通过保存已解决子问题的结果来避免重复计算。

在C语言中,我们可以使用动态规划算法来解决背包问题、最长公共子序列问题等。

七、贪心算法贪心算法是一种通过每一步的局部最优选择来达到全局最优的方法。

贪心算法通常在解决最优化问题时使用,它快速、简单,并且可以给出近似最优解。

C语言中可以使用贪心算法来解决霍夫曼编码、最小生成树等问题。

八、分治算法分治算法是一种将问题分解为多个相同或类似的子问题然后递归解决的方法。

常见的分治算法有快速排序、归并排序等。

在C语言中,我们可以使用分治算法来提高程序的效率和性能。

总结:本文介绍了C语言中的七大经典算法,包括排序算法、查找算法、图算法、字符串算法、动态规划算法、贪心算法和分治算法。

非常全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语言常用算法归纳

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”的累加式,此式必须出现在循环中才能被反复执行,从而实现累加功能。

C语言常用算法程序汇总

C语言常用算法程序汇总

C语言常用算法程序汇总C语言是一门广泛应用于计算机编程的语言,具有较高的效率和灵活性。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

通过学习这些算法,可以更好地理解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语言常用算法集
以下是一些常用的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语言常用算法大全

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语言常用算法程序汇总

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语言常用简单算法

C语言常用简单算法C语言是一门功能强大的编程语言,其算法也是很多的。

下面是一些常用的简单算法:1.二分查找算法:二分查找是一种在有序数组中查找特定元素的算法。

它的基本思想是首先在数组的中间位置找到待查找的元素,如果该元素等于目标值,则查找成功;如果该元素大于目标值,说明目标值在数组的前半部分,则在前半部分继续进行查找;如果该元素小于目标值,则说明目标值在数组的后半部分,则在后半部分继续进行查找。

重复以上步骤,直到找到目标值或者确定目标值不存在。

2.冒泡排序算法:冒泡排序是一种简单直观的排序算法。

它的基本思想是通过反复交换相邻的两个元素,将较大的元素逐渐往后移动,从而实现排序的目的。

具体实现时,每一轮比较都会使最大的元素移动到最后。

3.插入排序算法:插入排序是一种简单直观的排序算法。

它的基本思想是将数组分成已排序部分和未排序部分,每次从未排序部分取出一个元素,然后将该元素插入到已排序部分的合适位置,从而实现排序的目的。

4.选择排序算法:选择排序是一种简单直观的排序算法。

它的基本思想是每次选择一个最小(或最大)的元素放到已排序部分的末尾,从而实现排序的目的。

具体实现时,每一轮选择都通过比较找出未排序部分的最小(或最大)元素。

5.快速排序算法:快速排序是一种高效的排序算法。

它的基本思想是通过选取一个基准元素,将数组分成两个子数组,一个子数组中的元素都小于基准元素,另一个子数组中的元素都大于基准元素,然后对这两个子数组分别进行快速排序,最终实现排序的目的。

6.斐波那契数列算法:斐波那契数列是一列数字,其中每个数字都是前两个数字之和。

常见的斐波那契数列算法有递归算法和迭代算法。

递归算法通过反复调用自身来计算斐波那契数列的值,而迭代算法则通过循环来计算。

7.求最大公约数算法:求两个数的最大公约数是一种常见的问题。

常见的求最大公约数的算法有欧几里得算法和辗转相除法。

欧几里得算法通过不断用较小数除以较大数的余数,直到余数为0,得到最大公约数。

C语言常用算法大全

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语言中,有许多常用的算法,可以用来解决各种问题。

下面我们将详细介绍C语言中的六种常用算法。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

C语言的六种常用算法

C语言的六种常用算法

C语言的六种常用算法C语言是一种广泛使用的编程语言,它不仅支持基本的算术运算,还提供了一些常用的高级算法来解决各种问题。

下面将介绍C语言中的六种常用算法。

1.排序算法:排序算法用于按特定的顺序重新排列一组数据。

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

这些算法的时间复杂度和空间复杂度各不相同,可以根据不同的需求选择合适的排序算法。

2.算法:算法用于在一组数据中查找特定的元素。

常见的算法包括线性、二分和哈希。

线性从列表的一端开始逐个比对,直到找到目标元素或完整个列表。

二分是一种高效的算法,它将目标元素与列表的中间元素进行比较,然后根据比较结果将范围缩小一半,重复此过程,直到找到目标元素。

3.图算法:图算法用于解决与图相关的问题,如最短路径问题、最小生成树问题和网络流问题。

常见的图算法包括广度优先(BFS)和深度优先(DFS),它们用于遍历图的节点。

Dijkstra算法用于求解最短路径问题,Prim算法用于求解最小生成树问题。

4.动态规划算法:动态规划算法用于解决最优化问题,将原始问题分解为子问题,并记录子问题的解,以避免重复计算。

常见的动态规划算法包括0/1背包问题、最长公共子序列问题和矩阵链乘法问题。

这些问题都可以通过建立递推关系和使用动态规划表格求解。

5.贪心算法:贪心算法每次取最优解,然后将剩余的子问题交给下一次迭代。

它通常适用于解决一些具有最优子结构的问题。

常见的贪心算法包括霍夫曼编码、最小生成树问题和拟阵问题。

6.分治算法:分治算法将问题分解为若干个规模较小且相互独立的子问题,然后分别解决子问题,最后合并子问题的结果得到原始问题的解。

常见的分治算法包括快速排序、归并排序和大整数乘法。

这些算法利用递归的思想,将问题逐层分解,直到问题规模足够小,可以直接解决。

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

每种算法都有其适用的场景和特点,根据实际需求选择合适的算法可以提高程序的效率和性能。

C语言常用算法

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 语言中,算法是非常重要的部分,因为它们能够帮助我们解决许多实际问题。

本文将介绍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语言常用9种算法

C语言常用9种算法

C语言常用9种算法C语言是一门广泛应用于编程领域的语言,具有丰富的算法库和功能。

在C语言中,有许多常用的算法可以帮助程序员解决各种问题。

本文将介绍C语言中常用的9种算法,以帮助读者深入了解和应用这些算法。

1.顺序算法:顺序算法是一种简单但有效的方法,通过逐个比较目标元素和数组中的元素来寻找指定值。

该算法适用于小规模的数据集,时间复杂度为O(n)。

2.二分算法:二分算法是一种高效的方法,适用于已排序的数组。

该算法通过将目标值与数组的中间元素进行比较,并根据比较结果将范围缩小一半。

时间复杂度为O(log n)。

3.冒泡排序算法:冒泡排序算法是一种简单但低效的排序方法,通过反复交换相邻的元素将较大的元素逐渐移至数组的末尾。

时间复杂度为O(n^2)。

4.选择排序算法:选择排序算法是一种简单但较为高效的排序方法,通过找到最小元素并将其放置在数组的起始位置,逐个选择剩余元素中的最小值,直到完成排序。

时间复杂度为O(n^2)。

5.插入排序算法:插入排序算法是一种简单而且对小数据集很有效的排序方法,通过将未排序的元素依次插入已排序的序列中,逐步构建有序的序列。

时间复杂度为O(n^2)。

6.快速排序算法:快速排序算法是一种高效的排序方法,通过选择一个基准值将数组分割成两个子数组,较小的值放在基准值的左边,较大的值放在右边。

然后对子数组进行递归排序。

时间复杂度为O(n log n)。

7.归并排序算法:归并排序算法是一种稳定而且高效的排序方法,通过将数组递归地分成两个子数组,然后合并这些子数组以得到排序结果。

时间复杂度为O(n log n)。

8.哈希算法:哈希算法是一种用于将数据映射到特定位置的算法,可以快速访问数据。

C语言提供了多种哈希算法库,例如MD5和SHA1等,用于数据完整性校验和密码存储等应用场景。

9.图算法:图算法是一类用于处理图结构的算法,包括广度优先、深度优先和最短路径算法等。

通过这些算法,可以实现许多图相关的问题,如寻找社交网络中的最短路径或者查找网络拓扑结构等。

c语言常见算法

c语言常见算法

c语言常见算法C语言是一种非常流行的编程语言,广泛应用于软件开发和计算机科学领域。

在C语言中,算法是解决问题的关键步骤。

本文将介绍一些常见的C语言算法,包括排序算法、搜索算法和递归算法。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

熟悉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语言中常用的算法分类,以及每个分类中的常用算法。

希望这篇文章能对您学习C语言算法有所帮助。

1.排序算法:排序算法用于将一组数据按照一定的顺序进行排列。

C语言中常用的排序算法有以下几种:-冒泡排序:通过依次比较相邻元素的大小,将较大的元素逐渐向后移动,实现排序。

-插入排序:将未排序的元素一个个插入到已经排序的序列中,使得整个序列有序。

-选择排序:每次从待排序的序列中选择最小(或最大)的元素,放到已排序序列的末尾。

-快速排序:通过一趟排序将待排序的数据分割成独立的两部分,然后再按照该方法对两部分数据分别进行快速排序,递归实现排序。

-归并排序:将待排序的数据递归地分成两部分,分别进行排序,然后将两个有序的子序列合并成一个有序的序列。

2.查找算法:查找算法用于在一组数据中寻找指定的元素。

C语言中常用的查找算法有以下几种:-顺序查找:从序列的起始位置依次遍历,直到找到目标元素。

-二分查找:对于已经排序的序列,通过每次将查找范围减半的方式进行查找,提高查找效率。

-插值查找:对于有序的序列,根据目标元素在序列中的分布情况,通过插值计算来确定查找位置。

3.字符串处理算法:字符串处理算法用于对字符串进行处理和操作。

C语言中常用的字符串处理算法有以下几种:-字符串比较:用于比较两个字符串是否相等。

-字符串拼接:将两个字符串合并成一个字符串。

-字符串查找:在一个字符串中寻找指定的子串。

-字符串替换:将字符串中指定的子串替换为新的子串。

4.图算法:图算法用于研究图结构的相关问题。

C语言中常用的图算法有以下几种:-广度优先:从图的其中一个顶点开始,按广度优先的原则依次访问与该顶点相邻的未访问的顶点。

-深度优先:从图的其中一个顶点开始,按深度优先的原则访问与该顶点相邻的未访问的顶点,直到无法继续访问为止。

- 最短路径算法:用于寻找两个顶点之间最短路径的算法,常见的最短路径算法有Dijkstra算法和Floyd算法。

C语言算法大全

C语言算法大全

C语言经典算法目录一、单元加.................................... 错误!未定义书签。

1.erre ...................................... 错误!未定义书签。

2. erre2 ................................... 错误!未定义书签。

3. 数组完全单元........................ 错误!未定义书签。

4. 栈单元加.............................. 错误!未定义书签。

二、底层编程 ................................ 错误!未定义书签。

1. asm ..................................... 错误!未定义书签。

2. C标志符命名源程序............... 错误!未定义书签。

3. ping .................................... 错误!未定义书签。

4. winsock2 ............................. 错误!未定义书签。

5. 检测鼠标.............................. 错误!未定义书签。

6. 检出错误.............................. 错误!未定义书签。

7. 时间陷阱.............................. 错误!未定义书签。

三、汉诺塔.................................... 错误!未定义书签。

1. 非递归................................. 错误!未定义书签。

2. 汉诺塔................................. 错误!未定义书签。

3. 汉诺塔2 .............................. 错误!未定义书签。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

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);}。

相关文档
最新文档