精华内容
下载资源
问答
  • 对n个进行排序(空间复杂度O(1))

    千次阅读 2016-06-11 10:20:13
    题目:如何对n个进行排序,要求时间复杂度O(n),空间复杂度O(1) ? 思路分析: (1)关键:哈希表,空间复杂度O(1)中1的含义(只要是常量就可以) (2)在数字范围有限制的情况下,只需要用一数组记录...

    题目:如何对n个数进行排序,要求时间复杂度O(n),空间复杂度O(1) ?
    思路分析:
    (1)关键:哈希表,空间复杂度O(1)中1的含义(只要是常量就可以)
    (2)在数字范围有限制的情况下,只需要用一个数组记录每个数字出现次数就可以了。
    (3)假定你的数字范围在0到65535范围之内,定义一个数组count[65536](这个空间是常量,和n无关,所以是O(1) ),初值全部为0。
    假设待排序数组中有下面这些数字:
    100,200,300,119,0,6…
    那么对于每个数字,都做在count中记录一下:
    100 => count[100]++
    200 => count[200]++
    300 => count[300]++
    119 => count[119]++
    0 => count[0]++
    6 => count[6]++

    最后,遍历一遍待排序数组中的所有数字,就可得到0~65535每个数字的个数(在count数组中),然后再顺序遍历count数组,count[n] = m,则输出m个n,(比如说有count[3] = 2, 那么说明有2个数字3),依次输出,最后可得结果。第一次遍历是O(n),第二次遍历是O(1),为常量,所以最后的时间复杂度为O(n),而空间复杂度为O(1)。

    具体实现如下:

    #include <iostream>
    using namespace std;
    #define MAXSIZE 100
    
    void hashSort(int arr[],int len)
    {
        int max = arr[0];
        int min = arr[0];
        for (int i = 0; i < len; i++) // 找出待排序数组中的最大值和最小值
        {
            if(max <= arr[i])
                max = arr[i];
            if(min >= arr[i])
                min = arr[i];
        }
    
        int *hash = new int[max - min + 1]; // 根据最大值和最小值来动态创建一个新数组
    
        for (int i = 0; i < max - min + 1; i++) // 将新数组的元素全部初始化为0
            *(hash + i) = 0;
    
        for (int i = 0; i < len; i++) // 记录每个数出现的次数
            (*(hash+arr[i] - min))++;
    
        int j = 0;
        for (int i = 0; i < max - min + 1; i++)
        {
            while ((*(hash + i))--)// 出现k次,重复k次
                arr[j++] = i + min; // 新数组的每个下标位置存储的值,就是“该位置对应的下标的值”的“出现次数”。
        }
        delete [] hash;
    }
    
    
    int main(int argc, const char * argv[]) {
    
        int arr[] = {3,2,6,5,7,1,4,9,0,8};
        int len = sizeof(arr)/sizeof(int);
    
        hashSort(arr, len);
    
        for (int i = 0; i < len; i++) {
            printf("%d ", arr[i]);
        }
    
        printf("\n");
        return 0;
    }

    注意点:
    int *hash = new int[max - min + 1];
    此处定义数组时,不能使用 int temp[max - min + 1];的形式,定义数组时不能用变量来指定数组长度,因为定义数组时,分配空间是需要一个固定的值,来确定你所申请的空间的大小。
    如 int n = 5;
    int a[n];
    这样使用,根据编译器的不同,编译可能会通过,但是那个n始终是个变量,若n的值改变,则数组大小也会改变,在对其使用的时候就会使用到数组以外的内容,对程序会造成隐患,所以一般是不能编译通过的。
    所以,只能固定的申请a[5];即数组长度必须在编译时就已确定。
    c++可以用new表达式动态分配数组和用delete [] 撤消,new表达式返回新分配数组的第一个元素的指针。
    参考文章:【100题】第四十九题 排序,要求时间复杂度O(n),空间复杂度O(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个记录进行归并排序,空间复杂度为...

    判断题
    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, 56, 57, 46, 28, 7, 331, 33, 24, 63 },下面哪个选择是按次位优先(LSD)链式基数排序进行了一趟分配和收集的结果? C
    A.→331→431→33→63→24→56→46→57→7→28
    B.→56→28→431→331→33→24→46→57→63→7
    C.→431→331→33→63→24→56→46→57→7→28
    D.→57→46→28→7→33→24→63→56→431→331

    2-4
    输入105个只有一位数字的整数,可以用O(N)复杂度将其排序的算法是:C
    A.快速排序
    B.插入排序
    C.桶排序
    D.希尔排序

    2-5
    数据序列{ 3, 1, 4, 11, 9, 16, 7, 28 }只能是下列哪种排序算法的两趟排序结果?B
    A.冒泡排序
    B.快速排序
    C.插入排序
    D.堆排序

    2-6
    对10TB的数据文件进行排序,应使用的方法是:C
    A.希尔排序
    B.堆排序
    C.归并排序
    D.快速排序

    2-7
    在内部排序时,若选择了归并排序而没有选择插入排序,则可能的理由是:B
    1.归并排序的程序代码更短
    2.归并排序占用的空间更少
    3.归并排序的运行效率更高
    A.仅 2
    B.仅 3
    C.仅 1、2
    D.仅 1、3

    2-8
    下列排序方法中,若将顺序村吃更换为链式存储,则算法的时间效率会降低的是:D
    1.插入排序;2.选择排序;3.起泡排序;4.希尔排序;5.堆排序
    A.仅1、2
    B.仅2、3
    C.仅3、4
    D.仅4、5
    2-9
    { 12,9,11,8,7,4,5,13,23 }是下列哪种方法第二趟排序后的结果? B
    A.归并排序
    B.堆排序
    C.插入排序
    D.基数排序

    2-10
    输入104个只有一位数字的整数,可以用O(N)复杂度将其排序的算法是:A
    A.桶排序
    B.快速排序
    C.插入排序
    D.希尔排序

    2-11
    将序列{ 2, 12, 16, 88, 5, 10, 34 }排序。若前2趟排序的结果如下:

    第1趟排序后:2, 12, 16, 10, 5, 34, 88
    第2趟排序后:2, 5, 10, 12, 16, 34, 88
    则可能的排序算法是:B
    A.冒泡排序
    B.快速排序
    C.归并排序
    D.插入排序

    2-12
    将序列{ 2, 12, 16, 88, 5, 10, 34 }排序。若前2趟排序的结果如下:
    第1趟排序后:2, 12, 16, 10, 5, 34, 88
    第2趟排序后:2, 5, 10, 12, 16, 34, 88
    则可能的排序算法是:D
    A.冒泡排序
    B.归并排序
    C.插入排序
    D.快速排序

    2-13
    将序列{ 2, 12, 16, 88, 5, 10, 34 }排序。若前2趟排序的结果如下:
    第1趟排序后:2, 12, 16, 10, 5, 34, 88
    第2趟排序后:2, 5, 10, 12, 16, 34, 88
    则可能的排序算法是:C
    A.冒泡排序
    B.归并排序
    C.快速排序
    D.插入排序

    2-14
    在对N个元素进行排序时,基于比较的算法中,其“最坏时间复杂度”中最好的是: C
    A.O(logN)
    B.O(N)
    C.O(NlogN)
    D.O(N2)

    2-15
    下列排序算法中,哪种算法可能出现:在最后一趟开始之前,所有的元素都不在其最终的位置上?(设待排元素个数N>2) B
    A.冒泡排序
    B.插入排序
    C.堆排序
    D.快速排序

    2-16
    若数据元素序列{ 11,12,13,7,8,9,23,4,5 }是采用下列排序方法之一得到的第二趟排序后的结果,则该排序算法只能是: C
    A.冒泡排序
    B.选择排序
    C.插入排序
    D.归并排序

    2-17
    数据序列{ 3,2,4,9,8,11,6,20 }只能是下列哪种排序算法的两趟排序结果? D
    A.冒泡排序
    B.选择排序
    C.插入排序
    D.快速排序

    2-18
    对一组数据{ 2,12,16,88,5,10 }进行排序,若前三趟排序结果如下: 第一趟排序结果:2,12,16,5,10,88 第二趟排序结果:2,12,5,10,16,88 第三趟排序结果:2,5,10,12,16,88 则采用的排序方法可能是: A
    A.冒泡排序
    B.希尔排序
    C.归并排序
    D.基数排序

    2-19
    就排序算法所用的辅助空间而言,堆排序、快速排序、归并排序的关系是: C
    A.堆排序 < 归并排序 < 快速排序
    B.堆排序 > 归并排序 > 快速排序
    C.堆排序 < 快速排序 < 归并排序
    D.堆排序 > 快速排序 > 归并排序

    2-20
    下面四种排序算法中,稳定的算法是: C
    A.堆排序
    B.希尔排序
    C.归并排序
    D.快速排序

    2-21
    在基于比较的排序算法中,哪种算法的最坏情况下的时间复杂度不高于O(NlogN)? B
    A.冒泡排序
    B.归并排序
    C.希尔排序
    D.快速排序

    2-22
    下列排序算法中,时间复杂度不受数据初始状态影响,恒为O(NlogN)的是: C
    A.冒泡排序
    B.直接选择排序
    C.堆排序
    D.快速排序

    2-23
    输入105个只有一位数字的整数,可以用O(N)复杂度将其排序的算法是: D
    A.快速排序
    B.插入排序
    C.希尔排序
    D.基数排序

    2-24
    排序方法中,从未排序序列中依次取出元素与已排序序列中的元素进行比较,将其放入已排序序列的正确位置的方法称为: A
    A.插入排序
    B.选择排序
    C.快速排序
    D.归并排序

    展开全文
  • 归并排序(合并排序

    千次阅读 2016-03-27 21:52:42
    合并排序(MERGE SORT)是又一类不同的排序方法,合并的含义就是将两或两以上的有序数据序列合并成一新的有序数据序列,因此它又叫归并算法。它的基本思想就是假设数组A有N个元素,那么可以看成数组A是又N个...

    合并排序(MERGE SORT)是又一类不同的排序方法,合并的含义就是将两个或两个以上的有序数据序列合并成一个新的有序数据序列,因此它又叫归并算法。它的基本思想就是假设数组A有N个元素,那么可以看成数组A是又N个有序的子序列组成,每个子序列的长度为1,然后再两两合并,得到了一个 N/2 个长度为2或1的有序子序列,再两两合并,如此重复,值得得到一个长度为N的有序数据序列为止,这种排序方法称为2—路合并排序。
      例如数组A有7个数据,分别是: 49 38 65 97 76 13 27,那么采用归并排序算法的操作过程如图7所示: 
      初始值 [49] [38] [65] [97] [76] [13] [27] 
      看成由长度为1的7个子序列组成 
      第一次合并之后 [38 49] [65 97] [13 76] [27] 
      看成由长度为1或2的4个子序列组成 
      第二次合并之后 [38 49 65 97] [13 27 76] 
      看成由长度为4或3的2个子序列组成 
      第三次合并之后 [13 27 38 49 65 76 97] 
      合并算法的核心操作就是将一维数组中前后相邻的两个两个有序序列合并成一个有序序列。合并算法也可以采用递归算法来实现,形式上较为简单,但实用性很差。合并算法的合并次数是一个非常重要的量,根据计算当数组中有3到4个元素时,合并次数是2次,当有5到8个元素时,合并次数是3次,当有9到16个元素时,合并次数是4次,按照这一规律,当有N个子序列时可以推断出合并的次数是X(2 >=N,符合此条件的最小那个X)。
      
    其时间复杂度为:O(nlogn).   

           所需辅助存储空间为:O(n)
      归并算法如下:

    #include<stdio.h>   

    1. #include<stdlib.h>   
    2. typedef int RecType;//要排序元素类型  
    3. void Merge(RecType *R,int low,int m,int high)  
    4. {  
    5.     //将两个有序的子文件R[low..m)和R[m+1..high]归并成一个有序的子文件R[low..high]  
    6.     int i=low,j=m+1,p=0;                //置初始值  
    7.     RecType *R1;                        //R1是局部向量  
    8.     R1=(RecType *)malloc((high-low+1)*sizeof(RecType));  
    9.     if(!R1)  
    10.     {  
    11.         return;                         //申请空间失败  
    12.     }  
    13.   
    14.     while(i<=m&&j<=high)                //两子文件非空时取其小者输出到R1[p]上  
    15.     {  
    16.         R1[p++]=(R[i]<=R[j])?R[i++]:R[j++];  
    17.     }  
    18.   
    19.     while(i<=m)                         //若第1个子文件非空,则复制剩余记录到R1中  
    20.     {  
    21.         R1[p++]=R[i++];  
    22.     }  
    23.     while(j<=high)                      //若第2个子文件非空,则复制剩余记录到R1中  
    24.     {  
    25.         R1[p++]=R[j++];  
    26.     }  
    27.   
    28.     for(p=0,i=low;i<=high;p++,i++)  
    29.     {  
    30.         R[i]=R1[p];                     //归并完成后将结果复制回R[low..high]  
    31.     }  
    32. }  
    33.   
    34. void MergeSort(RecType R[],int low,int high)  
    35. {     
    36.     //用分治法对R[low..high]进行二路归并排序  
    37.     int mid;  
    38.     if(low<high)  
    39.     {   //区间长度大于1   
    40.         mid=(low+high)/2;               //分解  
    41.         MergeSort(R,low,mid);           //递归地对R[low..mid]排序  
    42.         MergeSort(R,mid+1,high);        //递归地对R[mid+1..high]排序  
    43.         Merge(R,low,mid,high);          //组合,将两个有序区归并为一个有序区  
    44.     }  
    45. }  
    46. void main()  
    47. {  
    48.     int a[7]={49,38,65,97,76,13,27}; //这里对8个元素进行排序  
    49.     int low=0,high=6;                   //初始化low和high的值  
    50.   
    51.     printf("Before merge sort: ");  
    52.     for(int i=low;i<=high;i++)  
    53.     {  
    54.         printf("%d ",a[i]);             //输出测试  
    55.     }  
    56.     printf("/n");  
    57.   
    58.     MergeSort(a,low,high);  
    59.   
    60.     printf("After merge sort:  ");  
    61.     for( i=low;i<=high;i++)  
    62.     {  
    63.         printf("%d ",a[i]);             //输出测试  
    64.     }  
    65.     printf("/n");  
    66. }   
    展开全文
  • 第十章-排序-归并排序与基数排序

    万次阅读 2018-11-30 17:07:08
    对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 给出关键字序列{ ...

    2-1

    对N个记录进行归并排序,归并趟数的数量级是: (1分)

    1. O(logN)
    2. O(N)
    3. O(NlogN)
    4. O(N​2​​)

    2-2

    对N个记录进行归并排序,空间复杂度为: (1分)

    1. O(logN)
    2. O(N)
    3. O(NlogN)
    4. O(N​2​​)

    2-3

    给出关键字序列{ 431, 56, 57, 46, 28, 7, 331, 33, 24, 63 },下面哪个选择是按次位优先(LSD)链式基数排序进行了一趟分配和收集的结果? (2分)

    1. →331→431→33→63→24→56→46→57→7→28
    2. →56→28→431→331→33→24→46→57→63→7
    3. →431→331→33→63→24→56→46→57→7→28
    4. →57→46→28→7→33→24→63→56→431→331

    2-4

    输入10​5​​个只有一位数字的整数,可以用O(N)复杂度将其排序的算法是:(1分)

    1. 快速排序
    2. 插入排序
    3. 桶排序
    4. 希尔排序

    2-5

    数据序列{ 3, 1, 4, 11, 9, 16, 7, 28 }只能是下列哪种排序算法的两趟排序结果?(2分)

    1. 冒泡排序
    2. 快速排序
    3. 插入排序
    4. 堆排序

    2-6

    对10TB的数据文件进行排序,应法使用的方是:(1分)

    1. 希尔排序
    2. 堆排序
    3. 归并排序
    4. 快速排序

    2-7

    在内部排序时,若选择了归并排序而没有选择插入排序,则可能的理由是:(2分)

    1. 归并排序的程序代码更短
    2. 归并排序占用的空间更少
    3. 归并排序的运行效率更高
    1. 仅 2
    2. 仅 3
    3. 仅 1、2
    4. 仅 1、3

    2-8

    下列排序方法中,若将顺序村吃更换为链式存储,则算法的时间效率会降低的是:(2分)

    1.插入排序;2.选择排序;3.起泡排序;4.希尔排序;5.堆排序

    1. 仅1、2
    2. 仅2、3
    3. 仅3、4
    4. 仅4、5

    2-9

    { 12,9,11,8,7,4,5,13,23 }是下列哪种方法第二趟排序后的结果? (2分)

    1. 归并排序
    2. 堆排序
    3. 插入排序
    4. 基数排序

    2-10

    输入10​4​​个只有一位数字的整数,可以用O(N)复杂度将其排序的算法是:(1分)

    1. 桶排序
    2. 快速排序
    3. 插入排序
    4. 希尔排序

    2-11

    将序列{ 2, 12, 16, 88, 5, 10, 34 }排序。若前2趟排序的结果如下:

    • 第1趟排序后:2, 12, 16, 10, 5, 34, 88
    • 第2趟排序后:2, 5, 10, 12, 16, 34, 88

    则可能的排序算法是:(2分)

    1. 冒泡排序
    2. 快速排序
    3. 归并排序
    4. 插入排序

    2-12

    将序列{ 2, 12, 16, 88, 5, 10, 34 }排序。若前2趟排序的结果如下:

    • 第1趟排序后:2, 12, 16, 10, 5, 34, 88
    • 第2趟排序后:2, 5, 10, 12, 16, 34, 88

    则可能的排序算法是:(2分)

    1. 冒泡排序
    2. 归并排序
    3. 插入排序
    4. 快速排序

    2-13

    将序列{ 2, 12, 16, 88, 5, 10, 34 }排序。若前2趟排序的结果如下:

    • 第1趟排序后:2, 12, 16, 10, 5, 34, 88
    • 第2趟排序后:2, 5, 10, 12, 16, 34, 88

    则可能的排序算法是:(2分)

    1. 冒泡排序
    2. 归并排序
    3. 快速排序
    4. 插入排序

    2-14

    在对N个元素进行排序时,基于比较的算法中,其“最坏时间复杂度”中最好的是: (1分)

    1. O(logN)
    2. O(N)
    3. O(NlogN)
    4. O(N​2​​)

    2-15

    下列排序算法中,哪种算法可能出现:在最后一趟开始之前,所有的元素都不在其最终的位置上?(设待排元素个数N>2) (2分)

    1. 冒泡排序
    2. 插入排序
    3. 堆排序
    4. 快速排序

    2-16

    若数据元素序列{ 11,12,13,7,8,9,23,4,5 }是采用下列排序方法之一得到的第二趟排序后的结果,则该排序算法只能是: (2分)

    1. 冒泡排序
    2. 选择排序
    3. 插入排序
    4. 归并排序

    2-17

    数据序列{ 3,2,4,9,8,11,6,20 }只能是下列哪种排序算法的两趟排序结果? (2分)

    1. 冒泡排序
    2. 选择排序
    3. 插入排序
    4. 快速排序

    2-18

    对一组数据{ 2,12,16,88,5,10 }进行排序,若前三趟排序结果如下: 第一趟排序结果:2,12,16,5,10,88 第二趟排序结果:2,12,5,10,16,88 第三趟排序结果:2,5,10,12,16,88 则采用的排序方法可能是: (2分)

    1. 冒泡排序
    2. 希尔排序
    3. 归并排序
    4. 基数排序

    2-19

    就排序算法所用的辅助空间而言,堆排序、快速排序、归并排序的关系是: (1分)

    1. 堆排序 < 归并排序 < 快速排序
    2. 堆排序 > 归并排序 > 快速排序
    3. 堆排序 < 快速排序 < 归并排序
    4. 堆排序 > 快速排序 > 归并排序

    2-20

    下面四种排序算法中,稳定的算法是: (1分)

    1. 堆排序
    2. 希尔排序
    3. 归并排序
    4. 快速排序

    2-21

    在基于比较的排序算法中,哪种算法的最坏情况下的时间复杂度不高于O(NlogN)? (1分)

    1. 冒泡排序
    2. 归并排序
    3. 希尔排序
    4. 快速排序

    2-22

    下列排序算法中,时间复杂度不受数据初始状态影响,恒为O(NlogN)的是: (1分)

    1. 冒泡排序
    2. 直接选择排序
    3. 堆排序
    4. 快速排序

    2-23

    输入10​5​​个只有一位数字的整数,可以用O(N)复杂度将其排序的算法是: (1分)

    1. 快速排序
    2. 插入排序
    3. 希尔排序
    4. 基数排序

    2-24

    排序方法中,从未排序序列中依次取出元素与已排序序列中的元素进行比较,将其放入已排序序列的正确位置的方法称为: (1分)

    1. 插入排序
    2. 选择排序
    3. 快速排序
    4. 归并排序
    展开全文
  • 1.对N个记录进行归并排序归并趟数的数量级是: 选项 A O(logN) B O(N) C O(NlogN) D O(N2) 2.对N个记录进行归并排序,空间复杂度为: 选项 A O(logN) B O(N) C O(NlogN) D O(N2)...
  • 听课记录(快速排序归并排序

    千次阅读 2021-02-13 16:22:31
    文章目录快速排序快速选择归并排序 快速排序 例题:https://www.acwing.com/problem/content/787/ 快排: ①确定分界点 ②调整区间,使得小于等于x的在左边,大于等于x的在右边 ③递归处理左右两段 两指针 i,j ...
  • 请你使用归并排序对数列按照从小到大进行排序。 并将排好序的数列按顺序输出。 输入格式 输入共两行,第一行包含整数 n。 第二行包含 n 整数(所有整数均在1~109范围内),表示整个数列。 输出格式 输出共一行...
  • 1) 排序 n 元素,元素为随机生成的长为1..32的字符串(字符串均为英文小写字母),n的取值为:2^2,2^5,2^8,2^11,2^14,2^17; 2) 算法:直接插入排序,堆排序归并排序,快速排序; 3) 字符串大小判断标准...
  • 归并排序

    2020-02-08 20:35:57
    归并排序算法的思想: 假设初始序列含 n 个记录,则可看成是 n 有序的子序列,每子序列的长度为1,然后两两归并,...当有 n 个记录时,需进行log2^n归并排序,每一趟归并,其关键字比较次数不超过 n ,元素移...
  • 1-1对N个记录进行归并排序归并趟数的数量级是O(NlogN)(F) 单选题 2-1对N个记录进行归并排序归并趟数的数量级是:(1分) O(logN) O(N) O(NlogN) O(N​2​​) 2-2对N个记录进行归并排序,空间复杂度为:(1...
  • 归并排序(合并排序)

    2013-04-05 11:57:48
    漫谈经典排序算法:四、归并排序(合并排序) 分类: Data Structures And Algorithms 算法merge数据结构c 目录(?)[+] 1、序言 这是《漫谈经典排序算法系列》第四篇,解析了归并排序。 ...
  • 最近点问题中涉及到点按x或y进行升序排序,笔者尝试对排序方式进行优化。首先想到的自然是归并排序,毕竟归并排序的核心思想也是分治法,但是归并排序比较适合基数较多的情况。最后笔者更改思路如下:当点集合...
  • 归并排序理解

    2017-08-06 10:47:53
    归并的含义是将两或两以上的有序表合并成一新的有序表。归并排序有多路归并排序、两路归并排序 , 可用于内排序,也可以用于外排序。这里仅对内排序的两路归并方法进行讨论。 1.两路归并排序算法思路 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 123,780
精华内容 49,512
关键字:

对n个记录进行归并排序