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语言--常见排序算法
49
2 j 49
08
0
25* 3 49 25
16 4
21
5
08
25
25*
16
21
i k 49
j 25* 25
08
25
25*
16
21
算法实例：
1.1.5 选择排序
49 2
08 0
25 1 i
25* 3
16 4 k
21 5 j 21 16
k 指示当前序列中最小者
算法实现：
08 5 temp
16 21 25 25* 49 08 0 1 2 3 4 5
算法实现：
1.1.3 直接插入排序
void InsertSort (int r[ ], int n ) { // 假设关键字为整型，放在向量r[]中 int i, j, temp; for (i = 1;i< n;i++ ) { temp = r[i]; for(j = i;j>0;j- -) {//从后向前顺序比较，并依次后移 if ( temp < r[j-1] ) r[j] = r[j-1]; else break; } r[j] = temp; } }
输入n 个数给a[1] 到 a[n]
for j=1 to n-1
for i=1 to n-j
真 a[i]>a[i+1]
a[i]a[i+1]
输出a[1] 到 a[n]
main() { int a[11],i,j,t; printf("Input 10 numbers:\n"); for(i=1;i<11;i++) scanf("%d",&a[i]); printf("\n"); 假 for(j=1;j<=9;j++) for(i=1;i<=10-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=1;i<11;i++) printf("%d ",a[i]); }
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语言八大排序算法
C语⾔⼋⼤排序算法C语⾔⼋⼤排序算法，附动图和详细代码解释！来源：C语⾔与程序设计、⽵⾬听闲等⼀前⾔如果说各种编程语⾔是程序员的招式，那么数据结构和算法就相当于程序员的内功。
想写出精炼、优秀的代码，不通过不断的锤炼，是很难做到的。
⼆⼋⼤排序算法排序算法作为数据结构的重要部分，系统地学习⼀下是很有必要的。
1、排序的概念排序是计算机内经常进⾏的⼀种操作，其⽬的是将⼀组“⽆序”的记录序列调整为“有序”的记录序列。
排序分为内部排序和外部排序。
若整个排序过程不需要访问外存便能完成，则称此类排序问题为内部排序。
反之，若参加排序的记录数量很⼤，整个序列的排序过程不可能在内存中完成，则称此类排序问题为外部排序。
2、排序分类⼋⼤排序算法均属于内部排序。
如果按照策略来分类，⼤致可分为：交换排序、插⼊排序、选择排序、归并排序和基数排序。
如下图所⽰：3、算法分析1.插⼊排序*直接插⼊排序*希尔排序2.选择排序*简单选择排序*堆排序3.交换排序*冒泡排序*快速排序4.归并排序5.基数排序不稳定排序：简单选择排序，快速排序，希尔排序，堆排序稳定排序：冒泡排序，直接插⼊排序，归并排序，奇数排序1、插⼊排序将第⼀个和第⼆个元素排好序，然后将第3个元素插⼊到已经排好序的元素中，依次类推（插⼊排序最好的情况就是数组已经有序了）因为插⼊排序每次只能操作⼀个元素，效率低。
元素个数N，取奇数k=N/2，将下标差值为k的数分为⼀组（⼀组元素个数看总元素个数决定），在组内构成有序序列，再取k=k/2，将下标差值为k的数分为⼀组，构成有序序列，直到k=1，然后再进⾏直接插⼊排序。
3、简单选择排序选出最⼩的数和第⼀个数交换，再在剩余的数中⼜选择最⼩的和第⼆个数交换，依次类推4、堆排序以升序排序为例，利⽤⼩根堆的性质（堆顶元素最⼩）不断输出最⼩元素，直到堆中没有元素1.构建⼩根堆2.输出堆顶元素3.将堆低元素放⼀个到堆顶，再重新构造成⼩根堆，再输出堆顶元素，以此类推5、冒泡排序改进1：如果某次冒泡不存在数据交换，则说明已经排序好了，可以直接退出排序改进2：头尾进⾏冒泡，每次把最⼤的沉底，最⼩的浮上去，两边往中间靠16、快速排序选择⼀个基准元素，⽐基准元素⼩的放基准元素的前⾯，⽐基准元素⼤的放基准元素的后⾯，这种动作叫分区，每次分区都把⼀个数列分成了两部分，每次分区都使得⼀个数字有序，然后将基准元素前⾯部分和后⾯部分继续分区，⼀直分区直到分区的区间中只有⼀个元素的时候，⼀个元素的序列肯定是有序的嘛，所以最后⼀个升序的序列就完成啦。
排列c的计算公式
排列组合C的计算公式
排列组合C的计算公式：
组合用符号C(n,m)表示，m≦n。
公式是：C(n,m)=A(n,m)/m!或C(n,m)=C(n,n-m)。
例如：C(5,2)=A(5,2)/[2!x(5-2)!]=(1x2x3x4x5)/[2x(1x2x3)]=10。
拓展：
排列A的计算公式：
排列用符号A(n,m)表示，m≦n。
计算公式是：A(n,m)＝n(n-1)(n-2)……(n-m+1)＝n!/(n-m)!
此外规定0!=1，n!表示n(n-1)(n-2) (1)
例如：6!=6x5x4x3x2x1=720，4!=4x3x2x1=24。
排列有两种定义，但计算方法只有一种，凡是符合这两种定义的都用这种方法计算；定义的前提条件是m≦n，m与n均为自然数。
（1）从n个不同元素中，任取m个元素按照一定的顺序排成一列，叫做从n个不同元素中取出m个元素的一个排列。
（2）从n个不同元素中，取出m个元素的所有排列的个数，叫做从n个不同元素中取出m个元素的排列数。
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语言实现简单排序(8种方法)
#include<stdio.h>#include<stdlib.h>//冒泡排序voidbubleSort(int data[], int n);//快速排序voidquickSort(int data[], int low, int high); intfindPos(int data[], int low, int high);//插入排序voidbInsertSort(int data[], int n);//希尔排序voidshellSort(int data[], int n);//选择排序voidselectSort(int data[], int n);//堆排序voidheapSort(int data[], int n);void swap(int data[], inti, int j);voidheapAdjust(int data[], inti, int n);//归并排序voidmergeSort(int data[], int first, int last);void merge(int data[], int low, int mid, int high); //基数排序voidradixSort(int data[], int n);intgetNumPos(intnum, intpos);int main() {int data[10] = {43, 65, 4, 23, 6, 98, 2, 65, 7, 79}; inti;printf("原先数组:");for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");/*printf("冒泡排序:");bubleSort(data, 10);for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");printf("快速排序:");quickSort(data, 0, 9);for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");printf("插入排序:");bInsertSort(data,10);for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");printf("希尔排序:");shellSort(data, 10);for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");printf("选择排序:");selectSort(data, 10);for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");int data[11] = {-1, 43, 65, 4, 23, 6, 98, 2, 65, 7, 79}; inti;printf("原先数组:");int data[11] = {-1, 43, 65, 4, 23, 6, 98, 2, 65, 7, 79}; for(i=1;i<11;i++) {printf("%d ", data[i]);}printf("\n");printf(" 堆排序:");heapSort(data, 10);for(i=1;i<11;i++) {printf("%d ", data[i]);}printf("\n");printf("归并排序:");mergeSort(data, 0, 9);for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");*/printf("基数排序:");radixSort(data, 10);for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");return 0;}/*--------------------冒泡排序---------------------*/ voidbubleSort(int data[], int n) {inti,j,temp;//两个for循环，每次取出一个元素跟数组的其他元素比较//将最大的元素排到最后。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
c排序算法大全排序算法是一种基本并且常用的算法。
由于实际工作中处理的数量巨大，所以排序算法对算法本身的速度要求很高。
而一般我们所谓的算法的性能主要是指算法的复杂度，一般用O方法来表示。
在后面我将给出详细的说明。
对于排序的算法我想先做一点简单的介绍，也是给这篇文章理一个提纲。
我将按照算法的复杂度，从简单到难来分析算法。
第一部分是简单排序算法，后面你将看到他们的共同点是算法复杂度为O(N*N)（因为没有使用word,所以无法打出上标和下标）。
第二部分是高级排序算法，复杂度为O(Log2(N))。
这里我们只介绍一种算法。
另外还有几种算法因为涉及树与堆的概念，所以这里不于讨论。
第三部分类似动脑筋。
这里的两种算法并不是最好的（甚至有最慢的），但是算法本身比较奇特，值得参考（编程的角度）。
同时也可以让我们从另外的角度来认识这个问题。
现在，让我们开始吧：一、简单排序算法由于程序比较简单，所以没有加什么注释。
所有的程序都给出了完整的运行代码，并在我的VC环境下运行通过。
因为没有涉及MFC和WINDOWS的内容，所以在BORLAND C++的平台上应该也不会有什么问题的。
在代码的后面给出了运行过程示意，希望对理解有帮助。
1.冒泡法：这是最原始，也是众所周知的最慢的算法了。
他的名字的由来因为它的工作看来象是冒泡：#include <iostream.h>void BubbleSort(int* pData,int Count){int iTemp;for(int i=1;i<Count;i++){for(int j=Count-1;j>=i;j--){if(pData[j]<pData[j-1]){iTemp = pData[j-1];pData[j-1] = pData[j];pData[j] = iTemp;}}}}void main(){int data[] = {10,9,8,7,6,5,4};BubbleSort(data,7);for (int i=0;i<7;i++)cout<<data[i]<<" ";cout<<"\n";}倒序(最糟情况)第一轮：10,9,8,7->10,9,7,8->10,7,9,8->7,10,9,8(交换3次)第二轮：7,10,9,8->7,10,8,9->7,8,10,9(交换2次)第一轮：7,8,10,9->7,8,9,10(交换1次)循环次数：6次交换次数：6次其他：第一轮：8,10,7,9->8,10,7,9->8,7,10,9->7,8,10,9(交换2次)第二轮：7,8,10,9->7,8,10,9->7,8,10,9(交换0次)第一轮：7,8,10,9->7,8,9,10(交换1次)循环次数：6次交换次数：3次上面我们给出了程序段，现在我们分析它：这里，影响我们算法性能的主要部分是循环和交换，显然，次数越多，性能就越差。
从上面的程序我们可以看出循环的次数是固定的，为1+2+...+n-1。
写成公式就是1/2*(n-1)*n。
现在注意，我们给出O方法的定义：若存在一常量K和起点n0，使当n>=n0时，有f(n)<=K*g(n),则f(n) = O(g(n))。
（呵呵，不要说没学好数学呀，对于编程数学是非常重要的！！！）现在我们来看1/2*(n-1)*n，当K=1/2，n0=1，g(n)=n*n时，1/2*(n-1)*n<=1/2*n*n=K*g(n)。
所以f(n) =O(g(n))=O(n*n)。
所以我们程序循环的复杂度为O(n*n)。
再看交换。
从程序后面所跟的表可以看到，两种情况的循环相同，交换不同。
其实交换本身同数据源的有序程度有极大的关系，当数据处于倒序的情况时，交换次数同循环一样（每次循环判断都会交换），复杂度为O(n*n)。
当数据为正序，将不会有交换。
复杂度为O(0)。
乱序时处于中间状态。
正是由于这样的原因，我们通常都是通过循环次数来对比算法。
2.交换法：交换法的程序最清晰简单，每次用当前的元素一一的同其后的元素比较并交换。
#include <iostream.h>void ExchangeSort(int* pData,int Count){int iTemp;for(int i=0;i<Count-1;i++){for(int j=i+1;j<Count;j++){if(pData[j]<pData[i]){iTemp = pData[i];pData[i] = pData[j];pData[j] = iTemp;}}}}void main(){int data[] = {10,9,8,7,6,5,4};ExchangeSort(data,7);for (int i=0;i<7;i++)cout<<data[i]<<" ";cout<<"\n";}倒序(最糟情况)第一轮：10,9,8,7->9,10,8,7->8,10,9,7->7,10,9,8(交换3次)第二轮：7,10,9,8->7,9,10,8->7,8,10,9(交换2次)第一轮：7,8,10,9->7,8,9,10(交换1次)循环次数：6次交换次数：6次其他：第一轮：8,10,7,9->8,10,7,9->7,10,8,9->7,10,8,9(交换1次)第二轮：7,10,8,9->7,8,10,9->7,8,10,9(交换1次)第一轮：7,8,10,9->7,8,9,10(交换1次)循环次数：6次交换次数：3次从运行的表格来看，交换几乎和冒泡一样糟。
事实确实如此。
循环次数和冒泡一样也是1/2*(n-1)*n，所以算法的复杂度仍然是O(n*n)。
由于我们无法给出所有的情况，所以只能直接告诉大家他们在交换上面也是一样的糟糕（在某些情况下稍好，在某些情况下稍差）。
3.选择法：现在我们终于可以看到一点希望：选择法，这种方法提高了一点性能（某些情况下）这种方法类似我们人为的排序习惯：从数据中选择最小的同第一个值交换，在从省下的部分中选择最小的与第二个交换，这样往复下去。
#include <iostream.h>void SelectSort(int* pData,int Count){int iTemp;int iPos;for(int i=0;i<Count-1;i++){iTemp = pData[i];iPos = i;for(int j=i+1;j<Count;j++){if(pData[j]<iTemp){iTemp = pData[j];iPos = j;}}pData[iPos] = pData[i];pData[i] = iTemp;}}void main(){int data[] = {10,9,8,7,6,5,4};SelectSort(data,7);for (int i=0;i<7;i++)cout<<data[i]<<" ";cout<<"\n";}倒序(最糟情况)第一轮：10,9,8,7->(iTemp=9)10,9,8,7->(iTemp=8)10,9,8,7->(iTemp=7)7,9,8,10(交换1次)第二轮：7,9,8,10->7,9,8,10(iTemp=8)->(iTemp=8)7,8,9,10(交换1次)第一轮：7,8,9,10->(iTemp=9)7,8,9,10(交换0次)循环次数：6次交换次数：2次其他：第一轮：8,10,7,9->(iTemp=8)8,10,7,9->(iTemp=7)8,10,7,9->(iTemp=7)7,10,8,9(交换1次)第二轮：7,10,8,9->(iTemp=8)7,10,8,9->(iTemp=8)7,8,10,9(交换1次)第一轮：7,8,10,9->(iTemp=9)7,8,9,10(交换1次)循环次数：6次交换次数：3次遗憾的是算法需要的循环次数依然是1/2*(n-1)*n。
所以算法复杂度为O(n*n)。
我们来看他的交换。
由于每次外层循环只产生一次交换（只有一个最小值）。
所以f(n)<=n 所以我们有f(n)=O(n)。
所以，在数据较乱的时候，可以减少一定的交换次数。
4.插入法：插入法较为复杂，它的基本工作原理是抽出牌，在前面的牌中寻找相应的位置插入，然后继续下一张#include <iostream.h>void InsertSort(int* pData,int Count){int iTemp;int iPos;for(int i=1;i<Count;i++){iTemp = pData[i];iPos = i-1;while((iPos>=0) && (iTemp<pData[iPos])){pData[iPos+1] = pData[iPos];iPos--;}pData[iPos+1] = iTemp;}}void main(){int data[] = {10,9,8,7,6,5,4};InsertSort(data,7);for (int i=0;i<7;i++)cout<<data[i]<<" ";cout<<"\n";}倒序(最糟情况)第一轮：10,9,8,7->9,10,8,7(交换1次)(循环1次)第二轮：9,10,8,7->8,9,10,7(交换1次)(循环2次)第一轮：8,9,10,7->7,8,9,10(交换1次)(循环3次)循环次数：6次交换次数：3次其他：第一轮：8,10,7,9->8,10,7,9(交换0次)(循环1次)第二轮：8,10,7,9->7,8,10,9(交换1次)(循环2次)第一轮：7,8,10,9->7,8,9,10(交换1次)(循环1次)循环次数：4次交换次数：2次上面结尾的行为分析事实上造成了一种假象，让我们认为这种算法是简单算法中最好的，其实不是，因为其循环次数虽然并不固定，我们仍可以使用O 方法。