排序算法

一、内部排序

整个排序过程不需要访问外存就能完成，内部排序是一个逐步扩大记录的有序序列长度的过程。

1、插入排序

      a、直接插入排序

      b、希尔排序

 

2、选择排序

     a、直接选择排序

     b、堆排序

 

3、交换排序

     a、交换排序

     b、快速排序

 

4、合并排序

 

二、外部排序

计算机的内存是有限的，当对大批量的数据进行排序时，不可能一次性将数据将数据全部装入内存，即待排序的数据记录存储在外存中。这时，可以从外存中读取一部分数据到内存中，将内存中的数据进行排序后，再存储到外存中，让后再从外存中读取下一部分数据到内存中，再对内存中的这部分数据进行排序。这样将待排序的数据在内存和外存之间进行数据交换，达到排序整个数据的目的。

 

常用的排序算法

1、快速排序算法

快速 排序（Quicksort）是对 冒泡排序的一种改进。它的基本思想是：通过一趟 排序将要排序的 数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以 递归进行，以此达到整个数据变成有序序列。

int Division(int a[],int left, int right) //分割 
{
    int base=a[left];    //基准元素
    while(left<right)
    {
        while(left<right && a[right]>base)
            --right;     //从右向左找第一个比基准小的元素
        a[left]=a[right];
        while(left<right && a[left]<base )
            ++left;      //从左向右找第一个比基准大的元素
        a[right]=a[left];
    }
    a[left]=base;
    return left;
}
void QuickSort(int a[],int left,int right)
{
    int i,j;
    if(left<right)
    {
        i=Division(a,left,right);   //分割
        QuickSort(a,left,i-1);     //将两部分分别排序
        QuickSort(a,i+1,right);
    }
}

2、冒泡排序法

 

void BubbleSort(int a[],int n)
{
    int i,j,t;
    for(i=0;i<n-1;i++)
    {
        for(j=n-1;j>i;j--)
        {
            if(a[j-1]>a[j])
            {
                t=a[j-1];
                a[j-1]=a[j];
                a[j]=t;
            }
        }
        printf("第%2d遍:",i+1); 
        for(j=0;j<n;j++)
            printf("%d ",a[j]);
        printf("\n");
    }
}

 

 3、堆排序算法

堆的构成，参考：http://blog.youkuaiyun.com/morewindows/article/details/6709644

void HeapAdjust(int a[],int s,int n)//构成堆
{
    int j,t;
    while(2*s+1<n) //第s个结点有右子树 
    {
        j=2*s+1 ;
        if((j+1)<n)
        {            
            if(a[j]<a[j+1])//右左子树小于右子树，则需要比较右子树
                j++; //序号增加1，指向右子树 
        }
        if(a[s]<a[j])//比较s与j为序号的数据
        {            
            t=a[s];  //交换数据 
            a[s]=a[j];
            a[j]=t;            
            s=j ;//堆被破坏，需要重新调整
        }
        else //比较左右孩子均大则堆未破坏，不再需要调整
            break;
    }
}

堆排序：

void HeapSort(int a[],int n)//堆排序
{
    int t,i;
    int j;
    for(i=n/2-1;i>=0;i--)    //将a[0,n-1]建成大根堆
        HeapAdjust(a, i, n);
    for(i=n-1;i>0;i--)
    {
        t=a[0];//与第i个记录交换
        a[0] =a[i];
        a[i] =t;
        HeapAdjust(a,0,i);        //将a[0]至a[i]重新调整为堆
    }  
}