插入排序，二分插入排序，希尔排序思想与比较

转自：http://www.cnblogs.com/GavinDai/archive/2011/12/02/2271998.html

直接插入排序的基本方法：每步将一个待排序的元素，按其排序码的大小，插入到前面已经排好序的一组元素的适当位置上去，直到元素全部插入为止。

插入排序（insert sorting)思想：当插入第i个元素时，前面的v[0],v[1],v[2]......v[i-1],已经排好序了.这时用v[i]的插入码与v[i-1],v[i-2],......排序码进行比较，找到插入的位置即插入v[i],原来位置上的元素从后向前依次后移。

时间复杂度:  平均比较次数O(n²),平均移动次数 O(n²).

直接插入排序是一种稳定的排序。元素大部分有序时效率会更高，这时比较次数和移动次数都会减少。

参考代码：　

void Sort<T>::insertSort(DataList<T> &datalist, int n)
{
　　if ( -1 == n)
　　{
　　　　for (int i = 1; i < datalist.m_nCurrentSize; i++)
　　　　{
　　　　　　insertSort(datalist, i);
　　　　}
　　　　return;
　　}
　　Element<T> temp = datalist.m_pvector[n];
　　int j;
　　for ( j = n; j > 0; j--)
　　{
　　　　if (temp > datalist.m_pvector[j-1])
　　　　{
　　　　　　break;
　　　　}else
　　　　{
　　　　　　datalist.m_pvector[j] = datalist.m_pvector[j-1];
　　　　}
　　}
　　datalist.m_pvector[j] = temp;
}

二分（折半）插入（Binary insert sort)排序基本思想：设在数据表中有一个元素序列v[0],v[1],v[2]......v[n].其中v[0],v[1],v[2]......v[i-1]是已经排好序的元素。在插入v[i]。利用折半搜索寻找v[i]的插入位置。

二分插入排序是一种稳定的排序。当n较大时，总排序码比较次数比直接插入排序的最差情况好得多，但比最好情况要差，所元素初始序列已经按排序码接近有序时，直接插入排序比二分插入排序比较次数少。二分插入排序元素移动次数与直接插入排序相同，依赖于元素初始序列。

参考代码：

template <class T>
void Sort<T>::binaryInsert(DataList<T> &datalist, int n)
{
　　if (-1 == n)
　　{
　　　　for (int i = 1; i < datalist.m_nCurrentSize; i++)
　　　　{
　　　　　　binaryInsert(datalist, i);
　　　　}
　　　　return;
　　}
　　Element<T> temp = datalist.m_pvector[n];
　　int left = 0, right = n - 1;　　
　　while(left <= right)
　　{
　　　　int middle = (left + right) / 2;
　　　　if (temp > datalist.m_pvector[middle])
　　　　{
　　　　　　left = middle + 1;
　　　　}else
　　　　{
　　　　　　right = middle - 1;
　　　　}
　　}
　　for (int j = n - 1; j >= left; j--)
　　{
　　　　datalist.m_pvector[j+1] = datalist.m_pvector[j];
　　}
　　datalist.m_pvector[left] = temp;
}

希尔排序（Shell sort）基本思想: 改进的直接插入算法。设待排序的元素序列有n个元素，首先取一整数gap（<n）作为间隔，将全部元素分为gap个子序列，所有距离为gap的元素放在同一序列中，在每个子序列中分别进行直接插入排序。然后缩小gap，例如gap=gap/2,重复上述的子序列划分与排序工作。开始由于gap取直大，每个子序列元素少，排序速度快，待排序后期，gap值逐渐变小，子序列元素变多，但由于前面的工作基础，大多数元素已经有序，所以排序速度快。

希尔排序是一种不稳定的排序。

参考代码：

void swap(int *a, int *b)
{
　　int x;
　　x = *a;
　　*a = *b;
　　*b = x;
}

void insertion_sort(int data[], int n, int increment)
{　　
　　int i, j;
　　for (i = increment; i < n; i += increment)
　　{
　　　　for (j = i; j >= increment && data[j] < data[j-increment]; j -= increment)
　　　　{
　　　　　　swap(&data[j], &data[j-increment]); 
　　　　}
　　}
}

void shellsort(int data[], int n)
{
　　int i, j;
　　for (i = n / 2; i > 0; i /= 2)
　　{
　　　　for (j = 0; j < i; j++)
　　　　{
　　　　　　insertion_sort(data, n, i);
　　　　}
　　}
}

 

另一种参考代码：

template <class T>
void Sort<T>::shellSort(DataList<T> &datalist, int gap /* = -1 */)
{
　　if (-1 == gap)
　　{
　　　　int gap = datalist.m_nCurrentSize / 2;
　　　　while(gap)
　　　　{
　　　　　　shellSort(datalist, gap);
　　　　　　gap = gap / 2;
　　　　}
　　　　return;
　　}
　　for (int i = gap; i < datalist.m_nCurrentSize; i++)
　　{
　　　　insert(datalist, i, gap);
　　}
}

template <class T>
void Sort<T>::insert(DataList<T> &dataList, int n, int gap)
{
for (int i = n; i >= gap; i -= gap)
{
if (dataList.m_pvector[i] < dataList.m_pvector[i-gap])
{
Element<T> temp = dataList.m_pvector[i];
dataList.m_pvector[i] = dataList.m_pvector[i-1];
dataList.m_pvector[i-1] = temp;
}
}
}

总结：以上三种排序方法的核心都是直接插入排序，直接插入排序对于大部分有序的序列排序时速度快。二分插入排序在直接插入的基本上改变了查找元素插入位置的方法，对于完全无序的序列来说，速度会变快，但是对开大部分有序的序列反而会更慢，希尔排序则利用直接插入排序对于大部分有序的序列速度快的特点，先让大部分序列有序，以此来提高排序效率。

追求永不止步