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语言经典算法大全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语言算法大全

C语言算法大全( C，C++）一、数论算法1．求两数的最大公约数functiongcd(a,b:integer):integer; beginifb=0thengcd:=aelsegcd:=gcd(b,amodb);end;2．求两数的最小公倍数functionlcm(a,b:integer):integer; beginifa<bthenswap(a,b);lcm:=a;whilelcmmodb>0doinc(lcm,a);end;3．素数的求法A.小范围内判断一个数是否为质数：functionprime(n:integer):Boolean;varI:integer;beginforI:=2totrunc(sqrt(n))doifnmodI=0thenbeginprime:=false;exit;end;prime:=true;end;B.判断longint范围内的数是否为素数（包含求50000以内的素数表）：proceduregetprime;vari,j:longint;p:array[1..50000]ofboolean;beginfillchar(p,sizeof(p),true);p[1]:=false;i:=2;whilei<50000dobeginifp[i]thenbeginj:=i*2;whilej<50000dobeginp[j]:=false;inc(j,i);end;end;inc(i);end;l:=0;fori:=1to50000doifp[i]thenbegininc(l);pr[l]:=i;end;end;{getprime}functionprime(x:longint):integer; vari:integer;beginprime:=false;fori:=1toldoifpr[i]>=xthenbreakelseifxmodpr[i]=0thenexit;prime:=true;end;{prime}二、图论算法1．最小生成树A.Prim算法：procedureprim(v0:integer);varlowcost,closest:array[1..maxn] ofinteger;i,j,k,min:integer;beginfori:=1tondobeginlowcost[i]:=cost[v0,i]; closest[i]:=v0;end;fori:=1ton-1dobegin{寻找离生成树最近的未加入顶点k}min:=maxlongint;forj:=1tondoif(lowcost[j]<min)and(lowcost[j]<>0)thenbeginmin:=lowcost[j];k:=j;end;lowcost[k]:=0;{将顶点k加入生成树}{生成树中增加一条新的边k到closest[k]}{修正各点的lowcost和closest值}forj:=1tondoifcost[k,j]<lwocost[j]thenbeginlowcost[j]:=cost[k,j];closest[j]:=k;end;end;end;{prim}B.Kruskal算法：(贪心)按权值递增顺序删去图中的边，若不形成回路则将此边加入最小生成树。

(完整版)非常全的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语言是一种广泛应用于计算机科学领域的编程语言，具有高效、可移植和灵活的特点。

在程序设计中，算法是解决问题的一系列有序步骤，可以通过C语言来实现。

本文将为您总结C语言中常用的算法，包括排序算法、查找算法和图算法。

一、排序算法排序算法是将一组元素按照特定的顺序重新排列的算法。

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

这些算法的核心思想是通过比较和交换元素的位置来进行排序。

1.冒泡排序冒泡排序通过多次比较和交换相邻元素的位置来实现排序。

它的基本思想是将最大的元素不断地往后移动，直到整个序列有序。

2.选择排序选择排序通过每次选择最小的元素来实现排序。

它的基本思想是通过比较找到最小元素的位置，然后将其与第一个元素交换，接着在剩下的元素中继续找到最小元素并进行交换，如此重复直到整个序列有序。

3.插入排序插入排序通过构建有序序列，对未排序序列逐个元素进行插入，从而实现排序。

它的基本思想是将当前元素插入到前面已经排好序的序列中的适当位置。

4.快速排序快速排序是一种分治算法，通过选择一个基准元素，将其他元素划分为小于基准元素和大于基准元素的两部分，然后递归地对这两部分进行排序，最终实现整个序列有序。

5.归并排序归并排序也是一种分治算法，将序列分成两个子序列，分别对这两个子序列进行排序，然后将排序后的子序列合并成一个有序序列，从而达到整个序列有序的目的。

二、查找算法查找算法是在一个数据集合中寻找特定元素的算法。

常见的查找算法包括线性查找、二分查找和散列查找。

这些算法的核心思想是通过比较元素的值来确定待查找元素的位置。

1.线性查找线性查找是从数据集合的开头开始，依次比较每个元素的值，直到找到目标元素为止。

它的时间复杂度为O(n)，其中n为数据集合的大小。

2.二分查找二分查找是针对有序序列进行查找的算法，它的基本思想是通过不断缩小查找范围，将目标元素与中间元素进行比较，从而确定待查找元素的位置。

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语言经典算法大全老掉牙河内塔费式数列巴斯卡三角形三色棋老鼠走迷官（一）老鼠走迷官（二）骑士走棋盘八个皇后八枚银币生命游戏字串核对双色、三色河内塔背包问题（Knapsack Problem）数、运算蒙地卡罗法求 PIEratosthenes筛选求质数超长整数运算（大数运算）长 PI最大公因数、最小公倍数、因式分解完美数阿姆斯壮数最大访客数中序式转后序式（前序式）后序式的运算关于赌博洗扑克牌（乱数排列）Craps赌博游戏约瑟夫问题（Josephus Problem）集合问题排列组合格雷码（Gray Code）产生可能的集合m元素集合的n个元素子集数字拆解排序得分排行选择、插入、气泡排序Shell 排序法 - 改良的插入排序Shaker 排序法 - 改良的气泡排序Heap 排序法 - 改良的选择排序快速排序法（一）快速排序法（二）快速排序法（三）合并排序法基数排序法搜寻循序搜寻法（使用卫兵）二分搜寻法（搜寻原则的代表）插补搜寻法费氏搜寻法矩阵稀疏矩阵多维矩阵转一维矩阵上三角、下三角、对称矩阵奇数魔方阵4N 魔方阵2(2N+1) 魔方阵1.河内之塔说明河内之塔(Towers of Hanoi)是法国人(Lucas)于1883年从泰国带至法国的，河内为越战时北越的首都，即现在的胡志明市；1883年法国数学家 Edouard Lucas曾提及这个故事，据说创世纪时Benares有一座波罗教塔，是由三支钻石棒（Pag）所支撑，开始时神在第一根棒上放置64个由上至下依由小至大排列的金盘（Disc），并命令僧侣将所有的金盘从第一根石棒移至第三根石棒，且搬运过程中遵守大盘子在小盘子之下的原则，若每日仅搬一个盘子，则当盘子全数搬运完毕之时，此塔将毁损，而也就是世界末日来临之时。

解法如果柱子标为ABC，要由A搬至C，在只有一个盘子时，就将它直接搬至C，当有两个盘子，就将B当作辅助柱。

如果盘数超过2个，将第三个以下的盘子遮起来，就很简单了，每次处理两个盘子，也就是：A->B、A ->C、B->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语言经典算法大全老掉牙河内塔费式数列巴斯卡三角形三色棋老鼠走迷官一老鼠走迷官二骑士走棋盘八个皇后八枚银币生命游戏字串核对双色三色河内塔背包问题Knapsack Problem数运算蒙地卡罗法求 PIEratosthenes筛选求质数超长整数运算大数运算长 PI最大公因数最小公倍数因式分解完美数阿姆斯壮数最大访客数中序式转后序式前序式后序式的运算关于赌博洗扑克牌乱数排列Craps赌博游戏约瑟夫问题Josephus Problem 集合问题排列组合格雷码Gray Code产生可能的集合m元素集合的n个元素子集数字拆解排序得分排行选择插入气泡排序Shell 排序法 - 改良的插入排序Shaker 排序法 - 改良的气泡排序Heap 排序法 - 改良的选择排序快速排序法一快速排序法二快速排序法三合并排序法基数排序法搜寻循序搜寻法使用卫兵二分搜寻法搜寻原则的代表插补搜寻法费氏搜寻法矩阵稀疏矩阵多维矩阵转一维矩阵上三角下三角对称矩阵奇数魔方阵4N 魔方阵2 2N1 魔方阵 1河内之塔说明河内之塔 Towers of Hanoi 是法国人MClaus Lucas 于1883年从泰国带至法国的河内为越战时北越的首都即现在的胡志明市1883年法国数学家 Edouard Lucas曾提及这个故事据说创世纪时Benares有一座波罗教塔是由三支钻石棒Pag所支撑开始时神在第一根棒上放置64个由上至下依由小至大排列的金盘Disc并命令僧侣将所有的金盘从第一根石棒移至第三根石棒且搬运过程中遵守大盘子在小盘子之下的原则若每日仅搬一个盘子则当盘子全数搬运完毕之时此塔将毁损而也就是世界末日来临之时解法如果柱子标为ABC要由A搬至C在只有一个盘子时就将它直接搬至C当有两个盘子就将B当作辅助柱如果盘数超过2个将第三个以下的盘子遮起来就很简单了每次处理两个盘子也就是A- BA - CB- C这三个步骤而被遮住的部份其实就是进入程式的递回处理事实上若有n个盘子则移动完毕所需之次数为2n - 1所以当盘数为64时则所需次数为264- 1 1XXXXXXXXXX709551615为505390248594782e16年也就是约5000世纪如果对这数字没什幺概念就假设每秒钟搬一个盘子好了也要约5850亿年左右includevoid hanoi int n char A char B char Cif n 1printf "Move sheet d from c to c\n" n A Celsehanoi n-1 A C Bprintf "Move sheet d from c to c\n" n A Chanoi n-1 B A Cint mainint nprintf "请输入盘数"scanf "d" nhanoi n A B Cfn fn-1 fn-2 if n 1fn n if n 0 1includeinclude define N 20 int main voidint Fib[N] 0int i Fib[0] 0Fib[1] 1 for i 2 i N iFib[i] Fib[i-1] Fib[i-2] for i 0 i N i printf "d " Fib[i]printf "\n"return 03 巴斯卡三角形 includedefine N 12long combi int n int rint ilong p 1for i 1 i r ip p n-i1 ireturn pvoid mainint n r tfor n 0 n N nfor r 0 r n rint i 排版设定开始if r 0for i 0 i N-n i printf " "elseprintf " "排版设定结束printf "3d" combi n rprintf "\n"4Algorithm Gossip 三色棋说明三色旗的问题最早由EWDijkstra所提出Dutch Nation Flag Dijkstra为荷兰人 Three-Color Flag来称之假设有一条绳子上面有红白蓝三种颜色的旗子起初绳子上的旗子颜色并没有顺序您希望将之分类并排列为蓝白红的顺序要如何移动次数才会最少注意您只能在绳子上进行这个动作而且一次只能调换两个旗子解法在一条绳子上移动在程式中也就意味只能使用一个阵列而不使用其它的阵列来作辅助问题的解法很简单您可以自己想像一下在移动旗子从绳子开头进行遇到蓝色往前移遇到白色留在中间遇到红色往后移如下所示只是要让移动次数最少的话就要有些技巧如果图中W所在的位置为白色则W1表示未处理的部份移至至白色群组如果W部份为蓝色则B与W的元素对调而B与W必须各1表示两个群组都多了一个元素如果W所在的位置是红色则将W与R交换但R要减1表示未处理的部份减1 注意BWR并不是三色旗的个数它们只是一个移动的指标什幺时候移动结束呢一开始时未处理的R指标会是等于旗子的总数当R的索引数减至少于W的索引数时表示接下来的旗子就都是红色了此时就可以结束移动如下所示 includeincludeinclude define BLUE bdefine WHITE wdefine RED r define SWAP x y char temp \temp color[x] \color[x] color[y] \color[y] temp int main char color[] r w b w wb r b w r \0 int wFlag 0 int bFlag 0int rFlag strlen color - 1int i for i 0 i strlen color iprintf "c " color[i]printf "\n" while wFlag rFlagif color[wFlag] WHITEwFlagelse if color[wFlag] BLUESWAP bFlag wFlagbFlag wFlagelsewhile wFlag rFlag color[rFlag] REDrFlag--SWAP rFlag wFlagrFlag--for i 0 i strlen color i printf "c " color[i]printf "\n" return 05Algorithm Gossip 老鼠走迷官说明老鼠走迷宫是递回求解的基本题型我们在二维阵列中使用2表示迷宫墙壁使用1来表示老鼠的行走路径试以程式求出由入口至出口的路径解法老鼠的走法有上左下右四个方向在每前进一格之后就选一个方向前进无法前进时退回选择下一个可前进方向如此在阵列中依序测试四个方向直到走到出口为止这是递回的基本题请直接看程式应就可以理解includeinclude int visit int int int maze[7][7] 2 2 2 22 2 22 0 0 0 0 0 22 0 2 0 2 0 22 0 0 2 0 2 22 2 0 2 0 2 22 0 0 0 0 0 22 2 2 2 2 2 2 int startI 1 startJ 1 入口int endI 5 endJ 5 出口int success 0 int main voidint i j printf "显示迷宫\n"for i 0 i 7 ifor j 0 j 7 jif maze[i][j] 2printf "█"elseprintf " "printf "\n"if visit startI startJ 0 printf "\n没有找到出口\n"elseprintf "\n\n"for i 0 i 7 ifor j 0 j 7 jif maze[i][j] 2printf "█"else if maze[i][j] 1 printf "◇"elseprintf " "printf "\n"return 0int visit int i int jmaze[i][j] 1 if i endI j endJsuccess 1 if success 1 maze[i][j1]0 visit i j1if success 1 maze[i1][j] 0 visit i1 jif success 1 maze[i][j-1] 0 visit i j-1if success 1 maze[i-1][j] 0 visit i-1 j if success 1maze[i][j] 0 return success6Algorithm Gossip 老鼠走迷官说明由于迷宫的设计老鼠走迷宫的入口至出口路径可能不只一条如何求出所有的路径呢解法求所有路径看起来复杂但其实更简单只要在老鼠走至出口时显示经过的路径然后退回上一格重新选择下一个位置继续递回就可以了比求出单一路径还简单我们的程式只要作一点修改就可以了includeinclude void visit int int int maze[9][9] 2 2 2 22 2 2 2 22 0 0 0 0 0 0 0 22 0 2 2 0 2 2 0 22 0 2 0 0 2 0 0 22 0 2 0 2 0 2 0 22 0 0 0 0 0 2 0 22 2 0 2 2 0 2 2 22 0 0 0 0 0 0 0 22 2 2 2 2 2 2 2 2 int startI 1 startJ 1 入口int endI 7 endJ 7 出口 int main voidint i j printf "显示迷宫\n"for i 0 i 7 ifor j 0 j 7 jif maze[i][j] 2printf "█"elseprintf " "printf "\n"visit startI startJ return 0void visit int i int jint m n maze[i][j] 1 if i endI j endJprintf "\n显示路径\n"for m 0 m 9 mfor n 0 n 9 nif maze[m][n] 2printf "█"else if maze[m][n] 1printf "◇"elseprintf " "printf "\n"if maze[i][j1] 0 visit i j1if maze[i1][j] 0 visit i1 jif maze[i][j-1] 0 visit i j-1if maze[i-1][j] 0 visit i-1 j maze[i][j] 07Algorithm Gossip 骑士走棋盘说明骑士旅游Knight tour[所有的位置include int board[8][8] 0 int main voidint startx startyint i jprintf "输入起始点"scanf "d d" startx starty if travel startx starty printf "\n"elseprintf "\n"for i 0 i 8 ifor j 0 j 8 jprintf "2d " board[i][j]putchar \nreturn 0int travel int x int yint ktmove1[8] -2 -1 1 2 2 1 -1 -2int ktmove2[8] 1 2 2 1 -1 -2 -2 -1 测试下一步的出路int nexti[8] 0int nextj[8] 0记录出路的个数int exists[8] 0int i j k m lint tmpi tmpjint count min tmp i xj yboard[i][j] 1 for m 2 m 64 mfor l 0 l 8 lexists[l] 0 l 0 试探八个方向for k 0 k 8 ktmpi i ktmove1[k]tmpj j ktmove2[k] 如果是边界了if tmpi 0 tmpj 0 tmpi 7 tmpj 7 continue 如果这个方向可走 if board[tmpi][tmpj] 0nexti[l] tmpinextj[l] tmpj可走的方向加一个lcount l如果可走的方向为0个if count 0return 0else if count 1只有一个可走的方向所以直接是最少出路的方向min 0else找出下一个位置的出路数for l 0 l count lfor k 0 k 8 ktmpi nexti[l] ktmove1[k] tmpj nextj[l] ktmove2[k] if tmpi 0 tmpj 0tmpi 7 tmpj 7continueif board[tmpi][tmpj] 0 exists[l]tmp exists[0]min 0从可走的方向中寻找最少出路的方向 for l 1 l count lif exists[l] tmptmp exists[l]min l走最少出路的方向i nexti[min]j nextj[min]board[i][j] mreturn 18Algorithm Gossip 八皇后说明西洋棋中的皇后可以直线前进吃掉遇到的所有棋子如果棋盘上有八个皇后则这八个皇后如何相安无事的放置在棋盘上1970年与1971年 EWDijkstra与NWirth曾经用这个问题来讲解程式设计之技巧解法关于棋盘的问题都可以用递回求解然而如何减少递回的次数在八个皇后的问题中不必要所有的格子都检查过例如若某列检查过该该列的其它格子就不用再检查了这个方法称为分支修剪includeincludedefine N 8 int column[N1] 同栏是否有皇后1int rup[2N1] 右上至左下是否有皇后int lup[2N1] 左上至右下是否有皇后int queen[N1] 0int num 解答编号 void backtrack int 递回求解 intmain voidint inum 0 for i 1 i N icolumn[i] 1 for i 1 i 2N irup[i] lup[i] 1 backtrack 1 return 0void showAnswerint x yprintf "\n解答 d\n" numfor y 1 y N yfor x 1 x N xif queen[y] xprintf " Q"elseprintf " "printf "\n"void backtrack int iint j if i NshowAnswerelsefor j 1 j N jif column[j] 1rup[ij] 1 lup[i-jN] 1 queen[i] j设定为占用column[j] rup[ij] lup[i-jN] 0 backtrack i1column[j] rup[ij] lup[i-jN] 19Algorithm Gossip 八枚银币说明现有八枚银币a b c d e f g h已知其中一枚是假币其重量不同于真币但不知是较轻或较重如何使用天平以最少的比较次数决定出哪枚是假币并得知假币比真币较轻或较重解法单就求假币的问题是不难但问题限制使用最少的比较次数所以我们不能以单纯的回圈比较来求解我们可以使用决策树decision tree使用分析与树状图来协助求解一个简单的状况是这样的我们比较abc与def 如果相等则假币必是g或h我们先比较g或h哪个较重如果g较重再与a比较a是真币如果g等于a则g为真币则h为假币由于h比g轻而 g是真币则h假币的重量比真币轻 include includeinclude void compare int[] int int intvoid eightcoins int[] int main voidint coins[8] 0int i srand time NULL for i 0 i 8 icoins[i] 10 printf "\n输入假币重量比10大或小 "scanf "d" icoins[rand 8] i eightcoins coins printf "\n\n"for i 0 i 8 iprintf "d " coins[i] printf "\n"return 0void compare int coins[] int i int j int kif coins[i] coins[k]printf "\n d 较重" i1elseprintf "\n假币 d 较轻" j1void eightcoins int coins[]if coins[0]coins[1]coins[2]coins[3]coins[4]coins[5]if coins[6] coins[7]compare coins 6 7 0elsecompare coins 7 6 0else if coins[0]coins[1]coins[2]coins[3]coins[4]coins[5]if coins[0]coins[3] coins[1]coins[4]compare coins 2 5 0else if coins[0]coins[3] coins[1]coins[4] compare coins 0 4 1if coins[0]coins[3] coins[1]coins[4]compare coins 1 3 0else if coins[0]coins[1]coins[2]coins[3]coins[4]coins[5]if coins[0]coins[3] coins[1]coins[4]compare coins 5 2 0else if coins[0]coins[3] coins[1]coins[4] compare coins 3 1 0if coins[0]coins[3] coins[1]coins[4]compare coins 4 0 110Algorithm Gossip 生命游戏说明生命游戏game of life1970年由英国数学家J H Conway所提出includeincludeinclude define ROW 10define COL 25define DEAD 0define ALIVE 1int map[ROW][COL] newmap[ROW][COL] void initint neighbors int intvoid outputMapvoid copyMap int mainint row colchar ansinitwhile 1outputMapfor row 0 row ROW rowfor col 0 col COL colswitch neighbors row colcase 0case 1case 4case 5case 6case 7case 8newmap[row][col] DEADbreakcase 2newmap[row][col] map[row][col] breakcase 3newmap[row][col] ALIVEbreakcopyMapprintf "\nContinue next Generation "getcharans toupper getcharif ans Y breakreturn 0void initint row col for row 0 row ROW rowfor col 0 col COL colmap[row][col] DEAD puts "Game of life Program"puts "Enter x y where x y is living cell"printf "0 x d 0 y d\n"ROW-1 COL-1puts "Terminate with x y -1 -1" while 1scanf "d d" row colif 0 row row ROW0 col col COLmap[row][col] ALIVEelse if row -1 col -1breakelseprintf " x y exceeds map ranage"int neighbors int row int colint count 0 c rfor r row-1 r row1 rfor c col-1 c col1 cif r 0 r ROW c 0 c COL continueif map[r][c] ALIVEcountif map[row][col] ALIVEcount--return countvoid outputMapint row colprintf "\n\n20cGame of life cell status\n" for row 0 row ROW rowprintf "\n20c"for col 0 col COL colif map[row][col] ALIVE putchar else putchar -void copyMapint row colfor row 0 row ROW rowfor col 0 col COL colmap[row][col] newmap[row][col]11Algorithm Gossip 字串核对说明今日的一些高阶程式语言对于字串的处理支援越来越强大例如JavaPerl等不过字串搜寻本身仍是个值得探讨的课题在这边以Boyer- Moore法来说明如何进行字串说明这个方法快且原理简洁易懂解法字串搜寻本身不难使用暴力法也可以求解但如何快速搜寻字串就不简单了传统的字串搜寻是从关键字与字串的开头开始比对例如 Knuth-Morris-Pratt 演算法字串搜寻这个方法也不错不过要花时间在公式计算上Boyer-Moore字串核对改由关键字的后面开始核对字串并制作前进表如果比对不符合则依前进表中的值前进至下一个核对处假设是p好了然后比对字串中p-n1至p的值是否与关键字相同如果关键字中有重复出现的字元则前进值就会有两个以上的值此时则取前进值较小的值如此就不会跳过可能的位置例如texture 这个关键字t的前进值应该取后面的3而不是取前面的7 includeincludeinclude void table char 建立前进表int search int char char 搜寻关键字void substring char char int int 取出子字串int skip[256] int main voidchar str_input[80]char str_key[80]char tmp[80] \0int m n pprintf "请输入字串"gets str_inputprintf ""gets str_keym strlen str_inputn strlen str_keytable str_keyp search n-1 str_input str_key while p -1 substring str_input tmp p mprintf "s\n" tmpp search pn1 str_input str_keyprintf "\n"return 0void table char keyint k nn strlen keyfor k 0 k 255 kskip[k] nfor k 0 k n - 1 kskip[key[k]] n - k - 1int search int p char input char keyint i m nchar tmp[80] \0m strlen inputn strlen key while p msubstring input tmp p-n1 pif strcmp tmp key 比较两字串是否相同return p-n1p skip[input[p]]return -1void substring char text char tmp int s int e int i jfor i s j 0 i e i jmp[j] text[i]tmp[j] \012Algorithm Gossip 双色三色河内塔说明双色河内塔与三色河内塔是由之前所介绍过的河内塔规则衍生而来双色河内塔的目的是将下图左上的圆环位置经移动成为右下的圆环位置而三色河内塔则是将下图左上的圆环经移动成为右上的圆环解法无论是双色河内塔或是三色河内塔其解法观念与之前介绍过的河内塔是类似的同样也是使用递回来解不过这次递回解法的目的不同我们先来看只有两个盘的情况这很简单只要将第一柱的黄色移动至第二柱而接下来第一柱的蓝色移动至第三柱再来是四个盘的情况首先必须用递回完成下图左上至右下的移动接下来最底层的就不用管它们了因为它们已经就定位只要再处理第一柱的上面两个盘子就可以了那么六个盘的情况呢一样首先必须用递回完成下图左上至右下的移动接下来最底层的就不用管它们了因为它们已经就定位只要再处理第一柱上面的四个盘子就可以了这又与之前只有四盘的情况相同接下来您就知道该如何进行解题了无论是八个盘十个盘以上等都是用这个观念来解题那么三色河内塔呢一样直接来看九个盘的情况首先必须完成下图的移动结果接下来最底两层的就不用管它们了因为它们已经就定位只要再处理第一柱上面的三个盘子就可以了双色河内塔 C 实作include void hanoi int disks char source char temp char targetif disks 1printf "move disk from c to c\n" source targetprintf "move disk from c to c\n" source target elsehanoi disks-1 source target temphanoi 1 source temp targethanoi disks-1 temp source targetvoid hanoi2colors int diskschar source Achar temp Bchar target Cint ifor i disks 2 i 1 i--hanoi i-1 source temp targetprintf "move disk from c to c\n" source temp printf "move disk from c to c\n" source temp hanoi i-1 target temp sourceprintf "move disk from c to c\n" temp targetprintf "move disk from c to c\n" source tempprintf "move disk from c to c\n" source targetint mainint nprintf "请输入盘数"scanf "d" n hanoi2colors n return 0C 实作include void hanoi int disks char source char temp char targetif disks 1printf "move disk from c to c\n" source target printf "move disk from c to c\n" source target printf "move disk from c to c\n" source target elsehanoi disks-1 source target temphanoi 1 source temp targethanoi disks-1 temp source targetvoid hanoi3colors int diskschar source Achar temp Bchar target Cint iif disks 3printf "move disk from c to c\n" source tempprintf "move disk from c to c\n" source tempprintf "move disk from c to c\n" source targetprintf "move disk from c to c\n" temp targetprintf "move disk from c to c\n" temp sourceprintf "move disk from c to c\n" target tempelsehanoi disks3-1 source temp targetprintf "move disk from c to c\n" source tempprintf "move disk from c to c\n" source tempprintf "move disk from c to c\n" source temp hanoi disks3-1 target temp sourceprintf "move disk from c to c\n" temp targetprintf "move disk from c to c\n" temp targetprintf "move disk from c to c\n" temp target hanoi disks3-1 source target tempprintf "move disk from c to c\n" target sourceprintf "move disk from c to c\n" target source hanoi disks3-1 temp source targetprintf "move disk from c to c\n" source temp for i disks 3 - 1 i 0 i--if i 1hanoi i-1 target source tempprintf "move disk from c to c\n"target source printf "move disk from c to c\n"target source if i 1hanoi i-1 temp source targetprintf "move disk from c to c\n" source tempint mainint nprintf "请输入盘数"scanf "d" n hanoi3colors nreturn 013Algorithm Gossip 背包问题Knapsack Problem说明假设有一个背包的负重最多可达8公斤而希望在背包中装入负重范围内可得之总价物品假设是水果好了水果的编号单价与重量如下所示0 李子 4KG NT4500 1 苹果 5KG NT57002 橘子 2KG NT22503 草莓 1KG NT1100 4甜瓜 6KG NT6700解法背包问题是关于最佳化的问题要解最佳化问题可以使用「动态规划」Dynamic programming从空集合开始每增加一个元素就先求出该阶段的最佳解直到所有的元素加入至集合中最后得到的就是最佳解以背包问题为例我们使用两个阵列value与itemvalue表示目前的最佳解所得之总价item表示最后一个放至背包的水果假设有负重量 1～8的背包8个并对每个背包求其最佳解逐步将水果放入背包中并求该阶段的最佳解放入李子背包负重 1 2 3 4 5 6 7 8 value ０００4500 4500 4500 4500 9000 item －－－０００００放入苹果背包负重 1 2 3 4 5 6 7 8 value ０００4500 5700 5700 5700 9000 item －－－０ 1 1 1 ０放入橘子背包负重 1 2 3 4 5 6 7 8 value ０2250 2250 4500 5700 6750 7950 9000 item －2 2 ０ 1 2 2 ０放入草莓背包负重 1 2 3 4 5 6 7 8 value 11002250 3350 4500 5700 6800 7950 9050 item 3 23 ０ 1 3 2 3放入甜瓜背包负重 1 2 3 4 5 6 7 8 value 11002250 3350 4500 5700 6800 7950 9050 item 3 23 ０ 1 3 2 3由最后一个表格可以得知在背包负重8公斤时最多可以装入9050元的水果而最后一个装入的水果是3号也就是草莓装入了草莓背包只能再放入7公斤8-1的水果所以必须看背包负重7公斤时的最佳解最后一个放入的是2号也就是橘子现在背包剩下负重量5公斤7-2所以看负重5公斤的最佳解最后放入的是1号也就是苹果此时背包负重量剩下0公斤5-5无法再放入水果所以求出最佳解为放入草莓橘子与苹果而总价为9050元实作 Cincludeinclude define LIMIT 8 重量限制define N 5 物品种类define MIN 1 最小重量 struct bodychar name[20]int sizeint pricetypedef struct body object int main voidint item[LIMIT1] 0int value[LIMIT1] 0int newvalue i s p object a[] "李子" 4 4500 "苹果" 5 5700"橘子" 2 2250"草莓" 1 1100"甜瓜" 6 6700 for i 0 i N i for s a[i]size s LIMIT sp s - a[i]sizenewvalue value[p] a[i]priceif newvalue value[s] 找到阶段最佳解value[s] newvalueitem[s] iprintf "物品\t价格\n"for i LIMIT i MIN i i - a[item[i]]sizeprintf "s\td\n"a[item[i]]name a[item[i]]priceprintf "合计\td\n" value[LIMIT] returnJavaclass Fruitprivate String nameprivate int sizeprivate int price public Fruit String name int size int pricethisname namethissize sizethisprice pricepublic String getNamereturn namepublic int getPricereturn pricepublic int getSizereturn sizepublic class Knapsackpublic static void main String[] argsfinal int 8final int MIN 1int[] item new int[1]int[] value new int[1] Fruit fruits[]new Fruit "李子" 4 4500new Fruit "苹果" 5 5700new Fruit "橘子" 2 2250new Fruit "草莓" 1 1100new Fruit "甜瓜" 6 6700 fo。

C语言超算法大全

C语言超算法大全1.快速排序算法：快速排序是一种高效的排序算法，基于分治法的思想。

它通过选择一个基准元素，将数组划分为两个子数组，其中一个子数组的所有元素小于基准元素，另一个子数组的所有元素大于基准元素。

然后递归地对两个子数组进行快速排序，最终得到排序后的数组。

2.归并排序算法：归并排序也是一种高效的排序算法，基于分治法的思想。

它将数组分为两个子数组，然后递归地对每个子数组进行归并排序，最后将两个有序的子数组合并成一个有序的数组。

3.堆排序算法：堆排序是一种树形选择排序算法，利用堆数据结构来实现。

它通过构建一个最大堆，将堆顶元素与最后一个元素交换，然后重新调整堆，重复这个过程，最终得到排序后的数组。

4.二分查找算法：二分查找算法是一种在有序数组中查找特定元素的算法。

它通过将待查找区间的中间元素与目标元素进行比较，根据比较结果调整区间范围，直到找到目标元素或区间为空。

5.图的深度优先算法：图的深度优先算法是一种用于遍历图的算法。

它从一个顶点开始，递归地访问所有与该顶点相连的未访问过的顶点，直到所有顶点都被访问过为止。

6.图的广度优先算法：图的广度优先算法也是一种用于遍历图的算法。

它从一个顶点开始，依次访问与该顶点相邻的顶点，并将这些相邻顶点加入到一个队列中，然后继续对队列中的顶点进行同样的操作，直到队列为空为止。

7.迪杰斯特拉算法：迪杰斯特拉算法是一种用于求解单源最短路径问题的算法。

它通过动态规划的方式，逐步更新起始顶点到其他顶点的最短路径长度。

8.动态规划算法：动态规划算法是一种用于解决多阶段决策问题的算法。

它通过将原问题划分为若干个子问题，并记忆已经解决的子问题的结果，从而避免重复计算，提高计算效率。

9.最小生成树算法：最小生成树算法是一种用于求解连通图的最小成本生成树的算法。

它通过选择具有最小权值的边来构建最小生成树，直到所有顶点都被包含在生成树中。

10.拓扑排序算法：拓扑排序算法是一种用于对有向无环图进行排序的算法。

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

一、 .累加累乘基本知识：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语言经典算法大全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语言典型算法汇总1. 大小写字母的转换c=c-32 小写字母变成大写字母2. 润年的判断year%4==0 && year%100!=0 || year%400==0.3. 累加及其引伸sum=sum+i4. 累积及其引伸s=s*i;5. 打印图案For(i=0;i<n;i++)< p="">{for(j=0;j<n-1-i;j++)< p="">printf(“ “); 4 4 4 4 4 4 4 3 3 3 3 3 2 2 2 1 2 2 2 3 3 3 3 3 4 4 4 4 4 4 4 X X x x X x x x x X x x x x x x X x x x x X x x xFor(k=1;k<=50;k++) ∑=5012k k S=s+k*k; S=0,t=1 ∑=201!n n For(n=1;n<=20;n++) { t=t*n; s=s+t; } 2/1,3/2,5/3,8/5,13/8,21/13,……前20项之和. Main() { int n,t,number=20; Float a=2,b=1,s=0; For(n=1;n<=number;n++) { s=s+b; t=a;a=a+b;b=t;} printf(“sum=%9.6\n ”,s);}for(k=0;k<2*i+1;k++)printf(“*”);printf(“\n”);}for(i=0;i<n-1;i++)< p="">{for(j=0;j<=i;j++)printf(““);for(k=0;k<2*(n-1)-2*i-1;k++)printf(“*”);printf(“\n”);}6.一个四位数的各位拆分及运算问题任意输入一个四位数x，求出千位数与十位数之和，求出个位数与百位数之和，并判断这两个数的和是奇数还是偶数。

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];。

c语言常见算法

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

熟悉C语言中的常见算法，可以帮助程序员更好地解决问题，提高代码的效率与质量。

c语言十大算法案例

c语言十大算法案例C语言是一种广泛应用于编程的高级语言，具有简单、灵活、高效等特点。

在C语言中，有许多经典的算法案例，这些算法案例不仅有助于提高编程能力，还能帮助我们理解计算机科学的基本原理。

下面列举了十个C语言的经典算法案例。

1. 冒泡排序算法：冒泡排序是一种简单但效率较低的排序算法，它通过多次比较和交换相邻元素的方式将最大或最小的元素逐步移动到数组的一端。

2. 快速排序算法：快速排序是一种常用的排序算法，它通过选择一个基准元素，将数组分成两个子数组，然后对子数组进行递归排序。

3. 二分查找算法：二分查找是一种高效的查找算法，它通过将查找范围缩小一半来快速定位目标元素。

4. 链表反转算法：链表反转是一种常见的操作，它可以将链表中的节点顺序逆转。

5. 汉诺塔算法：汉诺塔是一种经典的递归问题，它通过将圆盘从一个柱子移动到另一个柱子来演示递归的思想。

6. 最大公约数算法：最大公约数是指能够同时被两个或多个整数整除的最大正整数，求最大公约数的算法有多种，如辗转相除法和欧几里德算法。

7. 斐波那契数列算法：斐波那契数列是一个数列，其中每个数字都是前两个数字之和，求斐波那契数列的算法有多种，如递归和循环。

8. 图的深度优先搜索算法：深度优先搜索是一种用于遍历图的算法，它通过递归的方式依次访问图中的每个节点。

9. 图的广度优先搜索算法：广度优先搜索也是一种用于遍历图的算法，它通过队列的方式依次访问图中的每个节点。

10. 最短路径算法：最短路径算法用于找到图中两个节点之间的最短路径，常用的最短路径算法有迪杰斯特拉算法和弗洛伊德算法。

这些算法案例涵盖了排序、查找、链表操作、递归、图算法等多个方面，是C语言学习中不可或缺的部分。

通过学习和理解这些经典算法案例，我们可以提高自己的编程能力，并在解决实际问题时能够选择合适的算法。

希望本文能够对读者有所帮助，激发他们对C 语言算法的兴趣，并在编程的道路上不断进步。

C语言常用算法范文

C语言常用算法范文一、排序算法1.冒泡排序：重复比较相邻的元素，如果反序则交换，直到没有反序元素。

2.选择排序：每次从未排序的部分中选择最小（大）的元素，放到已排序部分的末尾。

3.插入排序：将未排序部分的第一个元素插入到已排序部分的适当位置，使得已排序部分仍然有序。

4.快速排序：通过选取一个基准元素，将元素分为小于和大于基准值的两部分，然后对两部分分别递归地进行排序。

5.归并排序：将一个待排序的序列递归地划分为两个子序列，分别对子序列进行排序，然后合并两个有序子序列。

6.堆排序：构建一个大（小）顶堆，每次将堆顶元素与最后一个元素交换，并重新调整堆。

7.基数排序：按照低位到高位的顺序，对每一位进行排序，最终得到有序序列。

二、查找算法1.顺序查找：从头到尾依次遍历元素，直到找到目标元素或遍历结束。

2.二分查找：在有序序列中，找到中间元素，如果与目标元素相等则返回，否则根据中间元素大小调整查找范围，重复执行查找操作。

3.插值查找：对于均匀分布的有序序列，按照目标元素在序列中的位置进行估计，从而减少查找次数。

4.哈希查找：通过哈希函数将关键字映射到哈希表中的位置，根据哈希表中的位置来查找目标元素。

三、字符串匹配算法1.朴素字符串匹配：从主串的每个位置开始，逐个字符比较，如果匹配失败则移动到下一个位置。

2. KMP算法：通过预处理模式串构建一个next数组，根据next数组的值调整比较位置，从而减少比较次数。

3. Boyer-Moore算法：从主串的末尾向前逐个字符比较，根据坏字符规则和好后缀规则进行位置调整。

4. Sunday算法：根据主串中当前与模式串不匹配的字符，在模式串中寻找下一个可能的匹配位置，进行跳跃。

四、递归算法1.阶乘：通过递归地调用自身来计算一个数的阶乘。

2.斐波那契数列：通过递归地调用自身来计算斐波那契数列中的第n个数。

3.汉诺塔：将n个盘子从一个柱子移动到另一个柱子，保持盘子的顺序不变。

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．求两数的最大公约数function gcd(a,b:integer):intege r; beginif b=0 then gcd:=aelse gcd:=gcd (b,a mod b); end ;2．求两数的最小公倍数function lcm(a,b:intege r):integer; beginif a<b then sw ap(a,b);lcm:=a;w hile lcm mod b>0 do inc(lcm,a); end;3．素数的求法A.小范围内判断一个数是否为质数：function prime (n: intege r): Boolean; v ar I: integer;beginfor I:=2 to trunc(sqrt(n)) doif n mod I=0 then beginprime:=false; exit;end;prime:=true;end;B.判断longint范围内的数是否为素数（包含求50000以内的素数表）：procedure getprime;v ari,j:longint;p:array[1..50000] of boolean;beginfillchar(p,sizeof(p),true);p[1]:=false;i:=2;w hile i<50000 do beginif p[i] then beginj:=i*2;w hile j<50000 do beginp[j]:=false;inc(j,i);end;end;inc(i);end;l:=0;for i:=1 to 50000 doif p[i] then begininc(l);pr[l]:=i;end;end;{getprime}function prime(x:longint):integer;v ar i:integer;beginprime:=false;for i:=1 to l doif pr[i]>=x the n breakelse if x mod pr[i]=0 then exit;prime:=true;end;{prime}二、图论算法1．最小生成树A.Prim算法：procedure prim(v0:integer);v arlow cost,closest:array[1..maxn] of integer; i,j,k,min:integer;beginfor i:=1 to n do beginlow cost[i]:=cost[v0,i];closest[i]:=v0;end;for i:=1 to n-1 do begin{寻找离生成树最近的未加入顶点k}min:=maxlongint;for j:=1 to n doif (low cost[j]<min) and (low cost[j]<>0) then beginmin:=low cost[j];k:=j;end;low cost[k]:=0; {将顶点k加入生成树}{生成树中增加一条新的边k到closest[k]}{修正各点的low cost和clo sest值}for j:=1 to n doif cost[k,j]<lw ocost[j] then beginlow cost[j]:=cost[k,j];closest[j]:=k;end;end;end;{prim}B.Kruskal算法：(贪心)按权值递增顺序删去图中的边，若不形成回路则将此边加入最小生成树。

a. 顶点事件最早发生时间V e[j], V e [j] = max{ V e [j] + w[I,j] },其中V e (1) = 0;b. 顶点事件最晚发生时间V l[j], V l [j] = min{ V l[j] –w[I,j] },其中V l(n) = V e(n);c. 边活动最早开始时间Ee[I], 若边I由<j,k>表示，则Ee[I] = V e[j];d. 边活动最晚开始时间El[I], 若边I由<j,k>表示，则El[I] = V l[k] –w[j,k];若Ee[j] = El[j] ，则活动j为关键活动，由关键活动组成的路径为关键路径。

求解方法：a. 从源点起topsort,判断是否有回路并计算V e;b. 从汇点起topsort,求V l;c. 算Ee 和El;6．拓扑排序找入度为0的点，删去与其相连的所有边，不断重复这一过程。

例寻找一数列，其中任意连续p项之和为正，任意q 项之和为负，若不存在则输出NO.7.回路问题Euler回路(DF S)定义：经过图的每条边仅一次的回路。

（充要条件：图连同且无奇点）Hamilton回路定义：经过图的每个顶点仅一次的回路。

一笔画充要条件：图连通且奇点个数为0个或2个。