#include <stdio.h>
#include <stdlib.h>
typedef int KeyType;
#include"几种排序.h"
void main ()
{
DataType test[10]={43,5,47,1,19,11,59,15,48,41}; int d[]={5,3,1};
int i,n=10;
InsertSort(test,n);
printf("直接插入排序:");
for(i=0;i<n;i++)
printf("%d ",test[i].key);
SelectSort(test,n);
printf("\n");
printf("直接选择排序:");
for(i=0;i<n;i++)
printf("%d ",test[i].key);
BubbleSort(test,n);
printf("\n");
printf("冒泡排序:");
for(i=0;i<n;i++)
printf("%d ",test[i].key);
ShellSort(test,n);
printf("\n");
printf("希尔排序:");
for(i=0;i<n;i++)
printf("%d ",test[i].key);
}
第二篇：数据结构几种常见排序算法的比较与如何排序(例子)
1冒泡排序（Bubble Sort）
冒泡排序方法是最简单的排序方法。这种方法的基本思想是，将待排序的元素看作是竖着排列的“气泡”，较小的元素比较轻，从而要往上浮。在冒泡排序算法中我们要对这个“气泡”序列处理若干遍。所谓一遍处理，就是自底向上检查一遍这个序列，并时刻注意两个相邻的元素的顺序是否正确。如果发现两个相邻元素的顺序不对，即“轻”的元素在下面，就交换它们的位置。显然，处理一遍之后，“最轻”的元素就浮到了最高位置；处理二遍之后，“次轻”的元素就浮到了次高位置。在作第二遍处理时，由于最高位置上的元素已是“最轻”元素，所以不必检查。一般地，第i遍处理时，不必检查第i高位置以上的元素，因为经过前面i-1遍的处理，它们已正确地排好序。
冒泡排序是稳定的。算法时间复杂度是O(n^2)。 就是每进行一轮循环（内循环一次），把最大或最小的值放到最后一个位置即冒出。如 3 2 1 6 5 一轮后：2 1 3 5 6
2选择排序（Selection Sort）
选择排序的基本思想是对待排序的记录序列进行n-1遍的处理，第i遍处理是将L[i..n]中最小者与L[i]交换位置。这样，经过i遍处理之后，前i个记录的位置已经是正确的了。 选择排序是不稳定的。算法复杂度是O(n^2 )
就是扫描整个线性表，从中选则出最小的元素，将它交换到最前面的位置；然后对剩余的子表进行扫描，从中选出最小的元素，将它交换到子表最前面的位置；如此类推，直到做完为止即可。
有数组aaa[5]={1000,100,1,10000,10}
进行第一次交换后为{1，100，1000，10000，10} 1与1000换
进行第二次交换后为{1，10，1000，10000，100} 10与100换
进行第三次交换后为{1，10，100，10000，1000} 100与1000换
进行第四次交换后为{1，10，100，1000，10000} 1000与10000换
交换了5-1次得到结果。这是升序排列。
降序排列也是这种思想，只不过它是选择最大的放在前面。
3插入排序（Insertion Sort）
插入排序的基本思想是，经过i-1遍处理后,L[1..i-1]己排好序。第i遍处理仅将L[i]插入L[1..i-1]的适当位置，使得L[1..i]又是排好序的序列。要达到这个目的，我们可以用顺序比较的方法。首先比较L[i]和L[i-1]，如果L[i-1]≤ L[i]，则L[1..i]已排好序，第i遍处理就结束了；否则交换L[i]与L[i-1]的位置，继续比较L[i-1]和L[i-2]，直到找到某一个位置j(1≤j≤i-1)，使得L[j] ≤L[j+1]时为止。图1演示了对4个元素进行插入排序的过程，共需要(a),(b),(c)三次插入。
直接插入排序是稳定的。算法时间复杂度是O(n^2)
1 5 7 3 1 6
把表分成两部分，前半部分已排序，后半部分未排序，我用|分开
初始为 5 | 1 7 3 1 6
一次插入排序，把第一个1插入前边已排序部分，得
1 5 | 7 3 1 6
后边依次是
1 5 7 | 3 1 6
1 3 5 7 | 1 6
1 1 3 5 7 | 6
1 1 3 5 6 7 |
4堆排序
堆排序是一种树形选择排序，在排序过程中，将A[n]看成是完全二叉树的顺序存储结构，利用完全二叉树中双亲结点和孩子结点之间的内在关系来选择最小的元素。
堆排序是不稳定的。算法时间复杂度O(nlog n)。
18，30，35，10，46，38，5，40进行堆排序（假设堆的根节点为最小关键码），在初始建堆过程中需进行的关键码交换次数是（）？
第一次
30 18 35 10 46 38 5 40
第二次
35 30 18 10 46 38 5 40
第三次
35 30 18 10 46 38 5 40
第四次
46 35 30 18 10 38 5 40
第五次
46 38 35 30 18 10 5 40
第六次
46 38 35 30 18 10 5 40
第七次
46 40 38 35 30 18 10 5 40
5归并排序
设有两个有序（升序）序列存储在同一数组中相邻的位置上，不妨设为A[l..m]，A[m+1..h]，将它们归并为一个有序数列，并存储在A[l..h]。
其时间复杂度无论是在最好情况下还是在最坏情况下均是O(nlog2n)。
｛9,38,65,36,76,13,27,49,11,4｝
先把序列分成5组，并组内排序：{9,38},{36,65},{13,76},{27,49},{4,11}
再将组分成3大组：{9,36,38,65},{13,27,49,76},{4,11}
然后分成2大组：{9,13,27,36,38,49,65,76},{4,11}
最后：{4,9,11,13,27,36,38,49,65,76}
6快速排序
快速排序是对冒泡排序的一种本质改进。它的基本思想是通过一趟扫描后，使得排序序列的
长度能大幅度地减少。在冒泡排序中，一次扫描只能确保最大数值的数移到正确位置，而待排序序列的长度可能只减少1。快速排序通过一趟扫描，就能确保某个数（以它为基准点吧）的左边各数都比它小，右边各数都比它大。然后又用同样的方法处理它左右两边的数，直到基准点的左右只有一个元素为止。
快速排序是不稳定的。最理想情况算法时间复杂度O(nlog2n)，最坏O(n ^2)。 以下上下对应
A[0] 、 A[1]、 A[2]、 A[3]、 A[4]、 A[5]、 A[6]、A[7]：
24 19 32 43 38 6 13 22 初始关键数据KEY=A[0]=24，第一轮排序中一直不变
第一次从后往前搜，A[0]>A[7]，变换，24 22对换,A[0]=22，A[7]=24，KEY=A[7]=24 结果：22 19 32 43 38 6 13 24
第二次从前往后搜，A[1]<A[7]，不变换
A[2]>A[7]，变换，32 24对换，A[2]=24，A[7]=32，KEY=A[2]=24 结果：22 19 24 43 38 6 13 32
第三次从后往前搜，A[2]>A[6],变换，24 13对换，A[2]=13，A[6]=24，KEY=A[6]=24 结果：22 19 13 43 38 6 24 32
第四次从前往后搜，A[3]>A[6]，变换，43 24对换，A[3]=24，A[6]=43，KEY=A[3]=24 结果：22 19 13 24 38 6 43 32
第五次从后往前搜，A[3]>A[5]，变换，24 6对换，A[3]=6，A[5]=24，KEY=A[5]=24 结果：22 19 13 6 38 24 43 32
第六次从后往前搜，A[4]>A[5]，变换，38 24对换，A[4]=24，A[5]=38，KEY=A[4]=24 结果：22 19 13 6 24 38 43 32
即最终排序结果为：22 19 13 6 24 38 43 32
之后对24两边的子集分别按以上方法排序{22 19 13 6} 24 {38 43 32}
7希尔排序
在直接插入排序算法中，每次插入一个数，使有序序列只增加1个节点，并且对插入下一个数没有提供任何帮助。如果比较相隔较远距离（称为增量）的数，使得数移动时能跨过多个元素，则进行一次比较就可能消除多个元素交换。D.L.shell于19xx年在以他名字命名的排序算法中实现了这一思想。算法先将要排序的一组数按某个增量d分成若干组，每组中记录的下标相差d.对每组中全部元素进行排序，然后再用一个较小的增量对它进行，在每组中再进行排序。当增量减到1时，整个要排序的数被分成一组，排序完成。
希尔排序是不稳定的。算法时间复杂度是O(n^2)。
比如，1 5 3 7 18 6 2 9 4 如果d是3，则分组为{1 7 2}{5 18
9}{3 6
4}
d是3,意思就是把位置为1+3*0，1+3*1，1+3*2??放在一起 2+3*0，2+3*1，2+3*2??放在一起
3+3*0，3+3*1，3+3*2??放在一起