shell排序

shell排序算法：
shell排序算法的时间复杂度为o(n2)，本文中的间隔每次除以2，若修改时间间隔，那么就可以得到更加优化的时间代价
shell排序算法基于插入排序的两个性质：
1、小序列性质：插入排序在小序列时的排序时间较短.
2、有序性质：插入序列在有序序列中的时间消耗较少，接近于O(n).
因此可以将较长的序列分割成一些较小的序列进行插入排序，然后再将这些较小的序列合成较大的序列

[cpp]  view plain copy

1. #ifndef SHELLSORT_H  
2. #define SHELLSORT_H  
3. #include <iostream>  
4. using namespace std;  
5. /** 
6. *   交换两个元素的值 
7. */  
8. template<typename T> void swapT( T &lhs,T &rhs )  
9. {  
10.     T temp=lhs;  
11.     lhs=rhs;  
12.     rhs=temp;  
13. }  
14. /** 
15. *   shell排序类 
16. */  
17. template<typename T>  
18. class ShellSort{  
19. public:  
20.     void shellSort( T*,int );  
21.     void insertSort( T*,int,int );  
22.     void printArr( T*,int );  
23. };  
24. /** 
25. *   shell排序中使用的插入排序类 
26. *   shell排序是基于插入排序的 
27. */  
28. template<typename T> void ShellSort<T>::insertSort( T *sortedArr,int arrLength,int delta )  
29. {  
30.     for( int i=delta;i<arrLength;i+=delta )  
31.     {  
32.         for( int j=i;j>=delta;j-=delta )  
33.         {  
34.             if( sortedArr[j-delta]>sortedArr[j] )  
35.             {  
36.                 swapT( sortedArr[j-delta],sortedArr[j] );  
37.             }  
38.         }  
39.     }  
40. }  
41. /** 
42. *   shell排序主函数 
43. *   delta表示要排序数的间隔 
44. *   同时表示要排序的序列数 
45. *   delta从arrLength/2开始到1结束 
46. */  
47. template<typename T> void ShellSort<T>::shellSort( T *sortedArr,int arrLength )  
48. {  
49.     for( int delta=arrLength/2;delta>0;delta/=2 )  
50.         for( int j=0;j<delta;++j )  
51.         {  
52.             this->insertSort( &sortedArr[j],arrLength-j,delta );  
53.               
54.         }  
55. }  
56. template<typename T> void ShellSort<T>::printArr( T *sortedArr,int arrLength )  
57. {  
58.     for( int i=0;i<arrLength;++i )  
59.     {  
60.         cout<<sortedArr[i]<<"  ";  
61.     }  
62. }  
63. #endif  

1. void ShellSort(int *a, int len)  
2. {  
3.     int h = 1;  
4.     while( h<len )   
5.         h = 3*h + 1;  
6.     while( h>0 )  
7.     {  
8.         for (int j=h; j<len; j++)  
9.         {  
10.             int key = a[j];  
11.             int i = j-h;  
12.             while( i>=0 && a[i]>key )  
13.             {  
14.                 a[i+h] = a[i];  
15.                 i = i-h;  
16.             }  
17.             a[i+h] = key;  
18.         }  
19.         h  = h/3;  
20.     }  
21. }  

From:http://blog.youkuaiyun.com/wang11chao01/article/details/7794075

From:http://blog.youkuaiyun.com/left_la/article/details/8656425