排序的之插入排序

转载

mob604756fbd94e 2011-11-19 19:40:00

文章标签 时间复杂度空间复杂度插入排序算法实现直接插入排序 文章分类 数据结构与算法人工智能

一、插入排序的主要分类：

1、直接插入排序；

2、折半插入排序；

3、2-路插入排序；

4、希尔排序(缩小增量排序)。

二、直接插入排序（简便，容易实现）：

1、排序过程：整个排序过程为n-1趟插入，即先将序列中第1个元素看成是一个有序子序列，然后从第2个元素开始，逐个进行插入，直至整个序列有序。

2、算法实现：

void InsertSort(int a[], int len)
{
  for (int i = 1; i < len; ++i)
  {
    int temp = a[i]; //先把将要插入的元素保存
    int j = i;
    while (j > 0 && temp < a[j - 1])//通过while循环找出应该插入的位置
    {
      a[j] = a[j - 1]; //后移
      --j; 
    }
    a[j] = temp;
  }
}

3、算法评价：

(1) 时间复杂度

——若待排序元素按关键字从小到大排列(正序)

关键字比较次数：n-1

元素移动次数：0

——若待排序元素按关键字从大到小排列(逆序)

关键字比较次数：n*(n-1)/2 注意：上面算法并没设置哨兵，若有设置，则比较次数应为(n+2)(n-1)/2

元素移动次数：n*(n-1)/2 注意：上面算法并没设置哨兵，若有设置，则移动次数应为(n+4)(n-1)/2

——若待排序元素是随机的，取平均值

关键字比较次数：(n+2)(n-1)/4

元素移动次数：n*(n-1)/4

故时间复杂度为：T(n)=O(n²)

(2)空间复杂度：S(n)=O(1)

4、适应范围：当序列中元素的个数n很少时。

三、折半插入排序（减少了元素的比较次数）：

1、排序过程：用折半查找方法确定插入位置。

2、算法实现：

void binsort(int a[], int len)
{
  for (int i = 1; i < len; ++i)
  {
    int temp = a[i];
    int low = 0;
    int high = i - 1; //a[0]至a[i-1]的已经排序好了。
    //执行while循环（折半查找）找出a[i]应该插入的位置
    while (low <= high)
    {
      int middle = (low + high) / 2;
      if (temp < a[middle])
        high = middle - 1;
      else
        low = middle + 1;
    }
    //a[low]至a[i-1]的元素移动到a[low+1]至a[i];
    for (int j = i; j > low; --j)
    {
      a[j] = a[j - 1];
    }
    a[low] = temp;//a[low]放置插入的元素
  }
}

3、算法评价：

(1) 时间复杂度：

折半插入排序减少了关键字比较的次数，而元素的移动次数不变，故时间复杂度仍然为：T(n)=O(n²)

(2)空间复杂度：S(n)=O(1)

4、适应范围：当序列中元素的个数n很大时。

四、2-路插入排序（减少了元素的移动次数，但是增加了空间复杂度）：

1、排序过程：引进一个空序列b。把原序列中的第一个元素a[0]看成是处于排好后的序列的中间。大于a[0]的元素放于a[0]值前的有序序列中，反之，放于其后。

如下图例子：

2、算法实现：

void TowRsort(int a[], int len)
{
  int *b = new int[len];
  int current = len; //数组b后面序列中下标最小的一个
  b[0] = a[0];//在b数组中放置第一个元素
  int k = 0;
  for (int i = 1; i < len; ++i){
    if (a[i] >= b[0]){
      int k1 = k;
      //找出应该插入的位置
      while (a[i] < b[k1]){

        b[k1 + 1] = b[k1];
        --k1;
      }
      b[k1 + 1] = a[i];
      ++k;
    } else{
      if (current == len)//放置第一个在数组最后
        b[--current] = a[i];
      else{
        int tempCurrent = current;
        //找出应该插入的位置
        while (b[tempCurrent] < a[i] && tempCurrent < len){
          b[tempCurrent - 1] = b[tempCurrent];
          ++tempCurrent;
        }
        b[tempCurrent - 1] = a[i];
        --current;
      }
    }
  }
  int j = 0;
  for (int i = current; i < len; ++i, ++j){
    a[j] = b[i];
  }
  for (int i = 0; i < current; ++i, ++j){
    a[j] = b[i];
  }
}

3、算法评价：

(1) 时间复杂度：时间复杂度仍然为：T(n)=O(n²)。(然而元素的移动次数约n*n/8)

(2)空间复杂度：S(n)=O(n)。

五、希尔插入排序(缩小增量法)（减少了元素的比较次数）：

1、排序过程：分割成若干个较小的子文件，对各个子文件分别进行直接插入排序，当文件达到基本有序时，再对整个文件进行一次直接插入排序。

如下图例子：

2、算法实现：

void shellSort(int a[],const int& len){//希尔排序
  int b[] = {5,3,1};//增量序列
  int count = sizeof(b)/sizeof(int);
  for(int i = 0; i < count; ++i){
    for(int j = 0; j < len - b[i]; ++j){
      if(a[j] > a[j+b[i]]){
        swap(a[j],a[j+b[i]]);//交换a[j]和a[j+b[i]]的值
        int temp = j;
        while(temp >= b[i]){//向前想间隔b[i]的比较
          if(a[temp] < a[temp-b[i]]){
            swap(a[temp],a[temp-b[i]]);//交换
          }
          else//只要有一个不满足，就跳出
            break;
          temp -= b[i];//向前退
        }
      }
    }
  }
}