6大排序算法比较

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

#define LIST_INIT_SIZE 50000
int bj1,yd1,bj2,yd2,bj3,yd3,bj4,yd4,bj5,yd5,bj6,yd6,n;//yd,bj为记录关键字比较和移动的次数 

struct ElemType
{
    int key;
};

struct SqList//线性表
{
    ElemType *elem;
    int length;
};


void Createlist(SqList &L)//初始化顺序表的，确定输入数据个数n 
{
    int flags = 1;
    while(flags)
    {
        printf("请输入数据个数:");
        scanf("%d",&n);
        if(n>50000)
        {
            printf("超出范围重新输入!!!\n");
        }else flags = 0;//跳出循环
    }
    L.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));//分配内存
    if(!L.elem)exit(0);
}

void Random(SqList &L)//随机数产生程序 
{
    L.length=0;//数据初始为0
    srand(time(0));//使输入相同个数时每次产生的随机数不同 

    for(int i=1;i<n+1;i++)
    {
        L.elem[i].key=rand();//产生随机数
        while(L.elem[i].key>50000)L.elem[i].key=rand();//保证数据早50000以内
        L.length++;//数据个数+1
    }
}

void Memory(SqList &M,SqList &L)//记录L,使每个排序算法都用一组相同的随机数 
{
    int i = 1 ;
    M.length=0;//顺序表M初始长度为0
    while(i<=L.length)//顺序表L中的元素赋给顺序表M中
    {
        M.elem[i].key=L.elem[i].key;
        M.length++;
        i++;
    }
}

void BubbleSort(SqList &L)//冒泡排序 
{
    int i,j;
    for(i=1;i<L.length;i++)
    { 
        for(j=1;j<L.length-i+1;j++)
        {
            bj1++;//比较次数+1
            if(L.elem[j].key>L.elem[j+1].key)//关键字交换
            {
                L.elem[0].key=L.elem[j].key;
                L.elem[j].key=L.elem[j+1].key;
                L.elem[j+1].key=L.elem[0].key;
                yd1+=3;//关键字交换次数+3
            }
        }
    }
}

void InsertSort(SqList &L)//直接插入排序 
{
    int i,j;
    for(i=2;i<=L.length;i++)
    {
        if(L.elem[i].key<L.elem[i-1].key)
        {
            L.elem[0].key=L.elem[i].key;
            yd2++;//比较次数+1
            j=i-1;
            bj2++;//交换次数+1
            while(L.elem[0].key<L.elem[j].key)
            {
                L.elem[j+1].key=L.elem[j].key;
                j--;
                yd2++;//比较次数+1
                bj2++;//交换次数+1
            }
            L.elem[j+1].key=L.elem[0].key;
            yd2++;//比较次数+1
        }
    }
}



void SelectSort(SqList &L)//选择排序 
{
    int i,j,k;
    for(i=1;i<L.length;i++)
    {
        k=i;
        for(j=i+1;j<=L.length;j++)
        {
            bj3++;//比较次数+1
            if(L.elem[j].key<L.elem[k].key)k=j;
        }
        if(i!=k)
        {
            L.elem[0].key=L.elem[i].key;
            L.elem[i].key=L.elem[k].key;
            L.elem[k].key=L.elem[0].key;
            yd3+=3;//交换次数+3
        }
    }
}


int Partition(SqList &L,int low,int high)//快速排序 
{
    int pivotkey;
    L.elem[0]=L.elem[low];
    yd4++;//交换次数+1
    pivotkey=L.elem[low].key;
    while (low<high)
    {
        yd4++;//交换次数+1
        while(low<high&&L.elem[high].key>=pivotkey)
            high--;
            L.elem[low]=L.elem[high];
            bj4++;//比较次数+1
            yd4++;//交换次数+1
        while (low<high&&L.elem[low].key<=pivotkey)
            low++;
            L.elem[high]=L.elem[low];
            bj4++;//比较次数+1
            yd4++;//交换次数+1
    }
    L.elem[low]=L.elem[0];
    yd4++;//交换次数+1
    return low;
}
void QSort(SqList &L,int low,int high)//对顺序表的子序列作快速排序 
{
    int pivotloc;
    if(low<high)
    {
        pivotloc=Partition(L,low,high);
        QSort(L,low,pivotloc-1);
        QSort(L,pivotloc+1,high);
    }
}

void QuickSort(SqList &L)//对顺序表L作快速排序 
{
    QSort(L,1,L.length);
}


void ShellSort(SqList &L)//希尔排序 
{
    int dh,i,j;
    dh=L.length/2;
    while(dh>=1){
        for( i=dh;i<=L.length;i++){
            L.elem[0].key=L.elem[i].key;
            yd5+=1;//交换次数+1
            j=i-dh;
            while(j>=0&&L.elem[j].key>L.elem[0].key){
                L.elem[j+dh].key =  L.elem[j].key;
                bj5+=1;//比较次数+1
                yd5+=1;//交换次数+1    
                j-=dh;
            }
            L.elem[j+dh].key =  L.elem[0].key;
            yd5+=1;//交换次数+1    
        }
        dh/=2;
    }
}

/*
*调整数组A中以K为根的子序列为堆，其中最大的元素下标为m
*假设以2k,2k+1为根的左右子树均是堆
*/
void HeapAdjust(SqList &L,int k,int m)
{
    int i,j,x;
    int finished = 0;

    x =L.elem[k].key;//临时保存当前根植
    yd6+=1;//交换次数+1
    i = k;//指示空位
    j = 2*i;//j先指向其左孩子结点
    while(j<=m &&!finished)//确定i结点不是叶子节点且搜索未结束
    {
        if((j<m)&&(L.elem[j].key<L.elem[j+1].key))
        {
            j++;//让j指向左右孩子中的最大者
            bj6++;//比较次数+1
        }
        if(x>=L.elem[j].key)finished = 1;//若原根最大，置搜索和帅选结束标志
        else{
            L.elem[i].key = L.elem[j].key;//大的孩子结点值上移
            yd6+=1;//交换次数+1
            i = j;//继续往下帅选：i指示新的空位，j相应改变
            j*=2;
        }
    }
    L.elem[i].key = x;//将原根值填充到所搜索到的当前的空位置中
    yd6+=1;//交换次数+1
}


void HeapSort(SqList &L)
{
    int i;

    for(i=L.length/2;i>=1;i--)
    {
        HeapAdjust(L,i,n);//建初始堆
    }
    for(i=L.length;i>=2;i--)//控制排序过程
    {
        
        L.elem[0] = L.elem[1];
        L.elem[1] = L.elem[i];
        L.elem[i] = L.elem[0];
        yd6+=3;//交换次数+3
        HeapAdjust(L,1,i-1);//调整子序列Array[1]~Array[i-1]为堆
    }
    
}

void  print(SqList &L)//输出顺序表重元素
{
    int i;
    for(i=1;i<=L.length;i++)
    {
        printf("%d  ",L.elem[i]);
        if(i%5==0)printf("\n");
    }
    printf("\n");
}

int  main()
{

    int a,flags  = 1;
    while(flags)
    {
        printf(" -------------内部排序------------------\n");
        printf("|-------------欢迎使用------------------|\n");
        printf("|-----------(1)运行程序-----------------|\n");
        printf("|-----------(0)退出系统 ----------------|\n");
        printf("请选择:");
        scanf("%d",&a);
        while(a!=0&&a!=1)
        {
            printf("输入有误,请输入0|1:");
            scanf("%d",&a);
        }
        switch(a)
        {
        case 0:
            printf("谢谢使用!\n");
            flags = 0;
            break;
        case 1:
            system("cls");//清屏
            SqList L,M;
            M.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));
            if(!M.elem)exit(0);
            bj1=0,yd1=0,bj2=0,yd2=0,bj3=0,yd3=0,bj4=0,yd4=0,bj5=0,yd5=0,bj6=0,yd6=0;
            Createlist(L);
            Random(L);//产生数据

            Memory(M,L);
            BubbleSort(M);//冒泡排序

            Memory(M,L);
            InsertSort(M);//插入排序

            Memory(M,L);
            SelectSort(M);//选择排序

            Memory(M,L);
            QuickSort(M);//快速排序

            Memory(M,L);
            ShellSort(M);//希尔排序

            Memory(M,L);
            HeapSort(M);//堆排序

            printf("         比较次数      移动次数\n");
            printf("冒泡排序:%d\t\t%d\n",bj1,yd1);
            printf("直接插入:%d\t\t%d\n",bj2,yd2);
            printf("简单选择:%d\t\t%d\n",bj3,yd3);
            printf("快速排序:%d\t\t%d\n",bj4,yd4);
            printf("希尔排序:%d\t\t%d\n",bj5,yd5);
            printf("堆排序:  %d\t\t%d\n",bj6,yd6);
            break;
        }
    }
    return 0;    
}