数据结构与算法——7-12 排序 (25分)（排序方法总结）

最新推荐文章于 2022-01-02 17:34:50 发布
最新推荐文章于 2022-01-02 17:34:50 发布
阅读量4.1k 收藏 78
点赞数 23
分类专栏： 数据结构与算法 文章标签： 排序算法 数据结构 算法 归并排序 堆排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qazwsxxxxxasd/article/details/107299672
版权

7-12 排序 (25分)

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

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

数据1：只有1个元素；
数据2：11个不相同的整数，测试基本正确性；
数据3：103个随机整数；
数据4：104个随机整数；
数据5：105个随机整数；
数据6：105个顺序整数；
数据7：105个逆序整数；
数据8：105个基本有序的整数；
数据9：105个随机正整数，每个数字不超过1000。
输入格式:
输入第一行给出正整数N（≤105 ），随后一行给出N个（长整型范围内的）整数，其间以空格分隔。

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

思路：正好来总结一下排序方法把

1.直接使用库函数快排

懒狗方法 qsort()

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

int cmp(const void *a,const void *b)
{
    return *(int*)a-*(int*)b;
}

int main()
{
    int n;
    scanf("%d",&n);
    int a[n];
    for(int i=0;i<n;i++)
    {
        scanf("%d",&a[i]);
    }
    qsort(a,n,sizeof(a[0]),cmp);
    printf("%d",a[0]);
    for(int i=1;i<n;i++)
    {
        printf(" %d",a[i]);
    }
}

2.冒泡排序

（但在这道题中，数据量大的情况下 会超时）这里只是总结一下排序方法

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

void BubbleSort(int a[],int n)
{
    int i,j;
    int flag=1;
    int temp;
    for(i=0;i<n&&flag;i++)
    {
        flag=0;
        for(j=n-1;j>=i;j--)
        {
            if(a[j]>a[j+1])
            {
                temp=a[j];
                a[j]=a[j+1];
                a[j+1]=temp;
                flag=1;
            }
        }
    }
}

int main()
{
    int n;
    scanf("%d",&n);
    int a[n];
    for(int i=0;i<n;i++)
    {
        scanf("%d",&a[i]);
    }
    BubbleSort(a,n);
    printf("%d",a[0]);
    for(int i=1;i<n;i++)
    {
        printf(" %d",a[i]);
    }
}

3.选择排序

（会超时）

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

void swap(int a[],int i,int j)
{
    int temp=a[i];
    a[i]=a[j];
    a[j]=temp;
}

void SelectSort(int a[],int n)
{
    int i,j,min;
    for(i=0;i<n;i++)
    {
        min=i;
        for(j=i+1;j<n;j++)
        {
            if(a[min]>a[j])
                min=j;
        }
        if(i!=min)
        {
        swap(a,i,min);
        }
    }
}

int main()
{
    int n;
    scanf("%d",&n);
    int a[n];
    for(int i=0;i<n;i++)
    {
        scanf("%d",&a[i]);
    }
    SelectSort(a,n);
    printf("%d",a[0]);
    for(int i=1;i<n;i++)
    {
        printf(" %d",a[i]);
    }
}

4.插入排序

思路就是将一个记录插入到已经排好序的有序表中，从而得到一个新的，记录数新增1的有序表

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


void InsertSort(int r[],int n)
{
    int i,j,temp;
    for(i=1;i<n;i++)
    {
        temp=r[i];//摸下一张牌
        for(j=i;temp<r[j-1]&&j>0;j--)//从后往前比较，摸得牌如果比前面那张牌小  前面那张牌后移
        {                            //一直比较到j=0
            r[j]=r[j-1];
        }
        r[j]=temp;//新牌落位
    }
}



int main()
{
    int n;
    scanf("%d",&n);
    int a[n];
    for(int i=0;i<n;i++)
    {
        scanf("%d",&a[i]);
    }
    InsertSort(a,n);
    printf("%d",a[0]);
    for(int i=1;i<n;i++)
    {
        printf(" %d",a[i]);
    }
}

5.希尔排序

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


void ShellSort(int r[],int n)
{
    int i,j,temp;
    int increment;
    for(increment=n/2;increment>0;increment/=2)//增量序列
    {
        for(i=increment;i<n;i++)
        {
            temp=r[i];//摸下一张牌
            for(j=i;j>=increment&&temp<r[j-increment];j-=increment)
            {
                r[j]=r[j-increment];
            }
            r[j]=temp;//新牌落位
        }
    }
}



int main()
{
    int n;
    scanf("%d",&n);
    int a[n];
    for(int i=0;i<n;i++)
    {
        scanf("%d",&a[i]);
    }
    ShellSort(a,n);
    printf("%d",a[0]);
    for(int i=1;i<n;i++)
    {
        printf(" %d",a[i]);
    }
}

6.堆排序

基本思想，将待排序的序列构造成一个大顶堆，此时，整个序列的最大值就是堆顶的根结点，将他移走（其实就是将其与堆数组的末尾元素交换，此时末尾元素就是最大值），然后将剩余的n-1个序列重新构造成一个堆，这样就会得到n个元素中的次大值。如此反复执行，便能得到一个有序序列

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

typedef int ElementType;

void Swap( ElementType *a, ElementType *b )
{
     ElementType t = *a; *a = *b; *b = t;
}
  
void PercDown( ElementType A[], int p, int N )
{  /* 将N个元素的数组中以A[p]为根的子堆调整为最大堆 */
    int Parent, Child;
    ElementType X;
 
    X = A[p]; /* 取出根结点存放的值 */
    for( Parent=p; (Parent*2+1)<N; Parent=Child ) {
        Child = Parent * 2 + 1;//序号从0 开始 左孩子 2parent+1
        if( (Child!=N-1) && (A[Child]<A[Child+1]) )
            Child++;  /* Child指向左右子结点的较大者 */
        if( X >= A[Child] ) break; /* 找到了合适位置 */
        else  /* 下滤X */
            A[Parent] = A[Child];
    }
    A[Parent] = X;
}
 
void HeapSort( ElementType A[], int N ) 
{ /* 堆排序 */
     int i;
       
     for ( i=N/2-1; i>=0; i-- )/* 建立最大堆 */
         PercDown( A, i, N );//以A[i]为根建立最大堆
      
     for ( i=N-1; i>0; i-- ) {
         /* 删除最大堆顶 */
         Swap( &A[0], &A[i] ); //交换根结点和末尾元素
         PercDown( A, 0, i );
     }
}



int main()
{
    int n;
    scanf("%d",&n);
    int a[n];
    for(int i=0;i<n;i++)
    {
        scanf("%d",&a[i]);
    }
    HeapSort(a,n);
    printf("%d",a[0]);
    for(int i=1;i<n;i++)
    {
        printf(" %d",a[i]);
    }
}

7.归并排序

就是利用归并的思想实现的排序方法，假设初始序列含有n个记录，则可以看成是n个有序的子序列，每个子序列的长度为1，然后两两归并，得到⌈n/2⌉(⌈x⌉表示不小于x的最小整数）个长度为2或1的有序子序列，再两两归并…如此重复，直至得到一个长度为n的有序子序列为止，这样就是2路归并排序

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

typedef int ElementType;

/* 归并排序 - 递归实现 */
 
/* L = 左边起始位置, R = 右边起始位置, RightEnd = 右边终点位置*/
void Merge( ElementType A[], ElementType TmpA[], int L, int R, int RightEnd )
{ /* 将有序的A[L]~A[R-1]和A[R]~A[RightEnd]归并成一个有序序列 */
     int LeftEnd, NumElements, Tmp;
     int i;
      
     LeftEnd = R - 1; /* 左边终点位置 */
     Tmp = L;         /* 有序序列的起始位置 */
     NumElements = RightEnd - L + 1;
      
     while( L <= LeftEnd && R <= RightEnd ) {
         if ( A[L] <= A[R] )
             TmpA[Tmp++] = A[L++]; /* 将左边元素复制到TmpA */
         else
             TmpA[Tmp++] = A[R++]; /* 将右边元素复制到TmpA */
     }
 
     while( L <= LeftEnd )
         TmpA[Tmp++] = A[L++]; /* 直接复制左边剩下的 */
     while( R <= RightEnd )
         TmpA[Tmp++] = A[R++]; /* 直接复制右边剩下的 */
          
     for( i = 0; i < NumElements; i++, RightEnd -- )
         A[RightEnd] = TmpA[RightEnd]; /* 将有序的TmpA[]复制回A[] */
}
 
void Msort( ElementType A[], ElementType TmpA[], int L, int RightEnd )
{ /* 核心递归排序函数 */ 
     int Center;
      
     if ( L < RightEnd ) {
          Center = (L+RightEnd) / 2;
          Msort( A, TmpA, L, Center );              /* 递归解决左边 */ 
          Msort( A, TmpA, Center+1, RightEnd );     /* 递归解决右边 */  
          Merge( A, TmpA, L, Center+1, RightEnd );  /* 合并两段有序序列 */ 
     }
}
 
void MergeSort( ElementType A[], int N )
{ /* 归并排序 */
     ElementType *TmpA;
     TmpA = (ElementType *)malloc(N*sizeof(ElementType));
      
     if ( TmpA != NULL ) {
          Msort( A, TmpA, 0, N-1 );
          free( TmpA );
     }
     else printf( "空间不足" );
}



int main()
{
    int n;
    scanf("%d",&n);
    int a[n];
    for(int i=0;i<n;i++)
    {
        scanf("%d",&a[i]);
    }
    MergeSort(a,n);
    printf("%d",a[0]);
    for(int i=1;i<n;i++)
    {
        printf(" %d",a[i]);
    }
}
吃完有点累
关注
专栏目录
例7-12 选择排序法 对数组中10个整数按由小到大进行排序
Claire的博客
10-17 340
/* 例7-12 选择排序法 对数组中10个整数按由小到大进行排序 */ #include<stdio.h> int main(void) { void sort(int *array,int n); int a[10],i; printf("enter array:\n"); for(i=0;i<10;i++) { scanf("%d",&a[i]); } sort(a,10); printf("The sorted array:\n");
数据结构与算法——12. 冒泡排序和选择排序
花城的博客
11-25 1417
文章目录一、冒泡排序（Bubble Sort）python代码实现算法分析改进冒泡排序算法二、选择排序（Selection Sort）python代码实现算法分析 排序算法可视化演示：传送门，这些演示可以帮助我们跟好的理解这些排序算法。 下面的算法的实现，均以从小到大排序作为目的。 一、冒泡排序（Bubble Sort） 冒泡排序的算法思路在于对无序表进行多趟比较交换。 每趟包括了多次两两相邻比较，并将逆序的（小项在大项后面的）数据项互换位置，最终能将本趟的最大项就位。 经过n-1趟比较交换，实现整表排
C++实现PTA题目--排序
haha_7的博客
11-20 619
给定N个（长整型范围内的）整数，要求输出从小到大排序后的结果。 本题旨在测试各种不同的排序算法在各种数据情况下的表现。各组测试数据特点如下： 数据1：只有1个元素； 数据2：11个不相同的整数，测试基本正确性； 数据3：103个随机整数； 数据4：104个随机整数； 数据5：105个随机整数； 数据6：105个顺序整数； 数据7：105个逆序整数； 数据8：105个基本有序的整数； 数据9：105个随机正整数，每个数字不超过1000。 输入格式: 输入第一行给出正整数N（≤10 ​5 ​​ ），随后一行给出
7-12 排序 (25分)
AlenSmithing的博客
11-15 654
给定N个（长整型范围内的）整数，要求输出从小到大排序后的结果。 本题旨在测试各种不同的排序算法在各种数据情况下的表现。各组测试数据特点如下： 数据1：只有1个元素； 数据2：11个不相同的整数，测试基本正确性； 数据3：10^3个随机整数； 数据4：10^4个随机整数； 数据5：10^5个随机整数； 数据6：10^5个顺序整数； 数据7：10^5个逆序整数； 数据8：10^5个基本有序的整数； 数据9：10^5个随机正整数，每个数字不超过1000。 输入格式: 输入第一行给出正整数N（≤10^5 ），随后一
7-12 排序
m0_62895495的博客
01-02 1574
选择排序
06-图1 列出连通集
Jingwang Li
11-17 578
06-图1 列出连通集（25 分） 给定一个有N个顶点和E条边的无向图，请用DFS和BFS分别列出其所有的连通集。假设顶点从0到N−1编号。进行搜索时，假设我们总是从编号最小的顶点出发，按编号递增的顺序访问邻接点。 输入格式: 输入第1行给出2个整数N(0 #include &lt;iostream&gt; using namespace std; const int maxSize=15...
华中科技大学数据结构与算法分析实验-内部排序实验报告
最新发布
04-05
《内部排序算法实践与分析——华中科技大学数据结构与算法实验报告》 内部排序是计算机科学中的重要领域，涉及各种算法的设计与优化。本实验旨在深入理解并掌握常见内部排序算法，包括直接插入排序、冒泡排序、简单...
比KMP更快的字符串匹配算法——BM算法，排序算法数据结构 最快的排序算法
04-07
BM算法和排序算法数据结构 BM算法是比KMP更快的字符串匹配算法，它的理论时间复杂度也是O(n+m)，但实际上它的平均速度比KMP快很多。BM算法的原理是考虑O(nm)的暴力对比进进行字符串匹配，我们总是希望某次失配后能...
数据结构课程设计五——排序算法综合分析.doc
06-03
数据结构课程设计五——排序算法综合分析 该资源是一个数据结构课程设计的五个部分，主要讲解排序算法的综合分析。该资源涵盖了多种排序算法，包括直接插入排序、希尔排序、快速排序、冒泡排序、堆排序和归并法排序...
7种常用排序算法实现（C++）（冒泡排序、选择排序、直接插入排序、希尔排序、堆排序、归并排序以及快速排序）
04-11
本文件是7种常用排序算法的实现（C++），包括冒泡排序、选择排序、直接插入排序、希尔排序、堆排序、归并排序以及快速排序。代码详细有注释且有测试用例。
7-12 排序 （25 分）
qq_40941611的博客
11-01 618
题目链接 这次 JAVA 又超内存了。 还是用C++写过的； C++ code： #include &lt;iostream&gt; #include &lt;cstdio&gt; #include &lt;cstring&gt; #include &lt;algorithm&gt; using namespace std; int num[100005]; int main(){ ...
7-12 排序 (25 分)
姚军
10-20 316
#include<cstdio> #include<algorithm> using namespace std; const int maxn=1e5+5; int arr[maxn]; int main(){ int n; scanf("%d",&n); for(int i=0;i<n;i++){ scanf("%d",&arr[i]);...
09-排序1 排序 (25分)
WR的博客
11-10 365
09-排序1 排序 (25分) 给定N个（长整型范围内的）整数，要求输出从小到大排序后的结果。 本题旨在测试各种不同的排序算法在各种数据情况下的表现。各组测试数据特点如下：
数据结构与算法题目集7-12——排序
清风阁
12-01 481
我的数据结构与算法题目集代码仓：https://github.com/617076674/Data-structure-and-algorithm-topic-set 原题链接：https://pintia.cn/problem-sets/15/problems/720 题目描述： 知识点：排序 思路：用sort函数排序 时间复杂度是O(NlogN)。空间复杂度是O(N)。 C++...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值