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 " ; } 图示：
before_compare|one_turn|two_turn|three_turn|four_turn|five_turn|six_turn10 10 10 10 10 10 49 9 9 9 9 4 108 8 8 8 4 9 97 7 7 4 8 8 86 6 4 7 7 7 75 4 6 6 6 6 64 5 5 5 5 5 5通过上图可以看出，冒泡法形象的描述来，4这个元素就像一个气泡逐渐冒到上面来了。我们排序的有7个元素，最坏的情况全部倒序，4这个元素要冒上来需要6次。因此，n个元素，最坏的情况，需要移动：1+2+3+ ...+(n-1)=1/2*n(n-1)次。
倒序(最糟情况) 第一轮： 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 )。乱序时处于中间状态。正是由于这样的原因，我们通常都是通过循环次数来对比算法。
从上面的算法来看，基本和冒泡法的效率一样。 倒序(最糟情况) 第一轮： 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)。由于我们无法给出所有的情况，所以只能直接告诉大家他们在交换上面也是一样的糟糕（在某些情况下稍好，在某些情况下稍差）。before_compare|one_turn|two_turn|three_turn|four_turn|five_turn|six_turn10 9 8 7 6 5 49 10 10 10 10 10 108 8 9 9 9 9 97 7 7 8 8 8 86 6 6 6 7 7 75 5 5 5 5 6 64 4 4 4 4 4 5
由上面可以看到选择排序法并没有在一开始就交换数据，而是用第一个数据去和所有的数据比较，如果第一个数据小于第二个数据，那么，先把第二个数据放到一个临时变量里面，同时记录这个较小的数据在待排序的集合中的位置。再用该集合中的下一个数据和我们之前放在临时变量中的数据比较。也就是我们目前认为最小的数据比较，如果比我们之前选出来的数据小，那么再替换该变量。如果比这个数据大，则继续用下一个数据来比较。知道所有的数据都比较完为止。到这时，临时变量里面访的就是最小的数据了。我们把这个数据和第一个数据做对换。此时，最小的元素排到了第一位。
倒序(最糟情况) 第一轮： 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)。所以，在数据较乱的时候，可以减少一定的交换次数。
插入排序 #include < iostream > using namespace std; void coutstream( int a[], int n){ for ( int i = 0 ;i != n;i ++ ) cout << a[i] << " " ; } void insertsort( int a[], int n){ int temp; for ( int i = 1 ;i < n;i ++ ) { int j = i; temp = a[i]; // 先把a[i]位置的数据存起来 while (j > 0 && temp < a[j - 1 ]) { a[j] = a[j - 1 ]; j -- ; } a[j] = temp; } } int main() { int a[ 5 ] = { 1 , 6 , 4 , 8 , 4 }; insertsort(a, 5 ); // 插入排序 coutstream(a, 5 ); // return 0 ; }
2 .SHELL排序 这个排序非常复杂，看了程序就知道了。 首先需要一个递减的步长，这里我们使用的是9、 5 、 3 、 1 （最后的步长必须是1）。 工作原理是首先对相隔9 - 1个元素的所有内容排序，然后再使用同样的方法对相隔5 - 1个元素的排序以次类推。 #include < iostream.h > void ShellSort( int * pData, int Count) { int step[ 4 ]; step[ 0 ] = 9 ; step[ 1 ] = 5 ; step[ 2 ] = 3 ; step[ 3 ] = 1 ; int iTemp; int k,s,w; for ( int i = 0 ;i < 4 ;i ++ ) { k = step[i]; s = - k; for ( int j = k;j < Count;j ++ ) { iTemp = pData[j]; w = j - k; // 求上step个元素的下标 if (s == 0 ) { s = - k; s ++ ; pData[s] = iTemp; } while ((iTemp < pData[w]) && (w >= 0 ) && (w <= Count)) { pData[w + k] = pData[w]; w = w - k; } pData[w + k] = iTemp; } } } void main() { int data[] = { 10 , 9 , 8 , 7 , 6 , 5 , 4 , 3 , 2 , 1 , - 10 , - 1 }; ShellSort(data, 12 ); for ( int i = 0 ;i < 12 ;i ++ ) cout << data[i] << " " ; cout << " /n " ; } 呵呵，程序看起来有些头疼。不过也不是很难，把s == 0的块去掉就轻松多了，这里是避免使用0步长造成程序异常而写的代码。这个代码我认为很值得一看。这个算法的得名是因为其发明者的名字D.L.SHELL。依照参考资料上的说法：“由于复杂的数学原因避免使用2的幂次步长，它能降低算法效率。”另外算法的复杂度为n的1.2次幂。同样因为非常复杂并“超出本书讨论范围”的原因（我也不知道过程），我们只有结果了
shell排序的思想是根据步长由长到短分组，进行排序，直到步长为1为止，属于插入排序的一种。下面用个例子更好的理解一下
无序数列： 32， 43，56，99，34，8，54，76
1.首先设定gap=n/2=4于是分组
32，34 排序 32，34
43， 8 8， 43
56，54 54，56
99，76 76，99
数列变成 32，8，54，76，34，43，56，99
2.gap=gap/2=2 于是分组
32，54，34，56 排序 32，34，54，56
8，76，43，99 8，43，76，99
于是数列变成 32，8，34，43，54，76，56，99
3.gap=gap/2=1于是分组
32，8，34，43，54，76，56，99 排序
8，32，34，43，54，56，76，99
gap=1结束……
相应的C语言代码引用K＆R C程序设计一书中给出的代码
void shellsort(int v[], int n)
{
int gap, i, j, temp;
for(gap=n/2;gap>0;gap/=2) //设定步长
for(i=gap;i <n;++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;
}
}
最低0.47元/天 解锁文章
09-13
41
41
03-29
2289
2289
06-10
1万+
1万+
“相关推荐”对你有帮助么？
-
非常没帮助 -
没帮助 -
一般 -
有帮助 -
非常有帮助
提交
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
