C语言排序方法及代码
C语言数组的五种简单排序，选择法排序，冒泡法排序、交换法排序、插入法排序、折半法排序
C语⾔数组的五种简单排序，选择法排序，冒泡法排序、交换法排序、插⼊法排序、折半法排序⽂章⽬录1、选择法排序选择法排序是指每次选择索要排序的数组中的最⼩值（这⾥是由⼩到⼤排序，如果是由⼤到⼩排序则需要选择最⼤值）的数组元素，将这些数组元素的值与前⾯没有进⾏排序的数组元素值进⾏互换代码实现需要注意的是：声明⼀个数组和两个整形变量，数组⽤于存储输⼊的数字，⽽整形变量⽤于存储最⼩的数组元素的数值与该元素的位置，在我的代码中实现为a[] temp position。
代码具体如下#include<stdio.h>int main(){int m,n,k;printf("please input the length of the array:");scanf("%d",&k);int a[k];int temp;int position;printf("please input the number of the array:\n");for(m=0;m<k;m++){printf("a[%d]=",m+1);scanf("%d",&a[m]);}/*从⼩到⼤排序*/for(m=0;m<k-1;m++){temp=a[m]; //设置当前的值为最⼩值position=m; //记录当前的位置for(n=m+1;n<k;n++){if(a[n]<temp){temp=a[n]; //如果找到⽐当前的还要⼩的数值，则更换最⼩的数值与位置position=n;}}a[position]=a[m];a[m]=temp;}for(m=0;m<k;m++){printf("%d\t",a[m]);}return 0;}结果如下2、冒泡法排序冒泡法排序就是值在排序时，每次⽐较数组中相邻的两个数组元素的值，将⽐较⼩的（从⼩到⼤排序算法，如果是从⼤到⼩排序算法就是将较⼤的数排在较⼩的数前⾯）排在⽐较⼤的前⾯在代码实现的过程中：声明⼀个数组与⼀个整型变量，数组⽤于存放数据元素，整型变量⽤于交换时作为中间变量。
10个经典的C语言基础算法及代码
10个经典的C语言基础算法及代码1.冒泡排序算法冒泡排序是一种简单但效率较低的排序算法，在每一轮遍历中比较相邻的两个元素，如果顺序不正确则交换它们，直到整个数组有序为止。
```cvoid bubbleSort(int arr[], int n)for (int i = 0; i < n-1; i++)for (int j = 0; j < n-1-i; j++)if (arr[j] > arr[j+1])int temp = arr[j];arr[j] = arr[j+1];arr[j+1] = temp;}}}```2.选择排序算法选择排序是一种简单直观的排序算法，它每次从待排序的数组中选择最小（或最大）的元素，并放到已排序的数组末尾。
```cvoid selectionSort(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];arr[min_index] = temp;}```3.插入排序算法插入排序的基本思想是将数组分为已排序和未排序两部分，每次将未排序的元素插入到已排序的合适位置。
```cvoid insertionSort(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语言实现12种排序方法
使⽤C语⾔实现12种排序⽅法⽬录1.冒泡排序2.插⼊排序3.折半插⼊排序4.希尔排序5.选择排序6.鸡尾酒排序7.堆排序8.快速排序9.归并排序10.计数排序11.桶排序12.基数排序1.冒泡排序思路：⽐较相邻的两个数字，如果前⼀个数字⼤，那么就交换两个数字，直到有序。
时间复杂度O(n^2)，稳定性：这是⼀种稳定的算法。
代码实现：void bubble_sort(int arr[],size_t len){size_t i,j;for(i=0;i<len;i++){bool hasSwap = false; //优化，判断数组是否已经有序，如果有序可以提前退出循环for(j=1;j<len-i;j++){ //这⾥j<len-i是因为最后⾯的肯定都是最⼤的，不需要多进⾏⽐较if(arr[j-1]>arr[j]){ //如果前⼀个⽐后⼀个⼤swap(&arr[j-1],&arr[j]); //交换两个数据hasSwap = true;}}if(!hasSwap){break;}}}2.插⼊排序思路：把⼀个数字插⼊⼀个有序的序列中，使之仍然保持有序，如对于需要我们进⾏排序的数组，我们可以使它的前i个数字有序，然后再插⼊i+1个数字，插⼊到合适的位置使之仍然保持有序，直到所有的数字有序。
时间复杂度：O(n^2) 稳定性：稳定的算法代码实现：void insert_sort(int arr[],int len){int i,j;for(i=1;i<len;i++){int key = arr[i]; //记录当前需要插⼊的数据for(j= i-1;i>=0&&arr[j]>key;j--){ //找到插⼊的位置arr[j+1] = arr[j]; //把需要插⼊的元素后⾯的元素往后移}arr[j+1] = key; //插⼊该元素}}3.折半插⼊排序思路：本质上是插⼊排序，但是通过半分查找法找到插⼊的位置，让效率稍微快⼀点。
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语言简单查找排序方法及代码
第一部分查找1、线性查找法：import java.util.Scanner;public class SearchDataElement {public static void main(String[] args) {Scanner scanner=new Scanner(System.in);int[]array;array=new int[]{8,7,5,4,1,5,9,6,3,4};for(int i=0;i<array.length;i++)System.out.println(""+array[i]);System.out.println();int replay=0;do{System.out.print("请输入要查找的数字0-10");int num=scanner.nextInt();lable:{for(int t=0;t<array.length;t++){if(num==array[t]){System.out.println("array["+t+"]="+array[t]);break lable;}}System.out.println("输入的数字数组中不存在");}System.out.println("重新查找1:继续 0:结束?");replay=scanner.nextInt();}while(replay==1);}}2、二分查找算法import java.util.Scanner;public class SearchBinary {public static int searchB(int[]arr,int key){int low=0;int high=arr.length-1;//while(high>=low){int mid=(low+high)/2;if(key<arr[mid])high=mid-1;else if(key==arr[mid])return mid;elselow=mid+1;}return-1;}public static void main(String[] args) {// TODO Auto-generated method stubint[]array=new int[]{2,4,7,11,14,25,33,42,55,64,75,88,89,90,92};int key;Scanner scanner=new Scanner(System.in);System.out.println("\n 请输入关键字:");key=scanner.nextInt();//int result=searchB(array,key);if(result!=-1)System.out.printf("\n%d found in arrray element %d\n", key,result);elseSystem.out.printf("\n %d not found in array\n",key);}}C语言排序方法学的排序算法有：插入排序，合并排序，冒泡排序，选择排序，希尔排序，堆排序，快速排序，计数排序，基数排序，桶排序（没有实现）。
快速排序法c语言代码
快速排序法c语言代码
快速排序是一种常用的排序算法，时间复杂度为 O(n log n)。
在本代码中，我们先定义了一个 `quick_sort()` 函数和一个
`partition()` 函数。
`quick_sort()` 函数实现了快速排序的主要逻辑，它首先调用 `partition()` 函数将数组分为两部分，然后递归调用自身来对两个子数组进行排序。
`partition()` 函数用来将数组分为两部分，并返回枢轴元素的索引。
在此过程中，我们首先选择数组的最后一个元素作为枢轴元素，然后依次遍历数组并将小于枢轴元素的元素移到数组左边，大于枢轴元素的元素移到数组右边。
最后将枢轴元素移到分割点上，以便将数组分为两部分。
- 1 -。
C语言奇偶排序算法详解及实例代码
C语言奇偶排序算法详解及实例代码奇偶排序（Odd-Even Sort）算法是一种简单的排序算法，它可以同时对数组中的奇数和偶数进行排序。
这个算法的原理比较简单，它的思想类似冒泡排序，只不过比较的对象从相邻的两个数变为了相隔一个位置的两个数。
奇偶排序算法的步骤如下：1.将数组分为两个部分，分别存放奇数和偶数。
2.在奇数部分中进行一轮冒泡排序，将较大的数往右移。
3.在偶数部分中进行一轮冒泡排序，将较小的数往左移。
4.重复执行步骤2和步骤3，直到数组完全有序。
下面我们来详细解析奇偶排序算法，并给出一个实例代码。
1. 定义一个函数 `void oddEvenSort(int arr[], int n)`，用于实现奇偶排序。
2. 在函数内部创建两个变量 `sorted` 和 `exchange`，分别表示数组是否已经完全有序和两个相邻元素是否发生交换。
3. 使用一个循环，首先将 `sorted` 和 `exchange` 初始化为`false`。
4. 使用两个嵌套循环，外层循环控制数组两个部分的排序，内层循环控制每个部分的冒泡排序。
5. 内层循环的初始条件为 `j = i % 2`，其中 `i` 表示当前循环的次数。
当 `i` 为偶数时，`j` 为 0，表示要对偶数部分排序；当`i` 为奇数时，`j` 为 1，表示要对奇数部分排序。
6. 内层循环用于对数组中的一部分进行冒泡排序，如果发生交换，则将 `exchange` 设置为 `true`。
冒泡排序的过程和一般的冒泡排序算法类似。
7. 当内层循环结束后，判断 `exchange` 是否为 `false`，如果是，则说明数组已经完全有序，将 `sorted` 设置为 `true`，并退出外层循环。
8. 最后，在函数末尾添加一个循环，用于输出排序后的数组。
下面是完整的实例代码：```c#include <stdio.h>void swap(int *a, int *b){int temp = *a;*a = *b;*b = temp;}void oddEvenSort(int arr[], int n)int sorted = 0; // 数组是否已经完全有序int exchange = 0; // 两个相邻元素是否发生交换 while (!sorted){sorted = 1;for (int i = 0; i < n - 1; i++){exchange = 0;int j = i % 2;for (; j < n - 1; j += 2){if (arr[j] > arr[j + 1]){swap(&arr[j], &arr[j + 1]);exchange = 1;sorted = 0;}}if (!exchange){break;}}}}int main(){int arr[] = {9, 2, 7, 4, 5, 6, 3, 8, 1};int n = sizeof(arr) / sizeof(arr[0]);oddEvenSort(arr, n);for (int i = 0; i < n; i++){printf("%d ", arr[i]);}return 0;}```以上是奇偶排序算法的详细解析及一个示例代码。
c语言基础算法教学
c语言基础算法教学C语言是一门广泛应用于计算机编程的高级程序设计语言，也是学习其他计算机语言的基础。
在学习C语言的过程中，我们不可避免地会接触到各种基础算法。
本文将以C语言基础算法教学为主题，介绍一些常见的算法及其实现方法。
一、排序算法排序算法是计算机领域中最基础、最常用的算法之一。
常见的排序算法包括冒泡排序、选择排序、插入排序、快速排序、归并排序等。
下面我们以冒泡排序为例进行介绍。
冒泡排序的原理是重复地遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就进行交换。
通过多次遍历，将最大（或最小）的元素逐渐交换到数列的末尾，从而实现排序。
下面是冒泡排序的C语言实现代码：```c#include <stdio.h>void bubbleSort(int array[], int n) {int i, j, temp;for (i = 0; i < n-1; i++) {for (j = 0; j < n-i-1; j++) {if (array[j] > array[j+1]) {temp = array[j];array[j] = array[j+1];array[j+1] = temp;}}}}int main() {int array[] = {64, 34, 25, 12, 22, 11, 90};int n = sizeof(array)/sizeof(array[0]);bubbleSort(array, n);printf("排序后的数组：\n");for (int i = 0; i < n; i++) {printf("%d ", array[i]);}return 0;}```二、查找算法查找算法是在一组数据中寻找特定元素的算法。
常见的查找算法包括线性查找、二分查找、哈希查找等。
下面我们以二分查找为例进二分查找的前提是数据已经有序。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
6.选择排序，n*n的时间复杂度ቤተ መጻሕፍቲ ባይዱ稳定排序，原地排序。选择排序就是冒泡的基本思想，从小的定位，一个一个选择，直到选择结束。他和插入排序是一个相反的过程，插入是确定一个元素的位置，而选择是确定这个位置的元素。他的好处就是每次只选择确定的元素，不会对很多数据进行交换。所以在数据交换量上应该比冒泡小。
4.插入排序：n*n的时间复杂度，稳定排序，原地排序。插入排序是我学的第一个排序，速度还是很快的，特别是在数组已排好了之后，用它的思想来插入一个数据，效率是很高的。因为不用全部排。他的数据交换也很少，只是数据后移，然后放入要插入的数据。（这里不是指调用插入排序，而是用它的思想）。我觉得，在数据大部分都排好了，用插入排序会给你带来很大的方便。数据的移动和交换都很少。
注：这里红色的1,2是前一次比较1 vs 2交换的结构。后面也一样。
大概思路就这样了，奉上源代码：
#include <stdio.h>
#include <stdlib.h>
//冒泡排序, pnData要排序的数据，nLen数据的个数
14.桶排序：n的时间复杂度，稳定排序，非原地排序。主要思路和基数排序一样，也是假设都在一个范围例如概率都在0-1，而且分布还挺均匀，那么我们也是和基数排序一样对一个数把他划分在他指定的区域。然后在连接这些区域就可以了。书上对每个区域使用链表的存储，我认为在寸小区域的时候也会有时间在里面。所以只是理论上的n时间复杂度。这种思路是不错的。呵呵。
16nData[k] = nData[k -1];
17}
18nData[j] = nTemp;//将数据插入到指定位置
19break;
20}
21}
22}
23
24returntrue;
25}
26
27intmain()
28{
29intnData[10] = {4,10,9,8,7,6,5,4,3,2};//创建10个数据，测试
C语言排序方法
学的排序算法有：插入排序，合并排序，冒泡排序，选择排序，希尔排序，堆排序，快速排序，计数排序，基数排序，桶排序（没有实现）。比较一下学习后的心得。
我不是很清楚他们的时间复杂度，也真的不知道他们到底谁快谁慢，因为书上的推导我确实只是小小了解，并没有消化。也没有完全理解他们的精髓，所以又什么错误的还需要高手指点。呵呵。
我们把要排序的数组A = {3,4,2,1}看成一组水泡，<!--[endif]-->就像冒泡一样，轻的在上面，重的在下面，换成数据，就是小的在上面，大的在下面。我们先把最轻的冒出到顶端，然后冒出第二轻的在最轻的下面，接着冒出第三轻的。依次内推。直到所有都冒出来了为止。
3.我们怎么做到把最轻的放在顶端呢？我们从最底下的数据开始冒，如果比他上面的数据小，就交换（冒上去），然后再用第二第下的数据比较(此时他已经是较轻的一个)，如果他比他上面的小，则交换，把小的冒上去。直到比到第一位置，得到的就是最轻的数据咯，这个过程就像是冒泡一样，下面的和上面的比较，小的冒上去。大的沉下来。
15.计数排序，基数排序，桶排序的比较，我觉得他们都很有思想，不过都是在特定情况下才能发挥最大的效果。虽然效率很高，但是用的不会很广泛。他们之间我更喜欢计数排序，来个映射的方式就直接找到了自己的位置，很高明。和基数排序和同排序只是理论上的n时间复杂度，基数排序要确定一个关键字的排序是n复杂度的，桶排序要确定每个区域的排序是n复杂度的。
9.堆排序：n*log(n)的时间复杂度，非稳定排序，原地排序。他的思想是利用的堆这种数据结构，堆可以看成一个完全二叉树，所以在排序中比较的次数可以做到很少。加上他也是原地排序，不需要申请额外的空间，效率也不错。可是他的思想感觉比快速难掌握一些。还有就是在已经排好序的基础上添加一个数据再排序，他的交换次数和比较次数一点都不会减少。虽然堆排序在使用的中没有快速排序广泛，但是他的数据结构和思想真的很不错，而且用它来实现优先队列，效率没得说。堆，还是要好好学习掌握的。
10.希尔排序：n*log(n)的时间复杂度(这里是错误的，应该是n^lamda(1 < lamda < 2), lamda和每次步长选择有关。)，非稳定排序，原地排序。主要思想是分治，不过他的分治和合并排序的分治不一样，他是按步长来分组的，而不是想合并那样左一半右一半。开始步长为整个的长度的一半。分成nLen/2个组，然后每组排序。接个步长减为原来的一半在分组排序，直到步长为1，排序之后希尔排序就完成了。这个思路很好，据说是插入排序的升级版，所以在实现每组排序的时候我故意用了插入排序。我觉得他是一个特别好的排序方法了。他的缺点就是两个数可能比较多次，因为两个数据会多次分不过他们不会出现数据的交换。效率也是很高的。
30InsertionSort(nData, 10);//调用插入排序
31
32for(inti = 0; i < 10; ++i)
33{
34printf("%d ", nData[i]);
35}
36
37printf("\n");
38system("puase");
39return0;
40}
冒泡排序
冒泡排序的主要思路：
8.合并排序：n*log(n)的时间复杂度，稳定排序，非原地排序。他的思想是分治，先分成小的部分，排好部分之后合并，因为我们另外申请的空间，在合并的时候效率是0(n)的。速度很快。貌似他的上限是n*log(n)，所以如果说是比较的次数的话，他比快速排序要少一些。对任意的数组都能有效地在n*log(n)排好序。但是因为他是非原地排序，所以虽然他很快，但是貌似他的人气没有快速排序高。
1.普及一下排序稳定，所谓排序稳定就是指：如果两个数相同，对他们进行的排序结果为他们的相对顺序不变。例如A={1,2,1,2,1}这里排序之后是A = {1,1,1,2,2}稳定就是排序后第一个1就是排序前的第一个1，第二个1就是排序前第二个1，第三个1就是排序前的第三个1。同理2也是一样。这里用颜色标明了。不稳定呢就是他们的顺序不应和开始顺序一致。也就是可能会是A={1,1,1,2,2}这样的结果。
7.插入排序，选择排序，冒泡排序的比较，他们的时间复杂度都是n*n。我觉得他们的效率也是差不多的，我个人喜欢冒泡一些，因为要用它的时候数据多半不多，而且可以提前的返回已经排序好的数组。而其他两个排序就算已经排好了，他也要做全部的扫描。在数据的交换上，冒泡的确比他们都多。呵呵。举例说明插入一个数据在末尾后排序，冒泡只要一次就能搞定，而选择和插入都必须要n*n的复杂度才能搞定。就看你怎么看待咯。
选择排序：我学会了怎么去获得最大值，最小值等方法。只要选择一下，不就可以了。
合并排序：我学会分而治之的方法，而且在合并两个数组的时候很适用。
堆排序：可以用它来实现优先队列，而且他的思想应该给我加了很多内力。
快速排序：本来就用的最多的排序，对我的帮助大的都不知道怎么说好。
希尔排序：也是分治，让我看到了分治的不同，原来还有这种思想的存在。
16.排序算法的最后感悟：黑格尔说过：存在即合理。所以这些排序的算法都是很好的，他确实给了我们思想上的帮助。感谢前人把精华留给了我们。我得到的收获很大，总结一下各自排序的收获：
冒泡：好实现，速度不慢，使用于轻量级的数据排序。
插入排序：也使用于小数据的排序，但是我从他的思想中学到怎么插入一个数据。呵呵，这样就知道在排好的数据里面，不用再排序了，而是直接调用一下插入就可以了。
12.计数排序：n的时间复杂度，稳定排序，非原地排序。他的思想比较新颖，就是先约定数据的范围不是很大，而且数据都是整数(或能定位到整数)的情况，然后直接申请一个空间。把要排序的数组A的元素值与申请空间B的下标对应，然后B中存放该下标元素值的个数，从而直接定位A中每个元素的位置。这样效率只为n。因为比较很特殊，虽然很快，但是用的地方并不多。
计数排序，基数排序，桶排序：特殊情况特殊处理。
插入排序
插入排序主要思想是：把要排序的数字插入到已经排好的数据中。
例如12356是已经排好的序，我们将4插入到他们中，时插入之后也是排好序的。这里显而易见是插入到3的后面。变为123456.实现思路：插入排序就是先是一个有序的数据，然后把要插入的数据插到指定的位置，而排序首先给的就是无序的，我们怎么确定先得到一个有序的数据呢？答案就是：如果只有一个，当然是有序的咯。我们先拿一个出来，他是有序的，然后把数据一个一个插入到其中，那么插入之后是有序的，所以直到最后都是有序的。。结果就出来了！当然在写的时候还是有一个技巧的，不需要开额外的数组，下标从第二个元素开始遍历知道最后一个，然后插入到前面已经有序的数据中。这样就不会浪费空间了。插入排序用处还是很多的，特别是链表中，因为链表是指针存放的，没有数组那么好准确的用下标表示，插入是简单有效的方法。
11.快速排序，堆排序，合并排序，希尔排序的比较，他们的时间复杂的都是n*log(n)，我认为在使用上快速排序最广泛，他原地排序，虽然不稳定，可是很多情况下排序根本就不在意他是否稳定。他的比较次数是比较小的，因为他把数据分成了大和小的两部分。每次都确定了一个数的位置，所以理论上说不会出现两个数比较两次的情况，也是在最后在交换数据，说以数据交换上也很少。合并排序和堆排序也有这些优点，但是合并排序要申请额外的空间。堆排序堆已经排好的数据交换上比快速多。所以目前快速排序用的要广泛的多。还有他很容易掌握和实现。
8{
9intnTemp = nData[i];
10for(intj = 0; j < i; ++j)//对该数，寻找他要插入的位置