几个排序算法及其性能比较

#include <iostream>
#include <ctime>

using namespace std;

template <typename T>
void swap( T arr[], int i, int j )
{
 T temp;
 temp = arr[i];
 arr[i] = arr[j];
 arr[j] = temp;
}

template <typename T>
void selectionSort( T arr[], int n )
{
 int i, j, index;
 T minValue;
 for( i = 0; i < n; i++ )
 {
  minValue = arr[i];
  for( j = i + 1; j < n; j++ )
  {
   if( minValue > arr[j] )
   {
    minValue = arr[j];
    index = j;
   }
  }
  if( minValue != arr[i] )
  {
   swap( arr, i, index );
  }
 }
}

template <typename T>
void insertionSort( T arr[], int n )
{
 int i, j;
 T value;
 for( i = 1; i < n; i++ )
 {
  value = arr[i];
  j = i;
  while( j > 0 && value < arr[j-1] )
  {
   arr[j] = arr[j-1];
   --j;
  }
  arr[j] = value;
 }
}

template <typename T>
void bubbleSort( T arr[], int n )
{
 bool index = true;
 int i;
 while( index == true )
 {
  index = false;
  for( i = 1; i < n; i++ )
  {
   if( arr[i] < arr[i-1] )
   {
    swap( arr, i, i-1 );
    index = true;
   }
  }
  --n;
 }
}

template <typename T>
void exchangeSort( T arr[], int n )
{
 int i, j;
 for( i = 0; i < n-1; i++ )
 {
  for( j = i + 1; j < n; j++ )
  {
   if( arr[i] > arr[j] )
   {
    swap( arr, i, j );
   }
  }
 }
}

//定步长的插入排序（shell排序调用）

template <typename T>
void insertionSort( T arr[], int beg, int end, int k )
{
 int i = beg;
 int j;
 T value;
 while( i < end )
 {
  j = i + k;
  if( j >= end ) return;
  value = arr[j];
  while( j > 0 && j - k >= 0 && value < arr[j-k] )
  {
   arr[j] = arr[j-k];
   j-=k;
  }
  arr[j] = value;
  i += k;
 }
}

template <typename T>
void shellSort( T arr[], int n )
{
 int k, i, j;
 for( k = 1; k <= n/9; k = 3 * k + 1 );
 
 for( i = k; i >= 1; i-- )
 {
  for( j = 0; j < i; j++ )
  {
   insertionSort( arr, j, n, i );
  }
 }
}

//测试后，发现插入 排序的效果最好，选择排序其次，而shell排序的效果也并不是想像中的那么好。

测试结果如下（为长度为50000的整型数组排序结果）

time of selectionSort taken is: 5125
time of insertionSort taken is: 3890
time of bubbleSort taken is: 21625
time of exchangeSort taken is: 17375
time of shellSort taken is: 7734

同时，考虑到排序函数中再次调用函数的影响，在swap函数跟insertionSort（T arr[], int beg, int end, int k ）加上inline，效果如下：

time of selectionSort taken is: 4859
time of insertionSort taken is: 3812
time of bubbleSort taken is: 21282
time of exchangeSort taken is: 17344
time of shellSort taken is: 7891

两者用的时间差不多，看来函数的调用对排序的结果影响不是很大。

如果开始就有序的情况下（最好情况），测试结果如下：

time of selectionSort taken is: 4609
time of insertionSort taken is: 0
time of bubbleSort taken is: 0
time of exchangeSort taken is: 5687
time of shellSort taken is: 6672

开始逆序的情况下（最坏情况）：

time of selectionSort taken is: 5687
time of insertionSort taken is: 7469
time of bubbleSort taken is: 21250
time of exchangeSort taken is: 20469
time of shellSort taken is: 6671

 另外，冒泡排序跟交换排序，由于涉及到更多的数组元素的交换，故花去了较多的时间。在最好情况下，插入排序跟冒泡排序的时间复杂度为O(1),而插入排序的逆序效果确实很差o(n^2).

疑问：为什么书上推崇的shell排序效果会这么差（shell排序的时间复杂度为O(n^1.5),而选择跟插入排序的时间复杂度都为O(n^2)）。比较了最坏情况跟最好情况，难道是shell排序的稳定性最好？