排序总结:插入(简单和改进)、希尔、选择、冒泡、快速、堆排序、归并排序

原创 2015年07月08日 23:05:25

插入:基础的、改进的、希尔
选择:基础的、堆排序
交换:冒泡、快排及其改进
归并:将两个已经排好序的文件归并成一个有序的大文件(比较适合链表)

typedef int Item;
#define key(A) (A)
#define eq(A,B) (key(A) == key(B))
#define less(A,B) (key(A) < key(B))
#define exch(A,B) {Item t = A;A = B; B =t;}
#define compexch(A,B) if(less(B,A)) exch(A,B)
#define min(A,B) A < B ? A : B
//基础的插入排序
void simpleinsertsort(Item a[],int l,int r)
{
    int i,j;
    for(i = l+1;i <= r;i++)
        for(j = i;j > l;j--)
        compexch(a[j-1],a[j]);  //从i处往前对比,把小的移到前面!
}

//改进的插入排序
void insertsort(Item a[],int l,int r)
{
     int i,j;
     Item v;
     for(i = r;i > l;i--)
        compexch(a[i-1],a[i]);  //将最小值放在首位
     for(i = l+2;i <= r;i++)
     {
         j = i;
         v = a[i];
         while(less(v,a[j-1]))  //与当前索引值比较,比v大就将其右移,否则退出,
         {
             a[j] = a[j-1];      //只是赋值,并不交换
             j--;
         }
         a[j] = v;            //此时j+1与i之间的数都是比v大的,将v插入在j
     }
}
//希尔排序
void shellsort(Item a[],int l,int r)  //对步长的选择很重要(h要取到1)
{
      int h,i,j;
      for(h = 1;h <= (r-l)/7;h = 3*h+1);  //创建一个步长序列,最终h要取到1
      for(;h > 0;h = h/3)               //对每一个步长都要进行一次扫描排序
       for(i = l+h;i <= r;i++)         //从l+h开始:因为后面有对j-h的比较,
      {
          j = i;
          Item v = a[j];
          while(j-h >= l && less(v,a[j-h])) //这一循环与insertsort的思想一样
            {
                a[j] = a[j-h];          //只不过insert是h=1,这里的步长h可变
                j = j-h;
            }
            a[j] = v;
      }
}

//选择排序
void selectsort(Item a[],int l,int r)
{
    int i,j,Min;
    for(i = l;i < r;i++)               //当前索引左边的元素都是排好序的(最终位置)
    {
        Min = i;
        for(j = i+1;j <= r;j++)      //从左到右,记录最小元素下标,
            if(less(a[j], a[Min]))
             Min = j;
        exch(a[i],a[Min]);           //将最小元素交换到相应位置
    }
}
//堆排序
void fixDown(Item *pq,int k,int N)   //自顶向下堆化
{
    int j;
    while(2*k <= N)
    {
        j = 2*k;
        if(j < N && less(pq[j],pq[j+1]))  //找到子节点中的较大值
           j++;
        if(!less(pq[k],pq[j]))           //若较大值小于父节点就结束,否则交换子父节点
            break;
        exch(pq[k],pq[j]);
        k = j;
    }
}

void heapsort(Item a[],int l,int r)
{
    Item *pq = a;
    int k,N = r-l;
    for(k = N/2;k >= l;k--)  //将最大值交换到数组首位
        fixDown(pq,k,N);
    show(a,l,r);
    while(N > 0)
    {
        exch(pq[0],pq[N]);   //每次将首位元素(剩余数组元素中最大值)与最后的元素交换
        fixDown(pq,0,--N);   //接着数组大小-1,将剩余元素堆化,接着下一轮循环
    }
}
//冒泡排序
void bubblesort(Item a[],int l,int r) //遍历文件,依次比较相邻元素,将最小值排到前面
{
     int i,j;
     for(i = l;i < r;i++)
        for(j = r;j > i;j--)  //for(j = l+1;j <= i;j++)也可以用前面的循环
        compexch(a[j-1],a[j]);
}
//快速排序中的划分函数
int qpartition(Item a[],int l,int r)
{
    Item v = a[r];
    int i,j;
    i = l;
    j = r-1;
    for(;;)
    {
        while(less(a[i],v))  //左扫描,划分元素v左边不大于v
            i++;
        while(less(v,a[j]))  //右扫描,划分元素v右边不小于v
            {
                j--;
                if(j == l)
                    break;
            }
        if(j <= i)
            break;
        exch(a[i],a[j]);   //左扫描大于v的元素与右扫描小于v的元素交换
    }
    exch(a[r],a[i]);   //划分结束,将划分元素置换到结束位置
    return i;
}
//基本的快排:
void quicksort(Item a[],int l,int r)
{
    int i;
    if(r < l)
        return;
    i = qpartition(a,l,r);
    quicksort(a,l,i-1);
    quicksort(a,i+1,r);
}
//三路取中快排:取待排序列的首、中、尾三个元素,取大小居中的作为划分元素
void quicksortMid(Item a[],int l,int r)
{
    if(r-l <= 3)
       {
            simpleinsertsort(a,l,r);  //当数组小于某一大小时,就采用插入操作
            return;
       }
    exch(a[(l+r)/2],a[r-1]);
    compexch(a[l],a[r-1]);
    compexch(a[l],a[r]);
    compexch(a[r-1],a[r]);  //将三者中的中间元素放于r-1处,v=a[r-1]
    int i = qpartition(a,l+1,r-1); //v=a[r-1]
    quicksortMid(a,l,i-1);
    quicksortMid(a,i+1,r);
}
//三路划分快排:将待排序列分为三路:小于v、等于v、大于v
void quicksortDiv(Item a[],int l,int r)
{
     if(r <= l)
        return;
     int i,j,p,q;
     Item v = a[r];
     i = l;
     j = r;
     p = l;
     q = r-1;
     for(;;)
     {
         while(less(a[i],v)) i++;
         while(less(v,a[--j]))
            if(j == l)
              break;
            if(j <= i)
                break;
        exch(a[i],a[j]);
        if(eq(a[i],v))
            {
                exch(a[p],a[i]);   //需要对数组下标进行自加或自减时,最好与数组元素的引用分开
                p++;               //就如左边两句:先交换,然后再自加得到下一元素的下标!否则,有可能交换到相邻位置
            }
        if(eq(a[j],v))
            {
                exch(a[q],a[j]);
                q--;
            }
     }
     exch(a[i],a[r]);   //这里a[r]不能用v代替,否则a[i]处存的是v,但是a[r]处没变
     j = i-1;
     i = i+1;
     while(p > l)
        {
            p--;
            exch(a[p],a[j]);
            j--;
        }
     while(q < r-1)
        {
            q++;
            exch(a[i],a[q]);
            i++;
        }
     quicksortDiv(a,l,j);
     quicksortDiv(a,i,r);
}
//利用快排里的划分函数来寻找序列中第k个最小元素(非递归的形式、递归的调试未成功,成功后再上传)
int selectsortPar2(Item a[],int l,int r,int k)
{
   int i;
    while(r > l)
    {
       i = qpartition(a,l,r);
       if(i < k)
        l = i+1;
       if(i > k)
        r = i-1;
       if(i == k)
        break;
    }
    return a[i];
}
//归并排序:会用到大量的额外空间,如果两个待归并序列并不有序,可以先排序,再将其进行归并
void mergesort(Item c[],Item a[],int N,Item b[],int M)
{
    int i,j,k;
    for(i = 0,j = 0,k = 0;k < N+M;k++)
    {
        if(i == N)
        {
            c[k] = b[j];
            j++;
            continue;
        }
        if(j == M)
        {
            c[k] = a[i];
            i++;
            continue;
        }
        if(a[i] < b[j])
        {
            c[k] = a[i];
            i++;
        }
        else if(a[i] >= b[j])
        {
            c[k] = b[j];
            j++;
        }
    }
}

相关文章推荐

七大内部排序算法总结(插入排序、希尔排序、冒泡排序、简单选择排序、快速排序、归并排序、堆排序)

写在前面:                  排序是计算机程序设计中的一种重要操作,它的功能是将一个数据元素的任意序列,重新排列成一个按关键字有序的序列。因此排序掌握各种排序算法非常重要。...

七大内部排序算法总结(插入排序、希尔排序、冒泡排序、简单选择排序、快速排序、归并排序、堆排序)

写在前面:                  排序是计算机程序设计中的一种重要操作,它的功能是将一个数据元素的任意序列,重新排列成一个按关键字有序的序列。因此排序掌握各种排序算法非常重要。...

比较排序总结——直接插入排序,希尔排序,选择排序,堆排序,冒泡排序,快速排序,归并排序

一,直接插入排序 插入排序(Insertion Sort)的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。插入排...

插入排序、冒泡排序、选择排序、希尔排序、快速排序、归并排序、堆排序和LST基数排序——C++实现

首先是算法实现文件Sort.h,代码如下: /* * 实现了八个常用的排序算法:插入排序、冒泡排序、选择排序、希尔排序 * 以及快速排序、归并排序、堆排序和LST基数排序 * @author gkh1...

【Java】八个常用的排序算法:插入排序、冒泡排序、选择排序、希尔排序 、快速排序、归并排序、堆排序和LST基数排序

这篇文章主要介绍了Java如何实现八个常用的排序算法:插入排序、冒泡排序、选择排序、希尔排序 、快速排序、归并排序、堆排序和LST基数排序,需要的朋友可以参考下 本文实现了八个常用的排序算法:插...
  • C_jian
  • C_jian
  • 2016年01月16日 13:54
  • 556

八大经典排序算法基本思想及代码实现(插入排序,希尔排序,选择排序,堆排序,冒泡排序,快速排序,归并排序,基数排序)

一.插入排序——简单插入排序基本思想:每步将一个待排序的纪录,按其关键码值的大小插入前面已经排序的文件中适当位置上,直到全部插入完为止。def insertSort(arr): if len(...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:排序总结:插入(简单和改进)、希尔、选择、冒泡、快速、堆排序、归并排序
举报原因:
原因补充:

(最多只允许输入30个字)