内部排序算法

概述

　　计算机上的程序，往下说就是一堆门电路以及一些逻辑运算；往上说就几个主要的部件(cpu，寄存器，内存，硬盘)上数据的运算与流动。而数据结构和算法是计算机程序的存储结构和工作流程。恰当的数据结构和算法对特定项目有着意想不到的效率。其中排序算法是数据结构中比较重要的；因为几乎每种数据结构都有排序的操作。下面从排序算法的分类，各种排序算法的思想、具体的代码、时间复杂度、空间复杂度以及适用情况。排序算法又分为内部排序算法(指待排序的记录存放在计算机随机存储器中)和外部排序(指待排序的记录太大，以至于内存中一次不能容纳全部记录)

排序算法的分类

　　排序算法的分类有多种，主要看按什么来分类；

　　按排序过程中依据不同的原则可以分为：插入排序,交换排序,选择排序,归并排序,分配排序。

　　按工作量(时间复杂度)可以分为：简单排序算法(O(n^2)),先进排序算法(O(nlogn))和基数排序(O(d*n)).

具体的算法

(1) 插入排序

　　插入排序有：直接插入排序，折半插入排序，2-路插入排序和希尔排序

　　①直接插入排序

　　　　核心思想：假设当前有k个已经排好序的数据，现在有一个新的元素要插入到该k个有序数据中恰当的位置，从而使者k+1个元素有序。

　　　　代码 ：

void DirectInsertSort(int array[],int len) {
   //array 为需要进行排序的数组，而len为array数组的元素个数，注意第一个即下标为                  
   //0的位置上没有放元素。
     int i, j, len = len;
    for(i=2; i<=len; i++) {
        if(array[i] < array[i-1]) {
            array[0] = array[i];
            array[i] = array[i-1];
            for(j = i-2; array[0]<array[j]; --j) {
                array[j+1] = array[j];
            }
            array[j+1] = array[0];
         }
   }
    
}

　　　　时间复杂度：O(n^2)　　　　空间复杂度：O(n+3)

　　②折半插入排序

　　　　核心思想：在直接插入排序过程中，对于第k+1个元素要插入到k个有序队列中，需要去查找恰当的位置，而这里的查找可以通过折半查找来替代，从而可以改进查找过程的速度。

　　　　代码：

void BinaryInsertSort(int array[],int length) {
    //第一个元素仍然当做哨兵
     int i,low,mid,high,len=length;
    low = 0;
    mid = 0;
    high = 0;
    for(i=2;i<=len;i++) {
        array[0] = array[i];
        low = 1;
        high =  i-1;
        while(low <= high) {
            mid = (low + high)/2;
            if (array[0] < array[mid]) high = mid - 1;
            else low = mid + 1;
        }
        for(j=i-1; j>=high+1; j++) {
            array[j+1] = array[j];
        }
        array[high] = array[0];
    }
}

时间复杂度：O（n^2）   　　空间复杂度O(n+5)

注意：折半插入排序算法并不能改进直接插入排序算法的时间复杂度和移动元素的个数，它只是能够减少比较的次数。故它的时间复杂度也是O(n^2).

③2-路插入排序算法

　　核心思想：待排序的元素存放在array[]中，另外设置一个跟array相同类型大小的数组temp[]，将array[1]赋值给temp[1]，将temp[1]看成是排好序序列中间位置的元素，即现在有中间元素temp[1]，比其小的有序表list1，比其大的有序表list2，这样从array的第二个元素开始同temp[1]比较，如果比其大，则插入到list2中，比其小则插入到list1中，在实际的实现算法中，将temp看成是一个循环向量，并设置两个指针first和final分别指示排序过程中得到的有序序列中的第一个记录和最后一个记录在temp中的位置。

[参考http://blog.csdn.net/Sunboy_2050/archive/2010/06/03/5645831.aspx]

　　代码

 

void BinInsertSort(int array[],int len)
{
    int* arr_d = (int *)malloc(sizeof(int) * len);
    int i,j,pos;
    
    arr_d[0] = array[0];
    int first = 0,final = 0;
    
    for (i = 1;i < len; i++ )
    {
        if (array[i] > arr_d[0])
        {
            //插入到更大的那一部分中
             for ( j= final;j>0;j--)
            {
                if (array[i] < arr_d[j])
                    arr_d[j+1] = arr_d[j];
                else
                    break;
            }
            arr_d[j+1] = array[i];
            final += 1;
        }

        else
        {
            //插入到更小的那一部分中
             if (first ==0)
            {
                arr_d[len-1] = array[i];
                first =len-1;
            }
            else
            {
                
                for (j = first;j <= len-1;j++)
                {
                    if (array[i] > arr_d[j])
                        arr_d[j-1] = arr_d[j];
                    else
                        break;
                }
                arr_d[j-1] = array[i];
                first -= 1;
            }
        }

    }
    for (i = 0;i < len; i++)
    {
        pos = (i + first)%len;
        array[i] = arr_d[pos];
    }

    free(arr_d);
}

图解：

时间复杂度 O(n^2)  空间复杂度 O(2n+5)

④改进的2-路插入排序算法 [参看http://epub.cnki.net/grid2008/detail.aspx?filename=HDZR200402015&dbname=CJFD2004]  

在原来的数组上实现了2-路插入排序算法。时间复杂度 O(n^2)  空间复杂度 O(n+5)

⑤希尔排序

　　核心思想：先将整个待排记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序时”，再对全体记录进行一次直接插入排序。该算法依靠一个增量序列，通过该增量序列中的每个值，对记录进行分割并直接插入排序，通常这些增量值都是一序列的素数。

[注意]：这里的增量序列的最后一个元素必须是1，因为最后要进行一次整体的插入排序。

　　代码：

 

void ShellInsert(int array[],int dk,int len) {
    //len 是array数组的长度
     int i=0,j;
    for(i=dk+1; i<=len;i++) {
        if(array[i] < array[i-dk]) {
            array[0] = array[i];
            for(j=i-dk; j>0&&(array[0]<array[j]);j-=dk)
                array[j+dk] = array[j];
            array[j+dk] = array[0];
        }
    }
}
 void ShellSort(int array[],int dlta[],int len) {
    //len是dlta数组的长度
     int i=0,length=sizeof(array)/sizeof(int);
    for(i=0; i<len, i++) {
        ShellInsert(array,dlta[i],length);
    }
}

时间复杂度：O(n^1.5)           空间复杂度O(n+2)

(2)交换排序算法

　　交换排序算法有：冒泡排序算法和快速排序算法

①冒泡排序算法

　　核心思想：每一趟都是将一个元素沉底，第一趟是最大的元素，最后一趟是倒数第二小的元素，每次都像一个气泡沉底，所以叫冒泡排序算法。具体的一趟是拿到当前无序元素中最大的元素。

　　代码

 

void BubbleSort(int array[],int len) {
        //第一个元素不当哨兵
     int i,j,k,temp;
    for(i=0; i<len; i++) {
        k = len-i-1;
        for(j=0; j<k;j++) {
            if(array[j]> array[j+1]) {
                temp = array[j+1];
                array[j+1] = array[j];
                arrau[j] = temp;
            }
        }
    }
}

　　时间复杂度  O(n^2)   空间复杂度  O(n+4)

②快速排序算法

　　核心思想：通过一趟排序算法将待排记录分割成两部分，其中一部分记录的关键字均比另一部分记录的关键字小，然后再对这两部分队列进行这样的排序，从而分割成四部分，一直这样下去，知道每一个部分都有序。具体做法：以第1个元素作为枢轴，指针low指向当前枢轴的位置，将枢轴位置上的数据拿出来，指针high指向最后一个元素，从high指针开始往前走，当遇到比枢轴小的元素时，停下来，将该更小的元素放入low所指的位置，然后low指针往后走，遇到比枢轴大的元素时，停下来，将该更大的元素放入high所指的位置；接着重复这两个动作，从high开始。一直到(low>=high).

　　代码

 

int Partition(int array[],int low,int high) {
    //每一趟都确定一个元素的位置，并返回该位置
    //array[0] 作为哨兵
     array[0] = array[low];
    while(low < high) {
        //从high下标开始找比枢轴小的元素，找到就跳出第一个while，将该元素存放到low所指向的位置
         while(low < high && array[high] >= array[0]) --high;
        array[low] = array[high];
        //从low下标开始往后找比枢轴大的元素，找到就跳出第二个while，将该元素存放到high所指向的位置
         while(low < high && array[low] <= array[0]) ++low;
        array[high] = array[low];
    }
    array[low] = array[0];
    return low;
}

 void QSort(int array[],int low,int high) {
    //一开始的时候low=0；high=n-1；
     int temp ;
    if(low < high) {
        temp = Partition(array,low,high);
        QSort(array,low,temp-1);
        QSort(array,temp+1,high);
    }
}

时间复杂度 O(nlogn)   空间复杂度(2n)

(3)选择排序

　　选择排序的基本思想是：每趟在n-i+1(i=1,2,…,n-1)个记录中选取关键字最小的记录作为有序序列中第i个记录。有简单选择排序算法，树形选择排序，堆排序。

　①简单选择排序算法

　　核心思想：通过n-i次关键字间的比较，从n-i+1个记录中选出关键字最小的记录，并和第i个记录交换。

　　代码

 

void SelectSort(int array[],int len) {
    int i,j,temp;
    for(i=0;i<len;i++) {
        temp = i;
        for(j=i+1;j<len;j++)
            if(array[j] < array[i]) temp = j;
        
        if(temp != i) {
            array[i] = array[i]+ array[temp];
            array[temp] = array[i] - array[temp];
            array[i] = array[i] - array[temp];
        }
    }
}

　　时间复杂度 O(n^2)  空间复杂度  O(n+3)

②树形选择排序算法

　　核心思想：首先对n个记录进行两两比较，然后在其中「n/2]个较小者之间再进行两两比较，如此重复，直至选出最小关键字的记录为止。

　　时间复杂度 O(nlogn)  空间复杂度：很大，需要很多辅助存储空间。

③堆排序

　　堆的定义：

　　　　对于所有的元素都满足这样的条件：任何一个元素都比它的孩子结点小或者大，其中父亲节点小(大)的称为小(大)顶堆(严蔚敏的那本书上，认为父亲节点小的是大顶堆，我查了一些资料，是有一些资料这么说，但也有一些是不是这样的，一般称为最大堆的就是指父亲节点大，最小堆就是指父亲节点小。但我的理解是大顶堆就是指顶(父亲节点)是大的。所以下文都认为大顶堆是指父亲节点大的，小顶堆是指父亲节点元素小的)

　　核心思想：假设现在已经将待排的n个记录建成了一个小顶堆，输出堆顶元素，此时，左子树和右子树都成为了一个小顶堆，将堆中最后一个(下标最大)元素，作为一个新的堆顶，然后从堆顶开始进行"筛选",用该元素和两个孩子比较，和更小者进行对换，一直这样直到它的孩子为空或它的孩子都比它大为止。现在还有一个问题，就是一开始的时候，那个堆是如何建立起来的。事实上，通过"筛选"操作就能够建立一个小顶堆，先将这n个记录构建成一颗二叉树，然后从该二叉树的第[n/2]个元素开始进行"筛选"，直到下标为“0”，通过这样的“筛选”就能够建立起一个堆。

　　代码：

 

void HeapAdjust(int array[],int low,int high) {
    //array[low…high]中的元素除了array[low]之外均满足堆的定义，本函数调整array[low]的关
    //键字，使array[low…high]成为一个大顶堆
     int j,temp = array[low];
    for(j=2*low; j <= high; j*=2) {
        if( j < high && array[j] < array[j+1] ) ++j;
        if(temp >= array[j]) break;
        array[low] = array[j];
        low = j;
    }
    array[low] = temp;
}

 void HeapSort(int array[],int len) {
    //第一个元素当哨兵
     int i,temp;
    
    for(i=len/2; i>0; i--)
        HeapAdjust(array,i,len);
    for(i=len; i>1; i--) {
        temp = array[1];
        array[1] = array[i];
        array[i] = temp;
        HeapAdjust(array,1,i-1);
    }
    
}

时间复杂度 O(nlogn)  空间复杂度 O(n+2)

(4)归并排序

　　核心思想:归并的思想是将两个或两个以上的有序表组合成一个新的有序表。对n个待排记录划分为n个有序表，每个表中只有一个元素，然后两两表进行合并，从而合并为[n/2]个有序表，继续这样下去，直到所有表合并为一个有序表为止。

#define NUM 256
 void Merge(int array[],int low,int mid,int high) {
    int j,k;
    int iStart=low, iEnd = high;
    int arr_d[NUM];
    for(j=mid+1,k=low; low<=mid && j <= high; ++k) {
        if(array[low,array[j]) 
            arr_d[k] = array[low++];
        else
            arr_d[k] = array[j++];
    }
    if(low < mid) {
        for(; k<=high; k++, low++)
            arr_d[k] = array[low++];
    }
    
    if(j <= high) {
        for(; k<=high; k++,j++)
            arr_d[k] = array[j];
    }
    
    for(j=iStart; j<=iEnd; j++)
        array[j] = arr_d[j];
}


 void MSort(int array[],int low,int high) {
    int mid;
    if(low < high){
        mid = (low+high)/2;
        MSort(array,low,mid);
        MSort(array,mid+1,high);
        Merge(array,low,mid,high);
    }
}
 void MergeSort(int array[],int len) {
    MSort(array, 1, len);
}

时间复杂度：  O(nlogn)  空间复杂度 O(1.5n)--最坏的时候

(5) 分配排序

　　分配排序有：桶排序和基数排序

　　①桶排序

　　　　核心思想：把区间[0,1]划分成n个相同大小的子区间，每个区间叫做桶，然后将n个待排记录分布到各个桶上面去。划分时，各个桶已经有序，即桶值更小的，分布在其上的元素肯定小于分布在桶值更大的桶上的元素。而对于分布在同一个桶上面的元素，就要分别对他们进行排序，可以使用插入排序

　　代码

typedef struct BucketNode {
    int data;
    struct BucketNode * next;
}BucketNode;

typedef struct Bucket {
    struct BucketNode *p;
}Bucket;
 void InsertNode(struct Bucket* add_r, int index, int key) {
    struct BucketNode * p=NULL,*q=NULL,*temp=NULL;
    if(index == -1) {
        printf("error in the value of j");
        return;
    }
    temp = (BucketNode*)malloc(sizeof(BucketNode));
    if(!temp) {
        printf("2、error in malloc function");
        exit(1);
    }
    temp->data = key;
    temp->next = NULL;
            
    if(NULL != add_r[index].p) {
        p = add_r[index].p;
        q = p;
        while(NULL != p && p->data < key) {
            q = p;
            p = p->next;
        }
        
        if(NULL == P) {
            q->next = temp;
        }else {
            temp->next = q->next;
            q->next = temp;
        }
    }else {
        add_r[index].p = temp;
    }
    p = NULL;
    q = NULL;
    temp = NULL;
    free(p);
    free(q);
    free(temp);
}

 void BucketSort(int array[], int len) {
    //add_r作为数组array的桶，它的大小可以不用和array一样大，但是我们这里
    //设置成一样大.  假如array中最大的数时89，则num中存放10；最大数为889，num为100
     int i,j,max=array[0],num=1;
    struct Bucket *add_r;
    struct BucketNode * p; 
    add_r = (int*)malloc( sizeof(Bucket) * len );
    
    if(!add_r) {
        printf("1、error in malloc function!");
        exit(1);
    }
    for(i=0; i<len; i++)
        add_r[i].p = NULL;
    //找到最大的元素
     for(i=2; i<len; i++)
        if(max < array[i]) max = array[i];
    //设置num的值
     while(max) {
        
        max = max / 10;
        num = num * 10;
    }
    
    // 将array中的元素插入桶B中
     for(i=0; i<len; i++) {
        j = -1;
        j = array[i]/num;
        InsertNode(add_r, j, array[i]);
    }
    //将桶add_r中的元素进行合并
     j=0;
    
    for(i=0; i<len; i++) {
        p = add_r[i].p;
        if(NULL != add_r[i].p && p != NULL) {
            p = add_r[i].p;
            array[j] = p->data;
            j++;
            p = p->next;
        }
    }
}

时间复杂度 O(n)  空间复杂度 O(4n)

图例

②基数排序

　　　　核心思想：基数排序跟前面的各种算法都不一样，因为它不需要进行关键字间的比较，只需要进行关键移动，借助多关键字排序对单逻辑关键字进行排序。

　　　　时间复杂度O(n+rd)  d是指记录的进制，比如如果待排的记录为整数，则d为10；而r是指待排记录中最大的数所含有的关键字个数，比如待排最大记录为999，则认为r为3，因为它有三个关键字“个位、十位、百位”.

　　　　空间复杂度O(n+rd)

③计数排序

　　核心思想：假设待排记录都介于0与k之间的整数，此处k为某个整数，实际上我们找出待排记录中最大的元素就可以了。对每一个带排记录x，确定出小于x的元素个数，有了这一信息，就可以把x直接放到它在最终输出数组中的位置上了。

　　代码

void CountSort(int array[], int len) {
    //假设array中最大的元素
     int i,index;
    int *count = NULL,*add_r = NULL,max=array[0],min=array[0];
    
    //找array[]数组中最大和最小的元素
     for(i=1; i<len; i++) {
        if(array[i] > max) max = array[i];
        else if(array[i] < min) min = array[i];
    }
    count = (int*)malloc(sizeof(int)*(max-min+1));
    if(NULL == count) {
        printf("1、error in malloc function!");
        exit(1);
    }
    add_r = (int*)malloc(sizeof(int)*len);
    if(NULL == add_r) {
        printf("2、error in malloc function!");
        exit(1);
    }
    for(i=0; i<len; i++) {
        index = array[i]-min;
        count[index] = count[index] +1;
    }
    for(i=1; i<(max-min+1); i++) {
        count[i] = count[i] + count[i-1];
    }
    
    for(i=len-1; i>0; i--) {
        index = array[i]-min;
        add_r[count[index]] = array[i];
        count[index] = count[index]-1;
    }
    for(i=0; i<len; i++) {
        array[i] = add_r[i];
    }
    free(count);
    free(add_r);
}

时间复杂度：O(n) 空间复杂度 O(2n+k) k为array数组中最大记录与最小记录直接的差值