常用排序算法

 

考研复习数据结构时，总结的常用排序算法。
趁着开博之际记录一下，免得以后遗忘。哈哈哈~~~~
Sort.h
#ifndef _SORT_H
#define _SORT_H
/*
    定义各种排序算法
*/
/**************************************************************************************************************
    功能：冒泡排序
    参数：data为数据源，begin为开始序数，end为结束序数
    原理：待排序的元素序列中的元素个数为n，从后向前两两比较元素大小，如果发生逆序，交换他们的位置
             直至序列比较完。这是一趟冒泡排序，结果是将最小的元素交换到待排序序列的第一个位置，其余元素后挪。
             下一趟排序前，确定最小的元素不再参加比较。如果一趟比较下来，没有发生交换，则认为序列顺序是正确的。
             可以提前结束循环。这样下来，最多n-1趟比较，序列可以完成排序。
    评价：时间复杂度为O（n*n），空间复杂度O（1），是一种稳定的算法。
              由于移动了较多次元素，所以效率在简单排序中最低。
**************************************************************************************************************/
void BubbleSort(int *data,int begin,int end);
/**************************************************************************************************************
    功能：快速排序
    参数：data为数据源，begin为开始序数，end为结束序数
    原理：任取待排序元素序列中的某个元素作为基准，按照该元素的大小，将序列分成2个子序列，左子序列都小于
              该基准    ，右子序列都大于或等于该基准，该元素在2个序列的中间（即最终位置上）。对2个子序列各重复
              上述动作，直至所有元素都到最终位置而止。
    评价：平均时间为O（n*log2(n)），空间复杂度为O( log2(n) )，是一种不稳定的算法。
             当原始序列基本有序时，性能最差，时间为O(n*n)；但是就平均性能而言，性能最好。
**************************************************************************************************************/
void QuickSort(int *data,int begin,int end);
/**************************************************************************************************************
    功能：完成快速排序的一趟排序，移动基准元素到其最终位置
    参数：data为数据源，begin为开始序数，end为结束序数
    返回：基准元素的最终位置
**************************************************************************************************************/
int QuickSortPartition(int *data,int begin,int end);
/**************************************************************************************************************
    功能：直接插入排序
    参数：data为数据源，begin为开始序数，end为结束序数
    原理：把数组data[n]中待排序的n个元素分成有序表与无序表，开始时有序表只包含data[0]一个元素，无序表包含
              其余元素。排序过程中将无序表中第一个元素插入到有序表中合适的位置。经过（n-1）次插入，无序表位空，
              有序表包含n个元素。排序完成
    评价：平均时间O（n*n），空间复杂O（1）,是一种稳定的算法。当数组正序时，只需比较n-1次，无需移动；但当
              数组逆序时，比较和移动次数均为达到O（n*n/2）。
**************************************************************************************************************/
void InsertSort(int *data,int begin,int end);
/**************************************************************************************************************
    功能：折半插入排序
    参数：data为数据源，begin为开始序数，end为结束序数
    原理：与直接插入排序类似。区别，元素比较方式不同，利用折半查找的方法在有序表中找到合适的位置。
    评价：平均时间O（n*n），空间复杂O（1）,是一种稳定的算法。平均比较次数为O（n*log2(n)）。
              当n较大时，总比较次数比直接插入排序的最差情况好，但比后者的最好情况差。当数组基本有序时，
              性能比直接插入排序差。
**************************************************************************************************************/
void BinaryInsertSort(int *data,int begin,int end);
/**************************************************************************************************************
    功能：希尔排序
    参数：data为数据源，begin为开始序数，end为结束序数
    原理：与直接插入排序类似。设数组有n个元素，首先取gap=（n/3+1），以gap为间距，将全部元素分成gap个
              子序列，即所有距离为gap的元素在同一个子序列。在每个子序列进行直接插入排序。然后缩小gap，
              令gap=（gap/3+1），重复上述动作，直至gap<=1为止。当gap=1时，等价于直接插入排序。
    评价：平均时间O（n^1.25~n^1.65），空间复杂O（1）,是一种不稳定的算法。
              由于开始时gap较大，每个子序列中元素比较少，排序比较快。待排序到后期时，子序列元素数量增多，
              但由于前期工作的基础，使序列已基本有序，所以排序依然很快。
              对于规模较大的序列（n<1000），希尔排序具有较高的效率，而且代码简单。
**************************************************************************************************************/
void ShellSort(int *data,int begin,int end);
/**************************************************************************************************************
    功能：简单选择排序
    参数：data为数据源，begin为开始序数，end为结束序数
    原理：每一趟都从后面待排序的（n-i）个元素中选出最小的，作为有序表中的第i个元素。进行n-1趟之后，元素有序。
    评价：平均时间O（n^2），空间复杂O（1）,是一种不稳定的算法,移动次数不稳定。
              元素的移动次数跟初始序列状态有关。当序列正序排列时，移动次数为0；但最坏情况下，每一趟都要移动元素，
              总的移动次数为3*(n-1)。
**************************************************************************************************************/
void SelectSort(int *data,int begin,int end);
/**************************************************************************************************************
    功能：堆排序
    参数：data为数据源，begin为开始序数，end为结束序数
    原理：一旦建立初始堆（大根堆），处于对顶的元素data[begin]就是该未排序序列最大的元素，将该元素与该序列
             最后的元素交换，确定该该元素的最终位置。再对前面n-1个元素使用堆调整，使之重新成为堆。重复上述动作
             直至无序表位空。
    评价：平均时间O（n*log2(n)），空间复杂O（1）,是一种不稳定的算法。适用于规模较大的排序。平均性能较
              快速排序慢。
**************************************************************************************************************/
void HeapSort(int *data,int begin,int end);
/**************************************************************************************************************
    功能：堆调整
    参数：data为数据源，begin为开始序数，end为结束序数
    原理：设定除data[begin]之外的元素均满足大根堆的定义，将该元素与其孩子比较，将较大的元素上移到父母的位置，
              重复上述动作直至该元素大于其当前位置的孩子。
**************************************************************************************************************/
void HeapAdjust(int *data,int begin,int end);
/**************************************************************************************************************
    功能：二路归并排序
    参数：data为数据源，begin为开始序数，end为结束序数
    原理：就是将2个有序表合并成一个新的有序表。该算法在执行时一直调用划分过程，直到子序列划分成一个空序列或
              只有一个元素的序列，然后在归并过程中归并成长度为2的子序列，在归并为4的序列，依次类推，直至归并成
              整个序列。此时 序列已经有序。 共调用（n*log2(n)）次递归。
    评价：最好，最差，平均时间复杂度为O（n^2），对序列的初始状态无关。空间复杂度为O（n），是一种稳定的算法。
**************************************************************************************************************/
void MergeSort(int *data,int begin,int end);
/**************************************************************************************************************
    功能：合并序列
    参数：data为数据源，begin为开始序数，mid为中间，分割2个子序列，end为结束序数
    原理：将2个子序列（data[begin]~data[mid]  和 data[mid+1]~data[end]）合并成一个有序数列，且2个子序列均
              有序。
**************************************************************************************************************/
void Merge(int *data, int begin, int mid, int end);
#endif
Sort.cpp
#include "sort.h"
#include "util.h"
void BubbleSort(int *data,int begin,int end)
{
    if(!data || begin<0 || end<0)
        return ;
    bool exchange=false;
    int temp;
    int i=0,j=0;
    //正序排序
    for(i=begin;i<end;i++)
    {
        exchange=false;
        for(j=end;j>=i+1;j--)                                        //从后向前扫描，将最小的元素前置
        {
            if(data[j-1]>data[j])
            {
                temp=data[j-1];
                data[j-1]=data[j];
                data[j]=temp;
                exchange=true;
            }
        }
        if(!exchange)                                                    //没有发生交换，数据顺序正确，跳出循环
            return;           
    }//for           
}
void QuickSort(int *data,int begin,int end)
{
    if(begin<end && begin>=0)
    {
        int pivotPos=QuickSortPartition(data,begin,end);       
        QuickSort(data,begin,pivotPos-1);
        QuickSort(data,pivotPos+1,end);
    }
}
int QuickSortPartition(int *data,int begin,int end)
{   
    if(!data || begin<0 || end<0)
        return -1 ;
    int pivot=data[begin];
    int i=begin, j=end;
    while(i != j)                                            //从数组两端交替的向中间扫描
    {
        while(i<j && data[j]>pivot)
            j--;
        if(i<j)                                                //从右扫描，将比基值小的值移动到左边
            data[i++]=data[j];                       
        while(i<j && data[i]<=pivot)
            i++;
        if(i<j)                                                //从左扫描，将比基值大的值移动到右边
            data[j--]=data[i];
    }
    data[i]=pivot;                                        //将基值移动打最终的位置上
    return i;
}
void InsertSort(int *data,int begin,int end)
{
    if(!data || begin<0 || end<0)
        return ;
    int temp;
    int i,j;
    for(i=begin+1;i<=end;i++)
    {
        if(data[i]<data[i-1])
        {
            temp=data[i];
            j=i-1;
            //开始在有序表查找合适的位置,在查找的同时移动元素
            do{
                data[j+1]=data[j];
                j=j-1;
            }while(j>=begin && temp<data[j]);
            data[j+1]=temp;
        }
    }
}
void BinaryInsertSort(int *data,int begin,int end)
{
    if(!data || begin<0 || end<0)
        return ;
    int temp;
    int i,low,high,mid;
    for(i=begin+1;i<=end;i++)
    {
        if(data[i]<data[i-1])
        {
            temp=data[i];
            low=begin,high=i-1;
            //查找当前值在有序表中合适的位置，最终位置为low所在
            while(low<=high)   
            {
                mid=(low+high)/2;
                if(data[mid]>temp)
                {
                    high=mid-1;                   
                }else{                   
                    low=mid+1;
                }
            }       
            //移动元素，腾出位置
            for(int j=i-1;j>=low;j--)
                data[j+1]=data[j];
            //插入当前值到最终位置
            data[low]=temp;
        }
    }
}
void ShellSort(int *data,int begin,int end)
{
    if(!data || begin<0 || end<0)
        return ;
    int i,j,temp;
    int gap=end-begin+1;                //比较间距
    do{
        gap=gap/3+1;
        for( i=begin+gap; i<=end; i++)
        {
            if(data[i]<data[i-gap])
            {
                temp=data[i];
                j=i-gap;
                do{
                    data[j+gap]=data[j];
                    j-=gap;
                }while(j>begin && data[j]>temp);
                data[j+gap]=temp;
            }
        }
    }while(gap>1);
}
void SelectSort(int *data,int begin,int end)
{
    if(!data || begin<0 || end<0)
        return ;
    int i,j,temp,min;
    for(i=begin;i<end;i++)
    {
        min=i;
        //开始挑选最小的元素
        for(j=i+1;j<=end;j++)
        {
            if(data[j]<data[min])
                min=j;
        }
        //交换
        if(i!=min)
        {
            temp=data[i];
            data[i]=data[min];
            data[min]=temp;
        }
    }
}
void HeapSort(int *data,int begin,int end)
{
    if(!data || begin<0 || end<0)
        return ;
    int temp, length=end-begin+1;
    //建立初始堆
    for(int i=length/2; i>0; i-- )   
        HeapAdjust(data,i,end);
    //排序，每次取出最大值，放置到有序表的第一个位置，然后调整堆
    for( int j=end; j>begin; j-- )
    {
        temp=data[begin];
        data[begin]=data[j];
        data[j]=temp;
        HeapAdjust(data,begin,j-1);
    }
}
void HeapAdjust(int *data,int begin,int end)
{
    if(!data || begin<0 || end<0)
        return ;
    //大根堆，设定除data[begin]之外的元素均满足大根堆的定义
    int temp = data[begin];
    for( int i=begin*2; i<=end; i*=2)
    {
        if(i<end && data[i]<data[i+1])
            i+=1;
        //检查节点是否到达最终位置
        if(temp>=data[i])
            break;
        //调整堆，交换子孩子与父母的位置
        data[begin]=data[i];
        begin=i;
    }
    //将节点移动到最终位置上
    data[begin]=temp;
}
void Merge(int *data, int begin, int mid, int end)
{
    //将表1data[begin]~data[mid] 和表2data[mid+1]~data[end] 合并成一个有序表，设定表1，表2有序。
    if(!data || begin<0 || mid<0 || end<0)
        return;
    //建立data的副本
    int *temp=new int[end-begin+1];
    for(int i=begin;i<=end;i++)
        temp[i-begin]=data[i];
    int s1=begin,s2=mid+1;
    int j=begin;
    while(s1<=mid && s2<=end)
    {
        if(temp[s1-begin]<=temp[s2-begin])
            data[j++]=temp[s1++-begin];
        else
            data[j++]=temp[s2++-begin];
    }
    while(s1<=mid)
        data[j++]=temp[s1++-begin];
    while(s2<=end)
        data[j++]=temp[s2++-begin];
    //删除temp
    delete temp;
}
void MergeSort(int *data,int begin,int end)
{
    if(!data || begin<0 || end<0)
        return ;
    if(begin<end)
    {
        int mid=(begin+end)/2;
        MergeSort(data,begin,mid);
        MergeSort(data,mid+1,end);
        Merge(data,begin,mid,end);
    }
}