PTA7-12 排序 (冒泡排序+直接插入+希尔排序+堆排序)

PTA7-12 排序 (冒泡排序+直接插入+希尔排序+堆排序)

给定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

首先附上各种排序的时间空间复杂度稳定性表

图片来源于：https://blog.csdn.net/lovecyr/article/details/90437947

1 冒泡排序

最基础简单的排序之一，可惜测试点不能全过！，但依然保留参考。

#include<stdio.h>
#include<stdlib.h>

#define MAXNUM 100000
typedef int ElementType;
int N;
ElementType A[MAXNUM];

void Bubble_Sort(ElementType A[],int N)
{
   int p,flag,i,tmp;
   for(p=N-1;p>=0;p--)
   {
      flag=0;标志是否产生过交换,解决提前排好序的情况
      for(i=0;i<p;i++)
      {
         if(A[i]>A[i+1])
         {
            tmp=A[i+1];
            A[i+1]=A[i];
            A[i]=tmp;
            flag=1;
         }
      }
      if(flag==0)
         break;
   }
}

int main()
{
   int i;
    scanf("%d",&N);
    for(i=0;i<N;i++)
    {
        scanf("%d",&A[i]);
    }
    Bubble_Sort(A,N);
    for(i=0;i<N-1;i++)
    {
        printf("%d ",A[i]);
    }
    printf("%d",A[N-1]);
    return 0;
}

检测情况：

2 直接插入排序：

也是最基础简单的排序之一啦，测试点居然能全过，冒泡不服！！

#include<stdio.h>
#include<stdlib.h>
#define MAXNUM 100000

typedef int ElementType;
int N;
ElementType A[MAXNUM];

void Insertion_Sort(ElementType A[],int N)
{
   int i,p,tmp;
   for(p=1;p<N;p++)
   {
      tmp=A[p];
      for(i=p;i>0&&A[i-1]>tmp;i--)
      {
         A[i]=A[i-1];
      }
      A[i]=tmp;
   }
}

int main()
{
    int i;
    scanf("%d",&N);
    for(i=0;i<N;i++)
    {
        scanf("%d",&A[i]);
    }
    Insertion_Sort(A,N);
    for(i=0;i<N-1;i++)
    {
        printf("%d ",A[i]);
    }
    printf("%d",A[N-1]);
    return 0;
}

检测情况：

3 希尔排序

改进版的插入排序，相对于冒泡和直接插入，希尔排序要快很多
AC代码：

#include<stdio.h>
#include<stdlib.h>
#define MAXNUM 100000

void Shell_Sort(int A[],int N)
{
   int D,P,tmp,i;
   for(D=N/2;D>0;D/=2)//原始希尔序列
   { 
      for(P=D;P<N;P++)
      {
         tmp=A[P];
         for(i=P;i>=D&&A[i-D]>tmp;i-=D)
         {
            A[i]=A[i-D];
         }
         A[i]=tmp;
      }
   }
}

int main()
{
   int A[MAXNUM];
   int N,i;
   scanf("%d",&N);
   for(i=0;i<N;i++)
   {
       scanf("%d",&A[i]);
   }
   Shell_Sort(A,N);
   for(i=0;i<N-1;i++)
   {
       printf("%d ",A[i]);
   }
   printf("%d",A[N-1]);
   return 0;
}

检测情况：

4 堆排序

AC代码：

#include<stdio.h>
#include<stdlib.h>
#define MAXNUM 100000

int A[MAXNUM];
int N;

void Down_Adjust(int i,int N)
{
   int tmp;
   while(i*2+1<N)//存在子结点
   {
      int child=i*2+1;
      if(child+1<N&&A[child]>A[child+1])//保证child指向较小的子结点
      {
         child++;
      }
      if(A[i]>A[child])
      {
         tmp=A[child];
         A[child]=A[i];
         A[i]=tmp;
      }
      else
         break;
      i=child;
   }
} 

void Heap_Sort(int N)
{
   int i,tmp;
   for(i=N/2;i>=0;i--)//最后面的非叶节点位置就是N/2
      Down_Adjust(i,N);
   for(i=N;i>0;i--)
   {
      tmp=A[i-1];
      A[i-1]=A[0];
      A[0]=tmp;
      Down_Adjust(0,i-1);//减小调整范围
   }
}

int main()
{
   int i;
   while(scanf("%d",&N)!=EOF)
    {
        for(i=0;i<N;i++)
        {
            scanf("%d",&A[i]);
        }
        Heap_Sort(N);
        for(i=N-1;i>=0;i--)
        {
            if(i!=0)
                printf("%d ",A[i]);
            else
                printf("%d\n",A[i]);
        }
    }
    return 0;
}

检测情况：
如有问题欢迎联系我或下方留言！