c语言 数据结构 排序算法小结

7-18 排序（25 分）

给定N个（长整型范围内的）整数，要求输出从小到大排序后的结果。

本题旨在测试各种不同的排序算法在各种数据情况下的表现。各组测试数据特点如下

数据1：只有1个元素；

数据2：11个不相同的整数，测试基本正确性；

数据3：103个随机整数；

数据4：104个随机整数；

数据5：105个随机整数；

数据6：105个顺序整数；

数据7：105个逆序整数；

数据8：105个基本有序的整数；

数据9：105个随机正整数，每个数字不超过1000。

输入格式:

输入第一行给出正整数N（≤10​5​​），随后一行给出N个（长整型范围内的）整数，其间以空格分隔。

输出格式:

在一行中输出从小到大排序后的结果，数字间以1个空格分隔，行末不得有多余空格。

输入样例:

11
4 981 10 -17 0 -20 29 50 8 43 -5

输出样例:

-20 -17 -5 0 4 8 10 29 43 50 981

下面就是各种算法了；

#include <stdio.h>
#include <stdlib.h>
/*****/
void swap(long long *x,long long *y)
{
    long long sw;
    sw=*y;
    *y=*x;
    *x=sw;
}
int text(long long *arr,int n) /**改进的地方，待排序数组 随机抽10个 然后看 以小到大的数据有几个 然后 看看进行什么堆排序**/
{
    if(n==1) return 1;
    int step = n/10;
    int i,test=1,x;
    for(i=1;i<=n;i+=step)
    {
        if(i==1) x= arr[1];
        else
        {
            if(x<arr[i])
            {
                x=arr[i];
                test++;
            }
        }
    }
    return test;
}
int compare(long long x,long long y,int flag)
{
    if(flag)
    {
        if(x>=y) return 1;
        else return 0;
    }
    else
    {
        if(x<=y) return 1;
        else return 0;
    }
}


void perdown(long long *arr,int p,int n,int flag)
{
    int parent,children;
    long long x =arr[p];
    for(parent=p;parent*2<n;parent=children)
    {
        children = parent*2;
        if(children+1!=n&&!compare(arr[children],arr[children+1],flag))
            children++;
        if(compare(x,arr[children],flag)) break;
        else arr[parent] = arr[children];
    }
    arr[parent]=x;
}
void heapsort(long long *arr,int n,int flag)
{
    int i;
    for(i=n/2;i>=1;i--)
        perdown(arr,i,n,flag);
    for(i=n;i>1;i--)
    {
        swap(&arr[1],&arr[i]);
        perdown(arr,1,i,flag);
    }
}
/**以上几个函数 是 改良版堆排序 可以根据待排序数组 来进行大顶堆堆排序还是小顶堆排序**/
/**大顶堆不适合排序从小到大的数组，小顶堆不适合排序从大到小的数组**/
void sort1(long long *arr,int n)
{
    int i,j,f;
    for(i=n;i>1;i--)
    {
        f=1;
        for(j=1;j<i;j++)
        {
            if(arr[j]>arr[j+1])
            {
                swap(&arr[j],&arr[j+1]);
                f=0;
            }
        }
        if(f) break;
    }
}
/**这是 非常 简单的冒泡排序 好处就是简单**/
void sort2(long long *arr,int L,int R)
{
    if(L>=R) return;
    if(R-L>=-1)
    {
        int l=L,r=R-1;
        while(1)
        {
            while(arr[l]<arr[R]) l++;
            while(arr[r]>arr[R]) r--;
            if(l<r)swap(&arr[l],&arr[r]);
            else break;
        }
        swap(&arr[l],&arr[R]);
        sort2(arr,l+1,R);
        sort2(arr,L,l-1);
    }
    else sort1(arr+L-1,R-L+1);
}
/**这是 快速排序，大体思路就是把数据分成 有序的 数局小组 然后每个小组用 别的排序方法做，数据少的时候，排序很快**/
void deal(long long *arr,int n)
{
    int setwith[]={929,505,209,109,41,19,5,1,0};
    int si,i,j,D,P,TMP;
    for(si=0;setwith[si]>=n;si++);
    for(D=setwith[si];D>0;D=setwith[++si])
    {
        for(P=D+1;P<=n;P+=D)
        {
            TMP=arr[P];
            for(i=P;i>=D&&arr[i-D]>TMP;i-=D)
            {
                arr[i]=arr[i-D];
            }
            arr[i]=TMP;
        }
    }
}
/**希尔排序 就是 插入排序的进化版，比如 从小到大排序，将数组 大体上 就是隔几个 进行排序 ，慢慢越排越细**/
/**但是 希尔排序 还是仅仅是插入排序 如果数组是从大到小 而要求从小到大排 ，还是时间很多，不适合逆序排序**/
int main()
{
    int n,i,j,flag;
    long long *arr;
    scanf("%d",&n);
    arr=(long long*)malloc((n+2)*sizeof(long long));
    for(i=1;i<=n;i++)
        scanf("%lld",&arr[i]);
    /*if(text(arr,n)<=3) flag=1;
    else flag=0;
    heapsort(arr,n,flag);
    if(flag)
    {
        int f=1;
        for(i=1;i<=n;i++)
        {
            if(f) f=0;
            else printf(" ");
            printf("%lld",arr[i]);
        }
    }
    else
    {
        int f=1;
        for(i=n;i>=1;i--)
        {
            if(f) f=0;
            else printf(" ");
            printf("%lld",arr[i]);
        }
    }*/
    deal(arr,n);
    flag=1;
    for(i=1;i<=n;i++)
    {
        if(flag) flag=0;
        else printf(" ");
        printf("%lld",arr[i]);
    }
    return 0;
}