（PTA）数据结构（作业）13、排序

Misasagi Inori

已于 2022-10-07 11:51:03 修改

阅读量2.9k

点赞数 1

分类专栏：数据结构文章标签：数据结构算法排序算法

于 2022-08-08 21:55:14 首次发布

本文链接：https://blog.csdn.net/m0_52561302/article/details/125053658

版权

数据结构专栏收录该内容

16 篇文章 63 订阅

订阅专栏

判断题

1、仅基于比较的算法能得到的最好的“最坏时间复杂度”是O(NlogN)。T

2、对N个记录进行归并排序，归并趟数的数量级是O(NlogN)。F

归并排序的一趟一趟形似倒着的二叉树，其高度就是归并的趟数，二叉树的高为 $log_2n$ ，所以归并趟数的数量级为logN。（王道的图，真好用doge）

3、对N个记录进行简单选择排序，比较次数和移动次数分别为O( $N^2$ )和O(N)。T

4、对N个记录进行快速排序，在最坏的情况下，其时间复杂度是O(NlogN)。F

最好的时间复杂度是 $O(log_2n)$ ，最坏的时间复杂度是 $O(n^2)$

5、希尔排序是稳定的算法。F

6、对N个不同的数据采用冒泡排序进行从大到小的排序，当元素基本有序时交换元素次数肯定最多。F

7、要从50个键值中找出最大的3个值，选择排序比堆排序快。T

8、(neuDS)直接插入排序算法在最好情况下的时间复杂度为O(n)。T

选择题

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

A.冒泡排序

B.选择排序

C.插入排序

D.归并排序

2、数据序列{ 3，2，4，9，8，11，6，20 }只能是下列哪种排序算法的两趟排序结果？

A.冒泡排序

B.选择排序

C.插入排序

D.快速排序

3、对一组数据{ 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.冒泡排序

B.希尔排序

C.归并排序

D.基数排序

4、下面四种排序算法中，稳定的算法是：

A.堆排序

B.希尔排序

C.归并排序

D.快速排序

5、在基于比较的排序算法中，哪种算法的最坏情况下的时间复杂度不高于O(NlogN)？

A.冒泡排序

B.归并排序

C.希尔排序

D.快速排序

6、对N个不同的数据采用冒泡算法进行从大到小的排序，下面哪种情况下肯定交换元素次数最多？

A.从小到大排好的

B.从大到小排好的

C.元素无序

D.元素基本有序

7、对N个记录进行归并排序，空间复杂度为：

A.O(logN)

B.O(N)

C.O(NlogN)

D.O( $N^2$ )

8、排序方法中，从未排序序列中依次取出元素与已排序序列中的元素进行比较，将其放入已排序序列的正确位置的方法称为：

A.插入排序

B.选择排序

C.快速排序

D.归并排序

9、设有100个元素的有序序列，如果用二分插入排序再插入一个元素，则最大比较次数是：

A.7

B.10

C.25

D.50

10、对一组包含10个元素的非递减有序序列，采用直接插入排序排成非递增序列，其可能的比较次数和移动次数分别是：

A.100, 100

B.100, 54

C.54, 63

D.45, 44

11、对N个记录进行快速排序，在最坏的情况下，其时间复杂度是：

A.O(N)

B.O(NlogN)

C.O( ${\color{Red} N^2}$ )

D.O( $N^2logN$ )

12、有组记录的排序码为{46，79，56，38，40，84 }，采用快速排序（以位于最左位置的对象为基准而）得到的第一次划分结果为：

A.{38,46,79,56,40,84}

B.{38,79,56,46,40,84}

C.{38,46,56,79,40,84}

D.{40,38,46,56,79,84}

13、对于序列{ 49，38，65，97，76，13，27，50 }，按由小到大进行排序，下面哪一个是初始步长为4的希尔排序法第一趟的结果？

A.13,27,38,49,50,65,76,97

B.49,13,27,50,76,38,65,97

C.49,76,65,13,27,50,97,38

D.97,76,65,50,49,38,27,13

14、给定初始待排序列{ 15，9，7，8，20，-1，4 }。如果希尔排序第一趟结束后得到序列为{ 15，-1，4，8，20，9，7 }，则该趟增量为：

A.1

B.2

C.3

D.4

15、对N个元素采用简单选择排序，比较次数和移动次数分别为：

A.O( ${\color{Red} N^2}$ ), O(N)

B.O(N), O(logN)

C.O(logN), O( $N^2$ )

D.O(NlogN), O(NlogN)

16、对于10个数的简单选择排序，最坏情况下需要交换元素的次数为：

A.9

B.36

C.45

D.100

17、若数据元素序列{ 12, 13, 8, 11, 5, 16, 2, 9 }是采用下列排序方法之一得到的第一趟排序后的结果，则该排序算法只能是：

A.快速排序

B.选择排序

C.堆排序

D.归并排序

18、若数据元素序列{ 22, 25, 18, 20, 5, 30, 2, 19 }是采用下列排序方法之一得到的第一趟排序后的结果，则该排序算法只能是：

A.快速排序

B.归并排序

C.堆排序

D.选择排序

19、若数据元素序列{ 19, 21, 7, 14, 5, 27, 1, 10 }是采用下列排序方法之一得到的第一趟排序后的结果，则该排序算法只能是：

A.快速排序

B.堆排序

C.归并排序

D.选择排序

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

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

则可能的排序算法是：

A.冒泡排序

B.快速排序

C.归并排序

D.插入排序

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

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

则可能的排序算法是：

A.冒泡排序

B.归并排序

C.插入排序

D.快速排序

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

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

则可能的排序算法是：

A.冒泡排序

B.归并排序

C.快速排序

D.插入排序

23、数据序列{ 3, 1, 4, 11, 9, 16, 7, 28 }只能是下列哪种排序算法的两趟排序结果？

A.冒泡排序

B.快速排序

C.插入排序

D.堆排序

24、设有1000个元素的有序序列，如果用二分插入排序再插入一个元素，则最大比较次数是：

A.1000

B.999

C.500

D.10

25、在内部排序时，若选择了归并排序而没有选择插入排序，则可能的理由是：

归并排序的程序代码更短
归并排序占用的空间更少
归并排序的运行效率更高

A.仅 2

B.仅 3

C.仅 1、2

D.仅 1、3

26、对初始数据序列{ 8, 3, 9, 11, 2, 1, 4, 7, 5, 10, 6 }进行希尔排序。若第一趟排序结果为（ 1, 3, 7, 5, 2, 6, 4, 9, 11, 10, 8 ），第二趟排序结果为（ 1, 2, 6, 4, 3, 7, 5, 8, 11, 10, 9 ），则两趟排序采用的增量（间隔）依次是：

A.3, 1

B.3, 2

C.5, 2

D.5, 3

编程题

7-1 英文单词排序

本题要求编写程序，输入若干英文单词，对这些单词按长度从小到大排序后输出。如果长度相同，按照输入的顺序不变。

输入格式：

输入为若干英文单词，每行一个，以#作为输入结束标志。其中英文单词总数不超过20个，英文单词为长度小于10的仅由小写英文字母组成的字符串。

输出格式：

输出为排序后的结果，每个单词后面都额外输出一个空格。

输入样例：

blue
red
yellow
green
purple
#

输出样例：

red blue green yellow purple

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB


#include<iostream>

using namespace std;

int main()
{
	string instring[20];
	int num = 0;

	for (int i = 0; i < 20; i++)
	{
		cin >> instring[i];
		if (instring[i] == "#")
			break;
		num++;
	}


	for (int i = 0; i < num; i++)
	{
		for (int j = i + 1; j < num; j++)
		{
			if (instring[i].length() > instring[j].length())
			{
				string temp = instring[i];
				instring[i] = instring[j];
				instring[j] = temp;
			}
		}
	}

	for (int i = 0; i < num; i++)
	{
		cout << instring[i] << " ";
	}
	return 0;
}

7-2 冒泡法排序

将N个整数按从小到大排序的冒泡排序法是这样工作的：从头到尾比较相邻两个元素，如果前面的元素大于其紧随的后面元素，则交换它们。通过一遍扫描，则最后一个元素必定是最大的元素。然后用同样的方法对前N−1个元素进行第二遍扫描。依此类推，最后只需处理两个元素，就完成了对N个数的排序。

本题要求对任意给定的K（<N），输出扫描完第K遍后的中间结果数列。

输入格式：

输入在第1行中给出N和K（1≤K<N≤100），在第2行中给出N个待排序的整数，数字间以空格分隔。

输出格式：

在一行中输出冒泡排序法扫描完第K遍后的中间结果数列，数字间以空格分隔，但末尾不得有多余空格。

输入样例：

6 2
2 3 5 1 6 4

输出样例：

2 1 3 4 5 6

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

#include<iostream>

using namespace std;

int main()
{
    int num,target,count;
    
    cin >> num>>target;
    
    int n[num];
    
    for(int i=0;i<num;i++)
    {
        cin >> n[i];
    }
    
    for(int j=0;j<target;j++)
    {
        for(int k=0;k<num-j-1;k++)
        {
            if(n[k]>n[k+1])
            {
            int temp=n[k];
            n[k] = n[k+1];
            n[k+1] = temp;
            }
        }
    }
    
    for(int j =0;j<num;j++)
    {
        cout << n[j];
        if(j!=num-1)
            cout <<" ";
    }
    
    return 0;
}