数据结构排序算法汇总

一、冒泡排序

void BubbleSort(RecType R[],int n)
{
    int i,j,k;
    RecType tmp;
    for (i=0;i<n-1;i++) 
    {
        for (j=n-1;j>i;j--)    //比较,找出本趟最小关键字的记录
            if (R[j].key<R[j-1].key)   
            {
                tmp=R[j];  //R[j]与R[j-1]进行交换,将最小关键字记录前移
                R[j]=R[j-1];
                R[j-1]=tmp;
            }
        printf("i=%d: ",i);
        for (k=0;k<n;k++)
            printf("%d ",R[k].key);
        printf("\n");
    }
} 

二、堆排序

void sift(RecType R[],int low,int high)
{
        int i=low,j=2*i;                         //R[j]是R[i]的左孩子
        RecType temp=R[i];
        while (j<=high) 
        {
            if (j<high && R[j].key<R[j+1].key)     //若右孩子较大,把j指向右孩子
                j++;                                //变为2i+1
            if (temp.key<R[j].key) 
            {
                R[i]=R[j];                          //将R[j]调整到双亲结点位置上
                i=j;                                //修改i和j值,以便继续向下筛选
                j=2*i;
            }
            else break;                             //筛选结束
        }
        R[i]=temp;                                  //被筛选结点的值放入最终位置
}

三、插入排序

void InsertSort(RecType R[],int n) //对R[0..n-1]按递增有序进行直接插入排序
{
    int i,j,k;
    RecType temp;
    for (i=1;i<n;i++) 
    {
        temp=R[i];
        j=i-1;            //从右向左在有序区R[0..i-1]中找R[i]的插入位置
        while (j>=0 && temp.key<R[j].key) 
        {
            R[j+1]=R[j]; //将关键字大于R[i].key的记录后移
            j--;
        }
        R[j+1]=temp;      //在j+1处插入R[i]
        printf("i=%d: ",i);
        for (k=0;k<n;k++)
            printf("%d ",R[k].key);
        printf("\n");
    }
}

四、归并排序

void Merge(RecType R[],int low,int mid,int high) 
{
    RecType *R1;
    int i=low,j=mid+1,k=0; //k是R1的下标,i、j分别为第1、2段的下标
    R1=(RecType *)malloc((high-low+1)*sizeof(RecType));  //动态分配空间
    while (i<=mid && j<=high)         //在第1段和第2段均未扫描完时循环
        if (R[i].key<=R[j].key)        //将第1段中的记录放入R1中
        {
            R1[k]=R[i];
            i++;k++; 
        }
        else                               //将第2段中的记录放入R1中
        {
            R1[k]=R[j];
            j++;k++; 
        }
    while (i<=mid)                         //将第1段余下部分复制到R1
    { 
        R1[k]=R[i];
        i++;k++; 
    }
    while (j<=high)                    //将第2段余下部分复制到R1
    {
        R1[k]=R[j];
        j++;k++;  
    }
    for (k=0,i=low;i<=high;k++,i++) //将R1复制回R中
        R[i]=R1[k];
} 
void MergePass(RecType R[],int length,int n)    //对整个数序进行一趟归并
{
    int i;
    for (i=0;i+2*length-1<n;i=i+2*length)     //归并length长的两相邻子表
        Merge(R,i,i+length-1,i+2*length-1);
    if (i+length-1<n)                        //余下两个子表,后者长度小于length
        Merge(R,i,i+length-1,n-1);          //归并这两个子表
}
void MergeSort(RecType R[],int n)            //自底向上的二路归并算法
{
    int length;
    for (length=1;length<n;length=2*length)//进行log2n趟归并
        MergePass(R,length,n);
}

五、快速排序

void QuickSort(RecType R[],int s,int t) //对R[s]至R[t]的元素进行快速排序
{
    int i=s,j=t;
    RecType tmp;
    if (s<t)                 //区间内至少存在两个元素的情况
    {    
        tmp=R[s];             //用区间的第1个记录作为基准
        while (i!=j)          //从区间两端交替向中间扫描,直至i=j为止
        {    
            while (j>i && R[j].key>=tmp.key) 
                j--;          //从右向左扫描,找第1个小于tmp.key的R[j]
            R[i]=R[j];        //找到这样的R[j],R[i]"R[j]交换
            while (i<j && R[i].key<=tmp.key) 
                i++;        //从左向右扫描,找第1个大于tmp.key的记录R[i]
            R[j]=R[i];        //找到这样的R[i],R[i]"R[j]交换
        }
        R[i]=tmp;
        QuickSort(R,s,i-1);        //对左区间递归排序
        QuickSort(R,i+1,t);        //对右区间递归排序
    }
}

六、基数排序

void RadixSort(RecType *&p,int r,int d) //实现基数排序:*p为待排序序列链表指针,r为基数,d为关键字位数
{
    RecType *head[MAXR],*tail[MAXR],*t;    //定义各链队的首尾指针
    int i,j,k;
    for (i=0;i<=d-1;i++)                   //从低位到高位循环
    {    
        for (j=0;j<r;j++)                 //初始化各链队首、尾指针
            head[j]=tail[j]=NULL;
        while (p!=NULL)                  //对于原链表中每个结点循环
        {    
            k=p->data[i]-'0';           //找第k个链队
            if (head[k]==NULL)           //进行分配
            {
                head[k]=p;
                tail[k]=p;
            }
              else
            {
                  tail[k]->next=p;
                tail[k]=p;
            }
            p=p->next;                     //取下一个待排序的元素
        }
        p=NULL;                            //重新用p来收集所有结点
           for (j=0;j<r;j++)                //对于每一个链队循环
            if (head[j]!=NULL)             //进行收集
            {    
                if (p==NULL)
                {
                    p=head[j];
                    t=tail[j];
                }
                else
                {
                    t->next=head[j];
                    t=tail[j];
                }
            }
        t->next=NULL;                    //最后一个结点的next域置NULL
        printf("  按%s位排序\t",(i==0?"个":"十"));
        DispLink(p);
    }
}