常用排序算法再复习

冒泡排序，选择排序，插入排序，希尔排序，快速排序，堆排序，归并排序简单归纳。

#include "stdio.h"
#include "string.h"
#include"stdlib.h"
#include"math.h"

#define ok 1
#define error 0
#define true 1
#define false 0
#define Max_length_insert_sort 7 /*用于快速排序时判断是否选用插入排序阈值*/

#define Maxsize 1000  //用于排序数组个数最大值
typedef struct
{
    int r[Maxsize+1]; //用于要排序数组个数最大值，r［0］用作哨兵
    int length;//记录顺序表长度
}Sqlist;

void swap(Sqlist *l,int i,int j) //交换L数组中r的下标为i和j的值
{
    int temp = l -> r[i];
    l -> r[i] = l -> r[j];
    l -> r[j] = temp;
}

void print(Sqlist l)//打印数组
{
    int j;
    for(j=0;j<l.length;j++)
    {
        printf("%d",l.r[j]);
        printf("\n");
    }
}


//冒泡排序初级版
void Bubblesort0(Sqlist *l)
{
    int i,j;
    for(i=1;i<l->length;i++)
    {
        for(j=i+1;j<=l->length;j++)
        {
            if(l->r[i]>l->r[j])
                swap(l,i,j);//交换L－>r[i]和L->r[j]的值
        }
    }
}

//正宗冒泡排序
void Bubblesort1(Sqlist *l)
{
    int i,j;
    for(i=1;i<l->length;i++)
    {
        for(j=l->length-1;j>=i;j--)//注意j是从后往前循环
        {
            if(l->r[j]>l->r[j+1])//若前者大于后者
                swap(l,j,j+1);//交换
        }
    }
}

//冒泡程序改进版
void Bubblesort2(Sqlist *l)
{
    int i,j;
    int flag = true;//flag用于标记
    for(i=1;i<l->length&&flag;i++)//若flag为true说明数据有过交换，否则停止交换
    {
        flag = false;//初始为false
        for(j=l->length-1;j>=i;j--)
        {
            if(l->r[j]>l->r[j+1])
                swap(l,j,j+1);//交换
            flag = true; //如果有数据交换，则flag变为true
        }
    }
}


//选择排序
void Selectsort(Sqlist *l)
{
    int i,j;
    int min;
    for(i=1;i<l->length;i++)
    {
        min = i;  //将当前下标定义为最小值下标
        for(j=i+1;j<=l->length;j++)// 循环之后的数据
        {
            if(l->r[min]>l->r[j]) //如果有小于当前最小值的关键字
                min = j;  //将此关键字的下标赋值给min
        }
        if(i!=min)  //若min不等于i，说明找到最小值，交换
            swap(l,i,min);
    }
}


//插入排序
void Insertsort(Sqlist *l)
{
    int i,j;
    for(i=2;i<l->length;i++)
    {
        if(l->r[i]>l->r[i-1]) //需将L->r[i]插入有序子表
        {
            l->r[0]=l->r[i]; //设置哨兵
            for(j=i-1;l->r[j]>l->r[0];j--)
                l->r[j+1]=l->r[j];  //记录后移
            l->r[j+1]=l->r[0];  //插入到正确位置
        }
    }

}


//希尔排序
void Shellsort(Sqlist*l)
{
    int i,j;
    int increment = L->length;
    do
    {
        increment = increment/3 +1;
        for(i=increment+1;i<=l->length;i++)
        {
            if(l->r[i]<l->r[i-increment])
            {
                l->r[0]=l->r[i];
                for(j=i-increment;j>0&&l->r[j]>l->r[0];j-=increment)
                    l->r[j+increment]=l->r[j];
                l->r[j+increment]=l->r[0];
            }
        }
    }while(increment>1);
}


//快速排序
void Qsort(Sqlist *L,int low,int high)
{
    int pivot;
    if(low<high)
    {
        pivot = Part(L,low,high);//将L->r[low..high]一分为二，算出枢轴值
        Qsort(L,pivot-1,high); //对低子序递归排序
        Qsort(L,low,pivot+1);// 对高子表递归排序
    }
}

int Part(Sqlist *L,int low,int high)
{
    int pivotkey;
    pivotkey = L -> r[low]; //用子表的第一个记录作枢轴记录
    while(low<high) // 从表的两端交替向中间扫描
    {
        while(low<high&&L->r[high]>=L->r[pivotkey])
            high--;
        swap(L,low,high); // 将比枢轴记录小的记录交换到低段
        while(low<high&&L->r[low]<=L->r[pivotkey])
            low++;
        swap(L,low,high); //将比枢轴记录大的记录交换到高端
    }
    return low;  //返回枢轴所在的位置
}

int Part1(Sqlist *L,int low,int high)
{
    int pivotkey;
    int m = low + (high-low)/2;
    if(L->r[low]>L->r[high])
        swap(L,low,high);
    if(L->r[m]>L->r[high])
        swap(L,high,m);
    if(L->r[m]>L->r[low])
        swap(L,m,low);
    pivotkey = L->r[low];
    L->r[0] = pivotkey;
    while(low<high)
    {
        while(low<high&&L->r[high]>=pivotkey)
        {
            high--;
        }
        L->r[low] = L－>r[high];
        while(low<high&&L->r[low]<=pivotkey)
        {
            low++;
        }
        L->r[high] = L->r[low];
    }
    L->r[low] = L->r[0];
    return low;
}



//快排优化版
void Qsort1(Sqlist *L,int low,int high)
{
    int pivot;
    if((high-low)>Max_length_insert_sort)
    { //当high - low大于常数时用快速排序
        while(low<high)
        {
            pivot = Part1(L,low,high);
            Qsort1(L,low,pivot-1);
            low = pivot + 1;// 尾递归
        }
    }
    else
        Insertsort(L);  //当high - low小于常数时用直接插入
}


//堆排序
void Heapsort(Sqlist*L) 
{
    int i;
    for(i = L->length/2;i>0;i--)  //把L中的r构建成一个大顶堆
    {
        Heapadjust(L,i,L->length);
    }
    for(i = L->length;i>1;i--)
    {
        swap(L,1,i);  //将顶堆记录和当前未经排序子序列的最后一个记录交换
        Heapadjust(L,1,i-1); //将L->[1..i-1]重新调整为大顶堆
    }
}


void Heapadjust(Sqlist *L,int s,int m)
{
    int temp,j;
    temp = L->r[s];
    for(j = 2*s;j<=m；j*=2)  //沿关键字较大的孩子结点向r下筛选
    {
        if(j<m&&L->r[j]<L->r[j+1])
             ++j;  j为关键字中较大的记录的下标
        if(temp >= L->r[j])
            break;  //rc应插入在位置s上
        L->r[s] = L->r[j];
        s = j;
    }
    L->r[s] = temp;  //插入
}


void MSort(int sr[],int tr1[],int s,int t) //归并排序
{
    int m;
    int tr2[Maxsize + 1];
    if(s == t)
        tr1[s] = sr[s];
    else
    {
        m = (s+t)/2; //将sr［s..t］平分为sr［s..m]和sr［m＋1。。t］
        MSort(sr,tr2,s,m);//递归将sr［s。。m］归并为有序的tr2［s。。m］
        MSort(sr,tr2,m+1,t);//递归将sr［m＋1。。t]归并为有序的tr2［m＋1。。t］
        Merge(tr2,tr1,s,m,t);//将tr2［s。。m］和tr2［m＋1。。t］
                            //归并到tr1［s。。t］
    }
}


/*将tr2［s。。m］和tr2［m＋1。。t］归并到tr1［s。。t］*/
void Merge(int sr[],int tr[],int i,int m,int n)
{
    int j,k,l;
    for(j=m+1,k=i;i<=m && j<=n;k++) //将sr中记录由小到大归并如tr
    {
        if(sr[i]<sr[j])
            tr[k] = sr[i++];  //将剩余的sr［i。。m］复制到tr
        else
            tr[k] = sr[j++];
    }
    if(i<=m)
    {
        for(l= 0;l<=m;l++)
            tr[k+1] = sr[i+1];
    }
    if(j<=n)
    {
        for(l = 0;l<=n-j;l++)
            tr[k+1] = sr[j+1];  //将剩余的sr［j。。n］复制到tr
   }
}