1、各种排序算法的比较课程：算法与数据结构 班级 06409 本科 2008 年 1 月 4 日章节名称 内部排序的比较试验目的 通过对算法的比较加深各种内部排序算法的理解试验对象 冒泡排序，插入排序，选择排序，希尔排序，快速排序，堆排序等。教学过程（课堂组织、教学方法）当随机生成的排序数为 10000 时：(S)Insertsort：0.216917，0.222332, 0.225159Selectsort:0.330911，0.324383, 0.334553Bubblesort:0.763702, 0.7741, 0.784554Shellsort:0.00375746，0.00352894
2、, 0.00356638Heapsort:0.00662012,0.00660307,0.00708917Introsort:0.00187314,0.00272437,0.00193824Quicksort:0.0032398,0.00231203,0.00244472当随机生成的排序数为 100000 时：(S)Insertsort：21.8143Selectsort:33.3739Bubblesort:79.5382Shellsort:0.0582314Heapsort:0.08873618Introsort:0.00201115Quicksort:0.0243824当随机生成的排序数为
3、 1000000 时：(S)Insertsort：需要时间很长Selectsort: 需要时间很长Bubblesort: 需要时间很长Shellsort: 需要时间很长Heapsort:1.24989Introsort:0.250119Quicksort:0.24519。 。 。 。 。 。 。 。 。 。 。 。 。 。 。结论 简单的排序算法在大量数据的排序时显得非常没效率，快速排序在数据量大时优势比较明显，体现了算法在效率上的重要性冒泡排序p1, p2, pn 是 1, 2, , n 的一个排列。如果 j pk 则称（p j, pk）为一个逆序。原理依次比较相邻的两个元素的大小，如果是逆
4、序则交换他们的位置。这样小的元素就会像水泡一样向上漂浮。最大的一个元素会沉到最底下。0 50 40 40 40 401 40 50 20 20 202 20 20 50 30 303 30 30 30 50 104 10 10 10 10 500 40 20 20 201 20 40 30 302 30 30 40 103 10 10 10 404 50 50 50 50时间复杂度 O(n2)元素的比较次数和元素的交换次数。最佳， 最差， 平均。C 最佳 = C 最差 = 1 + 2 + + n-1 = n(n-1)/2S 最佳 = 0；S 最差 = n(n-1)/2 (比较一次就交换一次)
5、由于是相邻的两个元素交换，每交换一次只能减少一个逆序对。定理：n 个不同元素的平均逆序对为 n(n-1)/4 个。p1, p2, pn 中序对的个数为 n(n-1)/2。每个序对要么是正序对，要么是逆序对。考虑排列 p1, p2, pn 和它的逆排列 pn, pn-1, , p1. 在一个排列中为正序对，在另外一个排列中就是逆序对。所以在这两个排列中共有n(n-1)/2 个逆序对。平均一个排列就有 n(n-1)/4 个逆序对。S 平均 = n(n-1)/4程序/*bubble sort*/templatevoid bubblesort(Fitr first, Fitr last)Fitr pr
6、ev;Fitr cur;for(; first != last; last = prev)prev = cur = first;for(+cur; cur != last; prev = cur, +cur)if(*cur void guarded_linear_insert(Bitr first, Bitr last) std:iterator_traits:value_type value = *last;Bitr pre = last ;-pre;while(value void insertsort1(Bitr first, Bitr last)if(first = last)retu
7、rn;Bitr i = first;for( +i; i != last; +i)guarded_linear_insert(first, i);/*precondition:1.)first, last) is not empty and is already sorted,2.) !(*last void unguarded_linear_insert(Bitr last)std:iterator_traits:value_type value = *last;Bitr prev = last;for(-prev; value void linear_insert(Bitr first,
8、Bitr last) if(*last :value_type value = *last;std:copy_backward(first, last, last + 1);*first = value;elseunguarded_linear_insert(last);/linear_insert()/*/templatevoid insertsort(Bitr first, Bitr last)if(first = last) return;Bitr i = first;for(+i; i != last; +i)linear_insert(first, i);算法是稳定的。而且是最自然的
9、排序算法。即当要排序的元素已经排序时，算法最快。当要排序的元素是逆序时算法最慢。选择排序待排序的区间为first, last) 。在其中选择最小的元素放置在*first 处。在去处理区间first+1， last)0 1 2 3 450 40 20 30 1010 40 20 30 5010 20 40 30 5010 30 30 40 5010 20 30 40 50时间复杂度 O(n2)C = n-1 + . + 1 = n(n-1)/2S = n 1程序/*void min_first(Fitr first, Fitr last); preconditions:1.) first las
10、t) is not empty!2.) Fitr: Forward iterator.postcondition:find the minimum element and set it at first.*/templateinline void min_first(Fitr first, Fitr last) Fitr min = first;Fitr i = first;for(+i; i != last; +i)if(*i void selectsort(Fitr first, Fitr last)for( ; first != last; +first)min_first(first,
11、 last);算法是稳定的。shell 排序原始想法0 d 2d 3d81 94 11 96 12 35 17 95 28 58 41 75 154 12 35 11 75 15 58 17 95 28 94 41 96 812 11 35 12 58 15 75 17 95 28 94 41 96 811 11 12 15 17 28 35 41 58 75 81 94 95 96性能分析增量序列： (n) ht,ht-1,.h1. h1 = 1Shell 增量序列： n/2, n/4, n/8,.1 Hibbard 增量序列：2 k-1, .,7, 3,1. hk+1 = 2hk + 1P
12、ratt 增量序列：.,6,4,3,2,12p3q (5p11q, 7p13q)Sedgewick 增量序列： .,209, 109, 41,19,5,19*4k 9*2k + 1 或者 4k 3*2k + 1 3h+1 增量序列：.,121, 40,13,4,1hk+1 = 3hk + 1复杂度Shell 增量序列：O(n 2)Hilbbard 增量序列：O(n 3/2)Pratt 增量序列：O(n(logn) 2)Sedgewick 增量序列：统计性能最好。3h+1 增量序列：当 n 较小（ void shellsort(Ritr a, int n)for(int gap = 1; (ga
13、p *= 3) = 0; j -= gap)if(aj+gap void shellsort(T* a, int n)for(int gap = 1; (gap *= 3) = 0; j -= gap)if(aj+gap = a2k, ak = a2k+10 1 2 3 4 5 6 7 8 9 1098 53 59 26 41 58 31插入：shiftup/*void shiftup(Ritr a, int n)insert an element to the heapprecondition:a1n) is a heappostcondition:a1n is a heap*/templa
14、tevoidshiftup(Ritr a, int n)int i = n/2;while(i 0 bc voidheap_sort(Ritr a, int n)-a;/ make a1, n heapfor(int i = n/2; i 0; -i)shift_down(a, i, n);for(i = n; i 1; -i)std:swap(a1, ai);shift_down(a, 1, i - 1);/heap_sort(T*a, int n)堆排序时间复杂度 O(nlogn)HT = iT height(i)H(n+1) = H(n) + od(n) = H(n) + ed(n+1)
15、b(n+1) = b(n) od(n) + 1H(n) = n b(n)建立一个具有 n 个元素的堆所需的比较次数最多为 2H(n)Stirlings formular: N! = (N/e)N(2N)1/2建立堆后的排序的工作量：2(log2(n-1) + log2 (n-2) + . + log21)= 2 log2 (n-1)! = NlogN O(N)C 平均 = 2NlogN O(NloglogN)使用描述复杂度的理论：C 平均 = 2NlogN O(N)移动次数（平均）M 平均 = NlogN + O(N)快速排序算法pivot = p=ptemplatevoid qsort(Ri
16、tr first, Ritr last)if(first = last | first + 1 = last)return;Ritr mid = partition(first, last);qsort(first, mid);qsort(mid, last);快速排序算法的性能分析：50，40，20，30，10每一个算法的运行对应一个扩充二叉树。15，25，35，45 作为 pivot。对应的扩充二叉树。对划分的要求：两个子区间不能为空。解决的办法：1.)在first, last) 中选取一个元素作为pivot。2.)在程序中适当控制。选取*first 作为 pivot。划分算法：/*Rit
17、r partition(Ritr first, Ritr last)*first as the pivotprecondition:last - first 1;return value: midpostcondition:1.)first mid) Ritrpartition(Ritr first, Ritr last) Ritr const ppivot = first;std:iterator_traits:value_type constpivot = *ppivot;for(;)while(first Bitrpartition(Bitr first, Bitr last) Bitr
18、 ppivot = first;while(true)while(*ppivot void qsort(Bitr first, Bitr last)if(first = last)return;Bitr ppivot = partition(first, last);qsort(first, ppivot);qsort(+ppivot, last);/qsort(Bitr first, Bitr last)templatevoid qsort2(Bitr first, Bitr last)while(first != last)Bitr ppivot = partition(first, la
19、st);qsort2(first, ppivot);first = +ppivot;/qsort2(Bitr first, Bitr last)templatevoid qsort3(Ritr first, Ritr last)while(first != last)Ritr ppivot = partition(first, last);if(ppivot - first last - ppivot) /short longqsort3(first, ppivot);first = +ppivot;else /long shortqsort3(+ppivot, last);last = ppivot;/while/qsort3(Ritr first, Ritr last)
