排序算法总结

已于 2024-05-03 11:12:40 修改
阅读量355 收藏 1
点赞数 2
分类专栏： 【算法竞赛】 # 排序搜索 文章标签： 算法 排序算法
于 2018-11-24 20:08:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40772692/article/details/84451678
版权

目录

一. 前言

二. 交换排序

1. 冒泡排序（平均复杂度n^2）

2. 快速排序（平均复杂度nlogn）

三. 插入排序

1. 直接插入排序（平均复杂度n^2）

2. 折半插入排序（时间复杂度n^2）

3. 表插入排序

四. 选择排序

1. 简单选择排序（平均复杂度n^2）

2. 堆排序算法（平均复杂度nlogn）

五. 归并排序

六. 基数排序

七. 排序总结

一. 前言

        常见的共九大排序算法，可分为内部排序（小文件排序）和外部排序（大文件排序）两大类，本文将重点介绍内部排序。

        注意：后文中排序算法的稳定性指的是能保证排序前2个相等的数，其在序列的前后位置顺序和排序后它们两个的前后位置顺序相同。再简单形式化一下即如果Ai = Aj且Ai原来在位置前，则排序后Ai还是要在Aj位置前。

二. 交换排序

1. 冒泡排序（平均复杂度n^2）

（1）基本版

执行趟数：n-1 ；  比较次数：n*(n-1)/2

交换次数：min：有序0 ； max：逆序 n*(n-1)/2

稳定性：稳定

        算法特点是双层循环，外层循环循环比较趟数，内层循环比较起点。每轮循环必定会把剩余部分最大的沉到最后或者把最小的浮到最上面而且其他元素的相对位置不改变。

#include <iostream>
#include<bits/stdc++.h>
using namespace std;
const int maxn = 1000 + 7;
int Data[maxn],n;
int main()
{
    scanf("%d",&n);
    for(int i = 0;i<n;i++)scanf("%d",&Data[i]);
    for(int i = 0;i<n;i++){
        if(i==0)printf("%d",Data[i]);
        else printf(" %d",Data[i]);
    }
    printf("\n");
    for(int i = 0;i<n;i++){
        for(int j = n-1;j>i;j--){
            if(Data[j] < Data[j-1])swap(Data[j],Data[j-1]);
        }
    }
    for(int i = 0;i<n;i++){
        if(i==0)printf("%d",Data[i]);
        else printf(" %d",Data[i]);
    }
    printf("\n");
    return 0;
}

（2）优化版

执行趟数：min：有序 1 ；max：逆序：n-1

比较次数：min：有序n-1次 ；max：逆序 n*(n-1)/2

交换次数： min：有序0 ； max：逆序 n*(n-1)/2

#include <iostream>
#include<bits/stdc++.h>
using namespace std;
const int maxn = 1000 + 7;
int Data[maxn],n;
int main()
{
    scanf("%d",&n);
    for(int i = 0;i<n;i++)scanf("%d",&Data[i]);
    for(int i = 0;i<n;i++){
        if(i==0)printf("%d",Data[i]);
        else printf(" %d",Data[i]);
    }
    printf("\n");
    int i = n-1;//末位置
    while(i){
        int pos = 0;//记录最后一次交换的位置
        for(int j = 0;j<i;j++){
            if(Data[j] > Data[j+1]){
                swap(Data[j],Data[j+1]);
                pos = j;//发生交换
            }
        }
        i = pos;//记录位置
    }
    for(int i = 0;i<n;i++){
        if(i==0)printf("%d",Data[i]);
        else printf(" %d",Data[i]);
    }
    printf("\n");
    return 0;
}

2. 快速排序（平均复杂度nlogn）

        其思想是每次排序选取一个基准，小于基准的都放在左边，大于基准的都放在右边，然后递归排序左右区间。其算法特点是每次排序都把序列划分为独立的两部分，一部分记录的关键字均比另一部分的小。

稳定性：不稳定

举例：初始  {2, 12, 16, 88, 5, 10, 34}

以最右边为基准进行快速排序：

第一趟快排后： 2 , 12 , 16 , 10 , 5 , 34 , 88

第二趟快排后：2, 5, 10, 12, 16, 34, 88

注意：当初始记录有序或者基本有序时，快速排序退化为冒泡排序，复杂度O（n^2）  

#include <iostream>
#include<bits/stdc++.h>
using namespace std;
const int maxn = 1000 + 7;
int Data[maxn],n;
int Parttion(int low,int high){
    int temp = Data[low];//选取基准
    while(low < high){
        while(low < high&&Data[high]>=temp)high--;//从右往左找第一个小于基准的
        Data[low] = Data[high];//放在左边
        while(low < high&&Data[low]<=temp)low++;//从左往右找第一个大于基准的
        Data[high] = Data[low];//放在右边
    }
    Data[low] = temp;//最后更新基准位置
    return low;
}
void Qsort(int low,int high){
    if(low >= high)return;
    int pos = Parttion(low,high);//基准最终位置
    Qsort(low,pos-1);//递归左区间
    Qsort(pos+1,high);//递归右区间
}
int main()
{
    scanf("%d",&n);
    for(int i = 0;i<n;i++){
        scanf("%d",&Data[i]);
    }
    for(int i = 0;i<n;i++){
        if(i==0)printf("%d",Data[i]);
        else printf(" %d",Data[i]);
    }
    printf("\n");

    Qsort(0,n-1);

    for(int i = 0;i<n;i++){
        if(i==0)printf("%d",Data[i]);
        else printf(" %d",Data[i]);
    }
    printf("\n");
    return 0;
}

三. 插入排序

1. 直接插入排序（平均复杂度n^2）

执行趟数：n-1

比较次数：min：有序 n-1 ；max：逆序 (n+2)*(n-1)/2

移动次数：min：有序 0；max：逆序 (n+4)*(n-1)/2

最好：顺序 O(n)

最差：逆序 O(n^2)

稳定性：稳定

        其算法思想是假设前i项已经排好序，插入第i项，找到插入位置插入，后面元素后移。其算法特点是第i次循环结束，前i个元素必定有序，但不一定是最终结果。且其他元素相对位置不变。

#include <iostream>
#include<bits/stdc++.h>
using namespace std;
const int maxn = 1000 + 7;
int Data[maxn],n,j;
int main()
{
    scanf("%d",&n);
    for(int i = 1;i<=n;i++)scanf("%d",&Data[i]);
    for(int i = 1;i<=n;i++){
        if(i==1)printf("%d",Data[i]);
        else printf(" %d",Data[i]);
    }
    printf("\n");
    for(int i = 2;i<=n;i++){
        if(Data[i] < Data[i-1]){//升序排序，找到插入元素
            Data[0] = Data[i];//Data[0]保存插入元素
            Data[i] = Data[i-1];
            for(j = i-2;Data[0] < Data[j]&&j>=0;j--){//寻找位置并且后移元素
                Data[j+1] = Data[j];
            }
            Data[j+1] = Data[0];//更新
        }
    }
    for(int i = 1;i<=n;i++){
        if(i==1)printf("%d",Data[i]);
        else printf(" %d",Data[i]);
    }
    printf("\n");
    return 0;
}

2. 折半插入排序（时间复杂度n^2）

        其算法思想是因为前i个数有序，所以二分插入位置，然后移动元素即可。相比直接插入，折半插入减少了比较次数，移动次数不变

#include <iostream>
#include<bits/stdc++.h>
using namespace std;
const int maxn = 1000 + 7;
int Data[maxn],n;
int main()
{
    scanf("%d",&n);
    for(int i = 0;i<n;i++){
        scanf("%d",&Data[i]);
    }
    for(int i = 0;i<n;i++){
        if(i==0)printf("%d",Data[i]);
        else printf(" %d",Data[i]);
    }
    printf("\n");
    for(int i = 1;i<n;i++){
        int l = 0,r = i-1;
        int temp = Data[i];
        while(l<=r){//寻找插入位置
            int mid = (l+r)>>1;
            if(Data[mid] > temp)r = mid-1;
            else l = mid+1;
        }
        for(int j = i;j>=r+1;j--)Data[j] = Data[j-1];//后移元素
        Data[r+1] = temp;//更新
    }
    for(int i = 0;i<n;i++){
        if(i==0)printf("%d",Data[i]);
        else printf(" %d",Data[i]);
    }
    printf("\n");
    return 0;
}

3. 表插入排序

（1）普通表插入排序（复杂度n^2）

思想：为了减少插入排序的移动次数，用改变指针来代替移动

缺点：只能顺序操作，因为为链表结构，无法随机存取元素

#include <iostream>
#include<bits/stdc++.h>
using namespace std;
#define INF 0x3f3f3f3f
const int maxn = 1000 + 7;
typedef struct{
    int data;
    int next;
}SLNode;
typedef struct{
    SLNode node[maxn];
    int len;
}SLinkList;
int n;
void TISort(SLinkList &L){
    L.node[0].data = INF;
    L.node[0].next = 1;//初始化循环链表，0为头节点
    L.node[1].next = 0;
    for(int i = 2;i<=L.len;i++){
        int j = 0;//寻找插入位置
        while(j<i&&L.node[L.node[j].next].data <= L.node[i].data)j = L.node[j].next;
        L.node[i].next = L.node[j].next;//改变指针指向
        L.node[j].next = i;
    }
}
int main()
{
    SLinkList List;
    scanf("%d",&n);
    List.len = n;
    for(int i = 1;i<=n;i++){
        scanf("%d",&List.node[i].data);
        List.node[i].next = -1;
    }

    TISort(List);

    bool flag = false;
    for(int i = List.node[0].next;i;i = List.node[i].next){//只能顺序输出
        if(!flag){
            printf("%d",List.node[i].data);
            flag = true;
        }
        else printf(" %d",List.node[i].data);
    }
    printf("\n");


    return 0;
}

（2）改进表插入排序

       其算法思想是根据指针调节位置。重排链表为顺序表，则能够执行二分操作。

#include <iostream>
#include<bits/stdc++.h>
using namespace std;
#define INF 0x3f3f3f3f
const int maxn = 1000 + 7;
typedef struct{
    int data;
    int next;
}SLNode;
typedef struct{
    SLNode node[maxn];
    int len;
}SLinkList;
int n;
void TISort(SLinkList &L){
    L.node[0].data = INF;
    L.node[0].next = 1;
    L.node[1].next = 0;
    for(int i = 2;i<=L.len;i++){
        int j = 0;
        while(j<i&&L.node[L.node[j].next].data <= L.node[i].data)j = L.node[j].next;
        L.node[i].next = L.node[j].next;
        L.node[j].next = i;
    }
}
void Arrange(SLinkList&L){//重排函数
    int p = L.node[0].next;
    for(int i = 1;i<=L.len;i++){//拍好第i个元素（前i个元素已经有序）
        while(p<i)p = L.node[p].next;//在有序区域，要找到真正该排序的元素
        int q = L.node[p].next;//获得下一个该插入的元素
        if(p!=i){
            swap(L.node[p],L.node[i]);//交换
            L.node[i].next = p;//防止下次再前i区域内查找
        }
        p  = q;//下次查找做准备
    }
}
int main()
{
    SLinkList List;
    scanf("%d",&n);
    List.len = n;
    for(int i = 1;i<=n;i++){
        scanf("%d",&List.node[i].data);
        List.node[i].next = -1;
    }

    TISort(List);

    bool flag = false;
    for(int i = List.node[0].next;i;i = List.node[i].next){
        if(!flag){
            printf("%d",List.node[i].data);
            flag = true;
        }
        else printf(" %d",List.node[i].data);
    }
    printf("\n");

    Arrange(List);//重排

    for(int i = 1;i<=List.len;i++){//下表输出
        if(i==1)printf("%d",List.node[i].data);
        else printf(" %d",List.node[i].data);
    }
    printf("\n");
    return 0;
}

（3）希尔排序（复杂度n^1.3）

最优：正序O（n）

最差：逆序O（n^2）

稳定性：不稳定

        其算法思想是利用分治法思想划分插入排序的区间，先插入排序小区间，在逐步合并的插入排序大区间，依据原理：直接插入排序的优点是：当序列有序时，插入排序复杂度为线性On。其算法特点是某轮排序，每隔一定间隔元素全部有序；算法时间复杂度与选取怎么步长有关。

#include <iostream>
#include<bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 7;
int Data[maxn],n;
void ShellSort(int a[],int len){
     for(int gap = len/2;gap > 0;gap/=2){//步长
        for(int j = gap;j<n;j++){//排序该步长下每个子区间
            if(a[j] > a[j-gap])continue;
            int temp = a[j];
            for(int k = j-gap;k>=0&&a[k] > temp;k-=gap){//每个子区间插入排序
                a[k+gap] = a[k];
            }
            a[k+gap] = temp;
        }
     }
}
int main()
{
    scanf("%d",&n);
    for(int i = 0;i<n;i++){
        scanf("%d",&Data[i]);
    }
    for(int i = 0;i<n;i++){
        if(i==0)printf("%d",Data[i]);
        else printf(" %d",Data[i]);
    }
    printf("\n");

    ShellSort(Data,n);//希尔排序

    for(int i = 0;i<n;i++){
        if(i==0)printf("%d",Data[i]);
        else printf(" %d",Data[i]);
    }
    printf("\n");
    return 0;
}

四. 选择排序

1. 简单选择排序（平均复杂度n^2）

操作趟数：n-1

比较次数：n*（n-1）/2

移动次数：min：有序0 ； max：逆序3*（n-1）

稳定性： 不稳定

        其算法特点是第i轮选择结束，前i个元素一定为最终结果中前i个元素。

#include <iostream>
#include<bits/stdc++.h>
using namespace std;
const int maxn = 10000 + 7;
int num[maxn],n;
int PosMin(int l,int r){
   int pos = l;
   int minn = num[l];
   for(int i = l;i<r;i++){
      if(minn > num[i]){
          minn = num[i];
          pos = i;
      }
   }
   return pos;
}
int main()
{
   scanf("%d",&n);
   for(int i = 0;i<n;i++){
     scanf("%d",&num[i]);
   }
   for(int i = 0;i<n;i++){
       int j = PosMin(i,n);//在[i,n)内选择最小的一个，排好前i个
       if(i!=j)swap(num[i],num[j]);
   }
   for(int i = 0;i<n;i++){
      if(i==0)printf("%d",num[i]);
      else printf(" %d",num[i]);
   }
   printf("\n");
   return 0;
}

2. 堆排序算法（平均复杂度nlogn）

优点：最好最坏情况下，堆排序均为nlogn复杂度

大顶堆：对于一个序列 , ai >= a2i && ai >= a(2i+1) 恒成立，可看作一个完全二叉树

小顶堆：对于一个序列 , ai <= a2i && ai <= a(2i+1) 恒成立，可看作一个完全二叉树

由小到大排序：选择大顶堆

由大到小排序：选择小顶堆

稳定性：不稳定

        堆排序算法是利用堆的性质，不断输出堆顶元素，然后调节堆结构使剩下的仍满足堆，如此反复得到的序列，则为堆排序。在实现时需要思考以下问题：

（1）问题一：怎么把一个无序序列建成一个大/小顶堆？

答：自下而上，先建成小部分的堆，后往上合并堆。

（2）问题二：怎么把一个堆输出堆顶后，调整剩余部分仍为堆？

答：自上而下，选择较大的元素交换至上。

#include <iostream>
#include<bits/stdc++.h>
using namespace std;
const int maxn = 10000 + 7;
int Data[maxn],n;
void HeadAdjust(int l,int r){//假设除了堆顶以外，其他都成大顶堆
   int temp = Data[l];
   int s = l;
   for(int j = 2*s;j<=r;j*=2){
      if(j+1<=r&&Data[j] < Data[j+1])j++;//j+1 <= r !!!!  不然已经排好序的叶子会被再拿上来
      if(temp >= Data[j])break;
      Data[s] = Data[j];
      s = j;
   }
   Data[s] = temp;
}
void HeapSort(){
   for(int i = n/2;i>=1;i--){//从最后一个非叶子结点（叶子结点肯定自为堆），往上由小到大建堆
       HeadAdjust(i,n);
   }
   for(int i = n;i>1;i--){//排序一个堆
       swap(Data[i],Data[1]);
       HeadAdjust(1,i-1);//调整剩余部分仍为堆
   }
}
int main()
{
    scanf("%d",&n);
    for(int i = 1;i<=n;i++){
        scanf("%d",&Data[i]);
    }
    HeapSort();
    for(int i = 1;i<=n;i++){
        if(i==1)printf("%d",Data[i]);
        else printf(" %d",Data[i]);
    }
    printf("\n");
}
//10
//-1 100 99 0 66 14 -20 0 8 54

五. 归并排序

复杂度：归并排序的最好、最坏、平均时间复杂度均为O(nlogn)

缺点：需要辅助空间O(n)

稳定性：稳定

        归并排序的算法思想是分治，即分而治之。其算法特点是每一部分都独立的呈现有序。

举例：初始序列 {1,0,12,66,40,14,9}

第一趟排序后： [0，1 ]，[ 12 ， 66]，[ 14 ， 40 ]，[ 9 ]

第二趟排序后： [ 0 ， 1 ， 12 ， 66 ] ， [ 9 ， 14 ， 40 ]

第三趟排序后：0 ， 1，9，12，14，40，66

        2-路归并的实现代码如下：

#include <iostream>
#include<bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 7;
int num[maxn],temp[maxn],n;
void MergeArray(int *A,int l,int r,int mid){
     int p = l,q = mid+1;
     int len = l;
     while(p<=mid||q<=r){
        if(p>mid||(q<=r&&A[q] < A[p]))temp[len++] = A[q++];
        else temp[len++] = A[p++];
     }
     for(int i = l;i<=r;i++)A[i] = temp[i];
}
void Merge_Sort(int *A,int l,int r){
    if(l < r){
        int mid = (l + r)>>1;
        Merge_Sort(A,l,mid);
        Merge_Sort(A,mid+1,r);//分
        MergeArray(A,l,r,mid);//合
    }
}
int main()
{
    scanf("%d",&n);
    for(int i = 0;i<n;i++){
        scanf("%d",&num[i]);
    }

    Merge_Sort(num,0,n-1);

    for(int i = 0;i<n;i++){
        if(i==0)printf("%d",num[i]);
        else printf(" %d",num[i]);
    }
    printf("\n");
    return 0;
}

六. 基数排序

        多关键字排序，分为MSD（最高位优先排序） ， 和LSD（最低位优先排序），这里放个图就明白啦！以LSD为例子：

        假设一个序列有n个记录，每个记录含有d个关键字（或者说每个记录长度为d，注意这里所有的记录都要统一长度；若为数字的话，长度不够前面补零）， 每个关键字取值范围为rd，则基数排序中，每一次分配的复杂度为O（n），每次收集的复杂度为O（rd），整个排序要用d趟分配和收集。总的时间复杂度为O(n + rd) = O（kn）

七. 排序总结

阿阿阿安
关注
专栏目录
十大经典排序算法总结.docx
08-24
《十大经典排序算法总结》 排序算法是计算机科学的基础，其设计思想和效率对软件的性能有着直接影响。本文主要探讨了十种经典的排序算法，包括它们的设计思路、优缺点以及适用场景，帮助我们理解排序算法的核心。 ...
C#排序算法总结
09-18
C#排序算法总结涵盖了交换排序和插入排序两大类排序算法，其中交换排序包括了冒泡排序、选择排序和快速排序，而插入排序则涉及直接插入排序和折半插入排序。下面将详细介绍每种排序算法的实现原理、特点以及在C#中的...
《数据结构》_PTA_数据结构作业8：排序
国家一级致癌物
12-30 7413
判断题 1-1 仅基于比较的算法能得到的最好的“最坏时间复杂度”是O(NlogN)。 T 1-2 对N个记录进行简单选择排序，比较次数和移动次数分别为O(N2)和O(N)。 T 1-3 对N个记录进行快速排序，在最坏的情况下，其时间复杂度是O(NlogN) F 1-4 希尔排序是稳定的算法。 F 1-5 对N个不同的数据采用冒泡排序进行从大到小的排序，当元素基本有序时交换元素次数肯定最多。 F 1-6 采用递归方式对顺序表进行快速排序，每次划分后，先处理较短的分区可以减少递归次数。 F 1-7 对N个记录进
数据结构作业——第十六周--排序
qq_46476515的博客
12-19 1286
数据结构第十六周作业——排序算法
算法与数据结构专项练习6
围巢
05-07 1255
1.排序方法中，将整个无序序列分割成若干小的子序列并分别进行插入排序的方法是（） 正确答案: A 希尔排序 冒泡排序 插入排序 选择排序 解析： 希尔排序：先将整个序列按一定增量分割为若干子序列分别进行直接插入排序，随后不断减少增量，当增量减至1时，整个文件恰被分成一组，算法便终止 其最坏时间复杂度依然为O(n2) 2.对一组数据（2，12，16，88，5，10）进行排序，若前三趟排序结果如下（）...
第十章-排序-作业3-归并排序与基数排序
qq_43839907的博客
12-07 6585
判断题 1-1 对N个记录进行归并排序，归并趟数的数量级是O(NlogN)F 应为O(logN) 选择题 2-1 对N个记录进行归并排序，归并趟数的数量级是： A A.O(logN) B.O(N) C.O(NlogN) D.O(N​2) 2-2 对N个记录进行归并排序，空间复杂度为： B A.O(logN) B.O(N) C.O(NlogN) D.O(N2) 2-3 给出关键字序列{ 431,...
数据结构 第八章 排序 作业（已批改）
Jessieeeeeee的博客
07-12 1万+
判断题 1-1 对N个记录进行堆排序，需要的额外空间为O(N)。 T F 课本P254：堆排序仅需一个记录大小供交换用的辅助存储空间，所以空间复杂度为O(1) 1-2 对N个记录进行简单选择排序，比较次数和移动次数分别为O(N​^2​​)和O(N)。 T F 课本P247 1-3 对N个记录进行快速排序，在最坏的情况下，其时间复杂度是O(NlogN)。 T F 对N个记录进行快速排序，在最坏的情况下，其时间复杂度是O(N^2) 1-4 希尔排序是稳定的算法。 T F 课本P241 1-5 对
常见排序算法总结.pdf
03-28
【排序算法总结】 排序算法是计算机科学中处理数据排列的重要工具，主要分为稳定排序和非稳定排序、内排序和外排序两大类。稳定排序保证了相同元素在排序后的相对位置不变，而非稳定排序则不作此保证。内排序是指...
Java实现常见排序算法总结
最新发布
05-02
【Java实现常见排序算法总结】 排序算法是计算机科学中至关重要的一部分，它涉及到数据处理和算法设计。本文将探讨两种常见的排序算法在Java中的实现：直接插入排序和希尔排序。 1. **直接插入排序（直接插入排序...
利用ArrayList对map进行按key（键）和按value (值) 排序
qq_41487251的博客
09-08 4618
利用ArrayList对map进行按key(键)和按value (值) 排序 总感觉按照值得应该比较少，意义好像也不大，感觉还没有真正懂。 使用比较器 按key（键）排序 通过ArrayList将map.entrySet()，变成list 然后在类外写具体如何比较大小的方法compare()，最后调用 Collections.sort(list, new Comparator<Map.Entry<String, String>>() import java.util.*; pub
PTA排序易错题
浮而不实的博客
06-13 1万+
仅基于比较的算法能得到的最好的“最坏时间复杂度”是O(NlogN)。 A.对 B.错 原因：常见的最坏的时间复杂度如下第四列，最优是O(NlogN)。 对N个记录进行归并排序，归并趟数的数量级是O(NlogN)。 A.对 B.错 原因：归并趟数为log2n 对N个记录进行简单选择排序，比较次数和移动次数分别为O(N​2)和O(N) A.对 B.错 原因：简单排序遍历并比较最大的（或最小的）仅仅交换头部与最大或最小的位置，因此比较次数和移动次数分别为O(N​2)和O(N) 对N个记录进行快速排序，在最坏的情
数据结构期末复习（三）
qq_43791139的博客
05-26 3307
1.判断题 在散列表中，所谓同义词就是被不同散列函数映射到同一地址的两个元素。（F） 在散列中，函数“插入”和“查找”具有同样的时间复杂度。（T） **解析：**都是O（1） 有n个数存放在一维数组A[1…n]中，在进行顺序查找时，这n个数的排列有序或无序其平均查找长度不同。（F） **解析：**平均查找长度是固定的。 在索引顺序表中，实现分块查找，在等概率查找情况下，其平均查找长度不仅与表中元素个数有关，而且与每块中元素个数有关。（T） 举个例子：设顺序线性表的长度为30，分成5块，每块6个元素，如果采
Round22—归并与基数排序
你倒是敲代码鸭.
02-20 2215
判断题 1-1对N个记录进行归并排序，归并趟数的数量级是O(NlogN)（F） 单选题 2-1对N个记录进行归并排序，归并趟数的数量级是：(1分) O(logN) O(N) O(NlogN) O(N​2​​) 2-2对N个记录进行归并排序，空间复杂度为：(1分) O(logN) O(N) O(NlogN) O(N​2​​) 2-3给出关键字序列{ 431, 56, 57,...
【PAT】【数据结构】查找与排序周测+月测-05-01-06
韩旭051的博客
12-17 4436
下列排序算法中，哪种算法可能出现：在最后一趟开始之前，所有的元素都不在其最终的位置上？（设待排元素个数N>2）(3分) 冒泡排序 每次有一个位置确定 插入排序 插入插在头结点就全后移 堆排序 每次也就移动一个子树另一个子树不变动 快速排序 扫描的时候最后肯定有一半排好了 对于序列{ 49，38，65，97，76，13，27，50 }，按由小到大进行排序，下面哪一个是初始步...
归并与基数排序
qq_34596217的博客
12-07 1764
选择题 1.输入10​​^5个只有一位数字的整数，可以用O(N)复杂度将其排序的算法是：桶排序 2.数据序列{ 3, 1, 4, 11, 9, 16, 7, 28 }只能是下列哪种排序算法的两趟排序结果？B A 冒泡排序 B 快速排序 C 插入排序 D 堆排序 解析：如果是冒泡排序，末尾是最大或最小的两个数； 如果是插入排序，最前面应该是最大或最小的两个数； 如果是堆排序，末尾因该是筛选出来的两个数。 3.对10TB的数据文件进行排序，应使用的方法是：归并排序 4.下列排序方法中，若将顺序存储
第十章-排序-归并排序与基数排序
刘二狗的博客
11-30 1万+
2-1 对N个记录进行归并排序，归并趟数的数量级是： (1分) O(logN) O(N) O(NlogN) O(N​2​​) 2-2 对N个记录进行归并排序，空间复杂度为： (1分) O(logN) O(N) O(NlogN) O(N​2​​) 2-3 给出关键字序列{ 431, 56, 57, 46, 28, 7, 331, 33, 24, 63 }，下面哪个选择是按次位优...
中国大学MOOC-陈越、何钦铭-数据结构-2022春期末考试
热门推荐
YoungITの博客
05-17 2万+
按Ctrl+F 查询题目答案???? 判断题 1-1 无向连通图边数一定大于顶点个数减1。 1-2 若用平方探测法解决冲突，则插入新元素时，若散列表容量为质数，插入就一定可以成功。 1-3 对N个不同的数据采用冒泡排序进行从大到小的排序，当元素基本有序时交换元素次数肯定最多。 1-4 N​2​​logN和NlogN​2​​具有相同的增长速度。 1-5 对一棵平衡二叉树，所有非叶结点的平衡因子都是0，当且仅当该树是完全二叉树。 单选题 2-1...
中国大学MOOC-陈越、何钦铭-数据结构-2019夏期末考试（含答案）
zhangzhao219的博客
09-03 2万+
中国大学MOOC-陈越、何钦铭-数据结构-2019夏期末考试（含答案） 判断题 1-1   对N个不同的数据采用冒泡排序进行从大到小的排序，当元素基本有序时交换元素次数肯定最多。 (2分) 1-2   NlogN​2和NlogN具有相同的增长速度。 (2分) 1-3   采用平方探测冲突解决策略（h​i(k)=(H(k)+i​2)%11, 注意：不是±i​2），将一批散列值均等于2的对象连续插入一...
数据结构详解：排序算法总结与复杂性分析
本资源是一份关于常用排序算法总结的PPT课件，主要涵盖了数据结构中的排序理论和实践。章节9详细介绍了排序的基本概念，包括排序的定义，即通过特定规则重新排列数据，使其满足非递减关系。排序被划分为稳定和不稳定...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

阿阿阿安

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值