下载文档原格式
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语言经典算法大全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.快速排序算法快速排序是一种高效的排序算法，它通过选择一个主元，将列表分割为两个子列表，其中一个子列表的所有元素都小于主元，另一个子列表的所有元素都大于主元。
以下是使用PHP 实现的9个经典的排序算法：1. 冒泡排序```function bubble_sort($arr) {$n = count($arr);if ($n <= 1) {return $arr;}for ($i = 0; $i < $n; $i++) {for ($j = 0; $j < $n - $i - 1; $j++) {if ($arr[$j] > $arr[$j+1]) {$temp = $arr[$j+1];$arr[$j+1] = $arr[$j];$arr[$j] = $temp;}}}return $arr;}```2. 选择排序```function selection_sort($arr) {$n = count($arr);if ($n <= 1) {return $arr;}for ($i = 0; $i < $n; $i++) {$minIndex = $i;for ($j = $i+1; $j < $n; $j++) {if ($arr[$j] < $arr[$minIndex]) {$minIndex = $j;}}$temp = $arr[$i];$arr[$i] = $arr[$minIndex];$arr[$minIndex] = $temp;}return $arr;}```3. 插入排序```function insertion_sort($arr) {$n = count($arr);if ($n <= 1) {return $arr;}for ($i = 1; $i < $n; $i++) {$value = $arr[$i];$j = $i - 1;for (; $j >= 0; $j--) {if ($arr[$j] > $value) {$arr[$j+1] = $arr[$j];} else {break;}}$arr[$j+1] = $value;}return $arr;}```4. 快速排序```function quick_sort($arr) {$n = count($arr);if ($n <= 1) {return $arr;}$pivotIndex = floor($n/2);$pivot = $arr[$pivotIndex];$left = array();$right = array();for ($i = 0; $i < $n; $i++) {if ($i == $pivotIndex) {continue;} else if ($arr[$i] < $pivot) {$left[] = $arr[$i];} else {$right[] = $arr[$i];}}return array_merge(quick_sort($left), array($pivot), quick_sort($right));}```5. 归并排序```function merge_sort($arr) {$n = count($arr);if ($n <= 1) {return $arr;}$mid = floor($n/2);$left = array_slice($arr, 0, $mid);$right = array_slice($arr, $mid);$left = merge_sort($left);$right = merge_sort($right);$newArr = array();while (count($left) && count($right)) {$newArr[] = $left[0] < $right[0] ? array_shift($left) : array_shift($right);}return array_merge($newArr, $left, $right);}```6. 堆排序```function heap_sort(&$arr) {$n = count($arr);if ($n <= 1) {return;}build_heap($arr);for ($i = $n-1; $i > 0; $i--) {$temp = $arr[0];$arr[0] = $arr[$i];$arr[$i] = $temp;heapify($arr, 0, $i);}}function build_heap(&$arr) {$n = count($arr);for ($i = floor($n/2)-1; $i >= 0; $i--) {heapify($arr, $i, $n);}}function heapify(&$arr, $i, $n) {$left = 2*$i+1;$right = 2*$i+2;$largest = $i;if ($left < $n && $arr[$left] > $arr[$largest]) {$largest = $left;}if ($right < $n && $arr[$right] > $arr[$largest]) {$largest = $right;}if ($largest != $i) {$temp = $arr[$i];$arr[$i] = $arr[$largest];$arr[$largest] = $temp;heapify($arr, $largest, $n);}}```7. 希尔排序```function shell_sort($arr) {$n = count($arr);if ($n <= 1) {return $arr;}$gap = floor($n/2);while ($gap > 0) {for ($i = $gap; $i < $n; $i++) {$temp = $arr[$i];for ($j = $i-$gap; $j >= 0 && $arr[$j] > $temp; $j -= $gap) {$arr[$j+$gap] = $arr[$j];}$arr[$j+$gap] = $temp;}$gap = floor($gap/2);}return $arr;}```8. 计数排序```function counting_sort($arr) {$n = count($arr);if ($n <= 1) {return $arr;}$maxVal = max($arr);$countArr = array_fill(0, $maxVal+1, 0);for ($i = 0; $i < $n; $i++) {$countArr[$arr[$i]]++;}for ($i = 1; $i < $maxVal+1; $i++) {$countArr[$i] += $countArr[$i-1];}$tmpArr = array();for ($i = $n-1; $i >= 0; $i--) {$tmpArr[$countArr[$arr[$i]]-1] = $arr[$i];$countArr[$arr[$i]]--;}for ($i = 0; $i < $n; $i++) {$arr[$i] = $tmpArr[$i];}return $arr;}```9. 桶排序```function bucket_sort($arr) {$n = count($arr);if ($n <= 1) {return $arr;}$maxVal = max($arr);$bucketSize = 10;$bucketCount = floor($maxVal / $bucketSize) + 1;$buckets = array();for ($i = 0; $i < $bucketCount; $i++) {$buckets[$i] = array();}for ($i = 0; $i < $n; $i++) {$index = floor($arr[$i] / $bucketSize);array_push($buckets[$index], $arr[$i]);}$newArr = array();for ($i = 0; $i < $bucketCount; $i++) {$bucketArr = $buckets[$i];$len = count($bucketArr);if ($len > 1) {sort($bucketArr);}for ($j = 0; $j < $len; $j++) {array_push($newArr, $bucketArr[$j]);}}return $newArr;}```以上就是使用PHP 实现的9个经典的排序算法。
算法学习中的经典算法实现与应用案例在计算机科学领域中，算法是解决问题的一种方法或步骤的描述。
它是一种确定性的、有限的、有效的计算过程，可以将输入转换为输出。
算法学习是计算机科学的基础，它涉及到各种经典算法的实现和应用。
一、排序算法排序算法是算法学习中最基础也是最常用的一类算法。
它们的目标是将一组元素按照特定的顺序进行排列。
其中，冒泡排序是最简单的一种排序算法，它的基本思想是通过相邻元素的比较和交换来实现排序。
另一个经典的排序算法是快速排序，它基于分治法的思想，通过选择一个基准元素将数组划分为两个子数组，然后递归地对子数组进行排序。
这些排序算法在实际应用中有着广泛的应用。
例如，在搜索引擎中，对搜索结果进行排序可以提高用户的搜索体验。
在电商平台中，对商品进行排序可以帮助用户更快地找到自己想要的产品。
此外，在数据分析和机器学习领域，排序算法也扮演着重要的角色。
二、图算法图算法是解决图论问题的一类算法。
图是由节点和边组成的数据结构，它可以用来表示各种关系和网络。
图算法的应用非常广泛，例如最短路径算法可以用来计算两个节点之间的最短路径，广度优先搜索算法可以用来遍历图中的所有节点，深度优先搜索算法可以用来查找图中的环路等等。
在社交网络中，图算法可以用来发现社区结构和关键节点。
在交通规划中，图算法可以用来寻找最佳路径和优化交通流量。
此外，图算法还被广泛应用于网络安全、电信网络优化、推荐系统等领域。
三、动态规划算法动态规划算法是一种通过将问题分解为子问题并存储子问题的解来解决复杂问题的方法。
它通常用于求解具有重叠子问题和最优子结构性质的问题。
动态规划算法的核心思想是通过利用已解决的子问题的解来构建更大的问题的解。
动态规划算法在实际应用中有着广泛的应用。
例如，在旅行商问题中，动态规划算法可以用来求解最短路径问题。
在背包问题中，动态规划算法可以用来求解最大价值问题。
此外，动态规划算法还被广泛应用于自然语言处理、图像处理、机器人路径规划等领域。
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）斐波那契数列是一列数字，其中每个数字都是前两个数字的和。
世界十大经典算法世界十大经典算法算法是计算机科学中非常重要的概念，它是一种解决问题的方法和步骤的描述。
以下是世界上广泛应用且被业界认可的十大经典算法： 1. 二分查找算法（Binary Search Algorithm）：在有序数组中查找目标元素的算法。
通过将目标元素与数组中间元素进行比较，可以将搜索范围缩小一半，从而提高搜索效率。
2. 快速排序算法（Quick Sort Algorithm）：一种基于分治法的排序算法。
它通过选择一个基准元素，将数组分为两个子数组，其中一个子数组的元素都小于等于基准元素，另一个子数组的元素都大于等于基准元素，然后递归地对子数组进行排序。
3. 归并排序算法（Merge Sort Algorithm）：一种基于分治法的排序算法。
它将数组分成两个子数组，然后递归地对子数组进行排序，并将排序好的子数组合并成一个有序的数组。
4. 广度优先搜索算法（Breadth-First Search Algorithm）：用于图遍历的一种算法。
它从图的某个顶点开始，逐层遍历其邻接顶点，直到遍历完所有顶点。
广度优先搜索常用于寻找最短路径或解决迷宫等问题。
5. 深度优先搜索算法（Depth-First Search Algorithm）：用于图遍历的一种算法。
它从图的某个顶点开始，沿着一条路径一直向下遍历，直到无法继续为止，然后回溯到上一个没有遍历完的邻接顶点，继续遍历其他路径。
深度优先搜索常用于生成迷宫、图的连通性问题等。
6. Dijkstra算法（Dijkstra's Algorithm）：用于求解单源最短路径问题的一种算法。
它根据权重赋值给每条边，计算出从源节点到其他节点的最短路径。
7. 动态规划算法（Dynamic Programming Algorithm）：一种基于分治法的优化算法。
动态规划在问题可分解为重叠子问题时，通过保存子问题的解，避免重复计算，从而提高算法效率。
python实现⼗⼤经典算法排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进⾏排序，⽽外部排序是因排序的数据很⼤，⼀次不能容纳全部的排序记录，在排序过程中需要访问外存。
常见的内部排序算法有：插⼊排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。
⽤⼀张图概括：关于时间复杂度：1. 平⽅阶 (O(n2)) 排序各类简单排序：直接插⼊、直接选择和冒泡排序。
2. 线性对数阶 (O(nlog2n)) 排序快速排序、堆排序和归并排序。
3. O(n1+§)) 排序，§ 是介于 0 和 1 之间的常数。
希尔排序。
4. 线性阶 (O(n)) 排序基数排序，此外还有桶、箱排序。
关于稳定性：稳定的排序算法：冒泡排序、插⼊排序、归并排序和基数排序。
不是稳定的排序算法：选择排序、快速排序、希尔排序、堆排序。
名词解释：n：数据规模k：“桶”的个数In-place：占⽤常数内存，不占⽤额外内存Out-place：占⽤额外内存稳定性：排序后 2 个相等键值的顺序和排序之前它们的顺序相同冒泡排序冒泡排序（Bubble Sort）也是⼀种简单直观的排序算法。
它重复地⾛访过要排序的数列，⼀次⽐较两个元素，如果他们的顺序错误就把他们交换过来。
⾛访数列的⼯作是重复地进⾏直到没有再需要交换，也就是说该数列已经排序完成。
这个算法的名字由来是因为越⼩的元素会经由交换慢慢“浮”到数列的顶端。
作为最简单的排序算法之⼀，冒泡排序给我的感觉就像 Abandon 在单词书⾥出现的感觉⼀样，每次都在第⼀页第⼀位，所以最熟悉。
冒泡排序还有⼀种优化算法，就是⽴⼀个 flag，当在⼀趟序列遍历中元素没有发⽣交换，则证明该序列已经有序。
但这种改进对于提升性能来说并没有什么太⼤作⽤。
1. 算法步骤1. ⽐较相邻的元素。
如果第⼀个⽐第⼆个⼤，就交换他们两个。
2. 对每⼀对相邻元素作同样的⼯作，从开始第⼀对到结尾的最后⼀对。
五大经典算法以及案例
1. 排序算法：使用冒泡排序算法对一个包含10个随机整数的数组进行排序。
案例：
给定数组：[4, 9, 2, 5, 1, 8, 3, 7, 6, 10]
排序后的数组：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
2. 查找算法：使用二分查找算法在一个有序整数数组中查找目标值。
案例：
给定有序数组：[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
目标值：11
查找结果：目标值在数组中的位置为5。
3. 图遍历算法：使用深度优先搜索算法遍历一个无向图。
案例：
给定无向图的邻接矩阵表示：
[0, 1, 1, 0, 0]
[1, 0, 0, 1, 1]
[1, 0, 0, 0, 1]
[0, 1, 0, 0, 0]
[0, 1, 1, 0, 0]
从节点1开始进行深度优先搜索的遍历结果：1 -> 2 -> 4 -> 3 -> 5
4. 动态规划算法：使用动态规划算法求解斐波那契数列的第n项。
案例：
求解斐波那契数列的第10项：
斐波那契数列：1, 1, 2, 3, 5, 8, 13, 21, 34, 55
第10项为55。
5. 贪心算法：使用贪心算法解决背包问题。
案例：
给定背包容量为10，物品列表如下：
物品1：重量4，价值8
物品2：重量3，价值5
物品3：重量1，价值2
物品4：重量5，价值12
通过贪心算法选择物品装入背包的方案：
选择物品2，物品3，物品4装入背包，总重量为9，总价值为19。
几种排序算法的伪代码.doc
一、冒泡排序
伪代码：
（1）设置一个标记flag，用于判断是否发生了数据的交换，初始设置为TRUE
（2）重复以下操作：
A、从第0个位置开始，比较相邻的数据；若第0个数据比第1个数据大，则将它们交换，否则直接跳过；然后，从第1个位置开始，比较相邻的数据；若第1个数据比第2个数据大，则将它们交换，否则直接跳过……
B、若这次循环发生了交换（若发生交换，flag将变为TRUE），则重复上面提到的A 步；若此次循环没有发生交换（若没有发生交换，flag将变为FALSE），则结束此次循环
（3）结束时若flag为FALSE，表明已排序完毕
（1）首先，找到数组的中心点元素作为对比元素
（2）从数组的头部开始遍历，当遇到比中心点元素小的元素时，将其加入其后面一个指针位置，由此序列小于中心点元素的序列将被形成
（4）数组以序列小于中心点元素和大于中心点元素两个序列分割，重复（1）、（2）、（3）步骤，直至数组的末尾
（5）排序完成
（1）从第0个位置开始，将第1个元素赋值给暂存变量
（2）比较暂存变量与第0个元素，若暂存变量比第0个元素小，则将暂存变量插入到第0个位置，此过程结束；否则，将第0个元素整体后移一位，并将暂存变量插入到第0个位置，此过程结束
（3）重复以上过程，直至最后一个元素完成排序。
计算机常见的32种算法
1.冒泡排序算法
2.选择排序算法
3.插入排序算法
4.希尔排序算法
5.归并排序算法
6.快速排序算法
7.堆排序算法
8.计数排序算法
9.桶排序算法
10.基数排序算法
11.贪心算法
12.动态规划算法
13.分治算法
14.回溯算法
15.图的深度优先算法（DFS）
16.图的广度优先算法（BFS）
17. Kruskal算法（最小生成树）
18. Prim算法（最小生成树）
19. Floyd-Warshall算法（最短路径）
20. Dijkstra算法（最短路径）
21.拓扑排序算法
22. 找出最大子数组的算法（Kadane算法）
23.最长公共子序列算法
24.最长递增子序列算法
25.最长回文子串算法
26.哈夫曼编码算法
27. Rabin-Karp算法（字符串匹配）
28. Boyer-Moore算法（字符串匹配）
29.KMP算法（字符串匹配）
30.后缀数组算法
31.基于哈希表的查找算法
32.基于二分查找的查找算法
需要注意的是，以上列举的只是计算机中常见的算法之一，实际上还存在着很多其他的算法。
每种算法都有其特定的应用场景和解决问题的方法。
对于每种算法的原理和具体实现细节，可以进一步深入学习和研究。
一、常见经典排序算法 1.希尔排序 2.二分插入法 3.直接插入法 4.带哨兵的直接排序法 5.冒泡排序 6.选择排序 7.快速排序 8.堆排序 一.希尔（Shell）排序法（又称宿小增量排序，是1959年由D.L.Shell提出来的） /* Shell 排序法 */ #include void sort(int v[],int n) { int gap,i,j,temp; for(gap=n/2;gap>0;gap /= 2) /* 设置排序的步长，步长gap每次减半，直到减到1 */ { for(i=gap;i{ for(j=i-gap;(j >= 0) && (v[j] > v[j+gap]);j -= gap ) /* 比较相距gap远的两个元素的大小，根据排序方向决定如何调换 */ { temp=v[j]; v[j]=v[j+gap]; v[j+gap]=temp; } } } } 二.二分插入法 /* 二分插入法 */ void HalfInsertSort(int a[], int len) { int i, j,temp; int low, high, mid; for (i=1; i{ temp = a[i];/* 保存但前元素 */ low = 0; high = i-1; while (low <= high) /* 在a[low...high]中折半查找有序插入的位置 */ { mid = (low + high) / 2; /* 找到中间元素 */ if (a[mid] > temp) /* 如果中间元素比但前元素大，当前元素要插入到中间元素的左侧 */ { high = mid-1; } else /* 如果中间元素比当前元素小，但前元素要插入到中间元素的右侧 */ { low = mid+1; } } /* 找到当前元素的位置，在low和high之间 */ for (j=i-1; j>high; j--)/* 元素后移 */ { a[j+1] = a[j]; } a[high+1] = temp; /* 插入 */ } } 三.直接插入法 /*直接插入法*/ void InsertionSort(int input[],int len) { int i,j,temp; for (i = 1; i < len; i++) { temp = input[i]; /* 操作当前元素，先保存在其它变量中 */ for (j = i - 1;j>-1&&input[j] > temp ; j--) /* 从当前元素的上一个元素开始查找合适的位置 */ { input[j + 1] = input[j]; /* 一边找一边移动元素 */ input[j] = temp; } } } 四.带哨兵的直接排序法 /** * 带哨兵的直接插入排序,数组的第一个元素不用于存储有效数据 * 将input[0]作为哨兵，可以避免判定input[j]中，数组是否越界 * 因为在j--的过程中，当j减小到0时,变成了input[0]与input[0] * 自身进行比较，很明显这个时候说明位置i之前的数字都比input[i]小 * 位置i上的数字不需要移动，直接进入下一轮的插入比较。 * */ void InsertionSortWithPiquet(int input[],int len) { int i,j; for (i = 2; i < len; i++) /* 保证数组input第一元素的存储数据无效，从第二个数据开始与它前面的元素比较 */ { input[0] = input[i]; for (j = i - 1; input[j] > input[0] ; j--) { input[j + 1] = input[j]; input[j] = input[0]; /* input[j]一直都是排序的元素中最大的那一个 */ } } } 五.冒泡法 /* 冒泡排序法 */ void Bublesort(int a[],int n) { int i,j,k; for(j=0;j{ for(i=0;i沉下去就可以啦 */ { if(a[i]>a[i+1]) /* 把值比较大的元素沉到底 */ { k=a[i]; a[i]=a[i+1]; a[i+1]=k; } } } } 六.选择排序法 /*算法原理：首先以一个元素为基准，从一个方向开始扫描， * 比如从左至右扫描，以A[0]为基准。接下来从A[0]...A[9] * 中找出最小的元素，将其与A[0]交换。然后将基准位置右 * 移一位，重复上面的动作，比如，以A[1]为基准，找出 * A[1]~A[9]中最小的，将其与A[1]交换。一直进行到基准位 * 置移到数组最后一个元素时排序结束（此时基准左边所有元素 * 均递增有序，而基准为最后一个元素，故完成排序）。 */ void Selectsort(int A[],int n) { int i,j,min,temp; for(i=0;i{ min=i; for(j=i+1;j<=n;j++) /* 从j往前的数据都是排好的，所以从j开始往下找剩下的元素中最小的 */ { if(A[min]>A[j]) /* 把剩下元素中最小的那个放到A[i]中 */ { temp=A[i]; A[i]=A[j]; A[j]=temp; } } } } 七.快速排序 /* 快速排序（quick sort）。在这种方法中， * n 个元素被分成三段（组）：左段left， * 右段right和中段middle。中段 * 仅包含一个元素。左段中各元素都小于等 * 于中段元素，右段中各元素都大于等于中 * 段元素。因此left和right中的元 * 素可以独立排序，并且不必对left和 * right的排序结果进行合并。 * 使用快速排序方法对a[0:n-1]排序 * 从a[0:n-1]中选择一个元素作为middle， * 该元素为支点把余下的元素分割为两段left * 和right，使得left中的元素都小于 * 等于支点，而right 中的元素都大于等于支点 * 递归地使用快速排序方法对left 进行排序 * 递归地使用快速排序方法对right 进行排序 * 所得结果为left+middle+right */ void Quick_sort(int data[],int low,int high) { int mid; if(low{ mid=Partition(data,low,high); Quick_sort(data,low,mid-1); /* 递归调用 */ Quick_sort(data,mid+1,high); } } /* 要注意看清楚下面的数据之间是如何替换的， * 首先选一个中间值，就是第一个元素data[low], * 然后从该元素的最右侧开始找到比它小的元素，把 * 该元素复制到它中间值原来的位置(data[low]=data[high])， * 然后从该元素的最左侧开始找到比它大的元素，把 * 该元素复制到上边刚刚找到的那个元素的位置(data[high]=data[low])， * 最后将这个刚空出来的位置装入中间值(data[low]=data[0])， * 这样一来比mid大的都会跑到mid的右侧，小于mid的会在左侧， * 最后一行，返回的low是中间元素的位置，左右分别递归就可以排好序了。 */ int Partition(int data[],int low,int high) { int mid; data[0]=data[low]; mid=data[low]; while(low < high) { while((low < high) && (data[high] >= mid)) { --high; } data[low]=data[high]; /* 从high的位置开始往low的方向找，找到比data[low]小的元素，存到data[low]中 */
while((low < high) && (data[low] < mid)) /* 新得到的data[low]肯定小于原来的data[low]即mid */ { ++low; } data[high]=data[low]; /* 从low的位置开始往high的方向找，找到比data[high]大的元素，存在data[high]中 */ } data[low]=data[0]; /* 把low的新位置存上原来的data[low]的数据 */ return low; /* 递归时，把它做为右侧元素的low */ } 八.堆排序 /************************************************************** * 堆的定义 n 个元素的序列 {k1,k2,...,kn}当且仅当满足下列关系时， * 称为堆: * ki<=k2i ki<=k2i+1 (i=1,2,...,n/2) * 或 * ki>=k2i ki>=k2i+1 (i=1,2,...,n/2) * 堆排序思路： * 建立在树形选择排序基础上； * 将待排序列建成堆（初始堆生成）后，序列的第一个元素（堆顶元素）就一定是序列中的最大元素；
