Round20—交换与选择类排序

判断题

1-1对N个记录进行堆排序，需要的额外空间为O(N)（F）

1-2对N个记录进行简单选择排序，比较次数和移动次数分别为O(N​2​​)和O(N)（T）

1-3希尔排序是稳定的算法（F）

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

选择题

2-1在快速排序的一趟划分过程中，当遇到与基准数相等的元素时，如果左右指针都会停止移动，那么当所有元素都相等时，算法的时间复杂度是多少？(2分)

• O(logN)
• O(N)
• O(NlogN)
• O(N​2​​)

2-2在快速排序的一趟划分过程中，当遇到与基准数相等的元素时，如果左右指针都不停止移动，那么当所有元素都相等时，算法的时间复杂度是多少？(2分)

• O(logN)
• O(N)
• O(NlogN)
• O(N​2​​)

2-3在快速排序的一趟划分过程中，当遇到与基准数相等的元素时，如果左指针停止移动，而右指针在同样情况下却不停止移动，那么当所有元素都相等时，算法的时间复杂度是多少？(2分)

• O(logN)
• O(N)
• O(NlogN)
• O(N​2​​)

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

• 从小到大排好的
• 从大到小排好的
• 元素无序
• 元素基本有序

2-5对于7个数进行冒泡排序，需要进行的比较次数为： (2分)

• 7
• 14
• 21
• 49

2-6有组记录的排序码为{ 46，79，56，38，40，84 }，则利用堆排序的方法建立的初始堆为： (2分)

• 79，46，56，38，40，80
• 84，79，56，46，40，38
• 84，56，79，40，46，38
• 84，79，56，38，40，46

2-7采用递归方式对顺序表进行快速排序，下列关于递归次数的叙述中，正确的是： (2分)

• 每次划分后，先处理较长的分区可以减少递归次数
• 每次划分后，先处理较短的分区可以减少递归次数
• 递归次数与每次划分后得到的分区处理顺序无关
• 递归次数与初始数据的排列次序无关

2-8对N个记录进行快速排序，在最坏的情况下，其时间复杂度是： (1分)

• O(N)
• O(NlogN)
• O(N​2​​)
• O(N​2​​logN)

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

• {38,46,79,56,40,84}
• {38,79,56,46,40,84}
• {38,46,56,79,40,84}
• {40,38,46,56,79,84}

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

• 13,27,38,49,50,65,76,97
• 49,13,27,50,76,38,65,97
• 49,76,65,13,27,50,97,38
• 97,76,65,50,49,38,27,13

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

• 1
• 2
• 3
• 4

2-12对N个元素采用简单选择排序，比较次数和移动次数分别为： (1分)

• O(N​2​​), O(N)
• O(N), O(logN)
• O(logN), O(N​2​​)
• O(NlogN), O(NlogN)

2-13对于10个数的简单选择排序，最坏情况下需要交换元素的次数为： (2分)

• 9
• 36
• 45
• 100

2-14对N个记录进行堆排序，最坏的情况下时间复杂度是： (1分)

• O(logN)
• O(N)
• O(NlogN)
• O(N​2​​)

2-15对N个记录进行堆排序，需要的额外空间为： (1分)

• O(1)
• O(logN)
• O(N)
• O(NlogN)

编程题

7-1 寻找大富翁 (25分)

胡润研究院的调查显示，截至2017年底，中国个人资产超过1亿元的高净值人群达15万人。假设给出N个人的个人资产值，请快速找出资产排前M位的大富翁。

输入格式:

输入首先给出两个正整数N（≤10​6​​）和M（≤10），其中N为总人数，M为需要找出的大富翁数；接下来一行给出N个人的个人资产值，以百万元为单位，为不超过长整型范围的整数。数字间以空格分隔。

输出格式:

在一行内按非递增顺序输出资产排前M位的大富翁的个人资产值。数字间以空格分隔，但结尾不得有多余空格。

输入样例:

8 3
8 12 7 3 20 9 5 18

输出样例:

20 18 12

AC代码：

#include <bits/stdc++.h>
using namespace std;

int main()
{
	ios::sync_with_stdio(false);
    vector<int> num;
    int n, m;
    cin >> n >> m;
    for(int i = 0; i < n; i++)
    {
		int a;
        cin >> a;
		num.push_back(a);
    }
    sort(num.begin(), num.end(), greater<int>());
    if(m == 0)
    	return 0;
    cout << num[0];
    for(int i = 1; i < m && i < num.size(); i++)
    	cout << " " << num[i];
    return 0;
}

7-2 奥运排行榜 (25分)

每年奥运会各大媒体都会公布一个排行榜，但是细心的读者发现，不同国家的排行榜略有不同。比如中国金牌总数列第一的时候，中国媒体就公布“金牌榜”；而美国的奖牌总数第一，于是美国媒体就公布“奖牌榜”。如果人口少的国家公布一个“国民人均奖牌榜”，说不定非洲的国家会成为榜魁…… 现在就请你写一个程序，对每个前来咨询的国家按照对其最有利的方式计算它的排名。

输入格式:

输入的第一行给出两个正整数N和M（≤224，因为世界上共有224个国家和地区），分别是参与排名的国家和地区的总个数、以及前来咨询的国家的个数。为简单起见，我们把国家从0 ~ N−1编号。之后有N行输入，第i行给出编号为i−1的国家的金牌数、奖牌数、国民人口数（单位为百万），数字均为[0,1000]区间内的整数，用空格分隔。最后面一行给出M个前来咨询的国家的编号，用空格分隔。

输出格式:

在一行里顺序输出前来咨询的国家的排名:计算方式编号。其排名按照对该国家最有利的方式计算；计算方式编号为：金牌榜=1，奖牌榜=2，国民人均金牌榜=3，国民人均奖牌榜=4。输出间以空格分隔，输出结尾不能有多余空格。

若某国在不同排名方式下有相同名次，则输出编号最小的计算方式。

输入样例:

4 4
51 100 1000
36 110 300
6 14 32
5 18 40
0 1 2 3

输出样例:

1:1 1:2 1:3 1:4

AC代码：

​
#include <bits/stdc++.h>
using namespace std;

struct node
{
    int status;
    int rank;
    node(int status, int rank) : status(status), rank(rank) {}
};
struct country
{
    int id;
    int gold_num;
    int nums;
    int people_num;
    double _gold_num, _nums;
    country(int id, int gold_num, int nums, int people_num) : id(id), gold_num(gold_num), nums(nums), people_num(people_num)
    {
        _gold_num = gold_num * 1.0 / people_num;
        _nums = nums * 1.0 / people_num;
    }
};
int n, m;
vector<country> G;
vector<node> V;

bool cmp1(const country &lhs, const country &rhs)
{
    return lhs.gold_num > rhs.gold_num;
}

bool cmp2(const country &lhs, const country &rhs)
{
    return lhs.nums > rhs.nums;
}

bool cmp3(const country &lhs, const country &rhs)
{
    return lhs._gold_num > rhs._gold_num;
}

bool cmp4(const country &lhs, const country &rhs)
{
    return lhs._nums > rhs._nums;
}

int main()
{
    ios::sync_with_stdio(false);
    cin >> n >> m;
    for(int i = 0; i < n; i++)
    {
        int x, y, z;
        cin >> x >> y >> z;
        G.push_back(country(i, x, y, z));
        V.push_back(node(1, 0));
    }
    double temp;
    int sum = 0, rank = 1;
    sort(G.begin(), G.end(), cmp1);
    temp = G[0].gold_num;
    for(int i = 0; i < G.size(); i++)
    {
        if(G[i].gold_num == (int)temp)
        {
            V[G[i].id].rank = rank;
            sum++;
        }
        else
        {
            temp = G[i].gold_num;
            rank += sum;
            V[G[i].id].rank = rank;
            sum = 1;
        }
    }

    sort(G.begin(), G.end(), cmp2);
    sum = 0, rank = 1;
    temp = G[0].nums;
    for(int i = 0; i < G.size(); i++)
    {
        if(G[i].nums == (int)temp)
        {
            if(V[G[i].id].rank > rank)
            {
                V[G[i].id].rank = rank;
                V[G[i].id].status = 2;
            }
            sum++;
        }
        else
        {
            temp = G[i].nums;
            rank += sum;
            if(V[G[i].id].rank > rank)
            {
                V[G[i].id].rank = rank;
                V[G[i].id].status = 2;
            }
            sum = 1;
        }
    }

    sort(G.begin(), G.end(), cmp3);
    sum = 0, rank = 1;
    temp = G[0]._gold_num;
    for(int i = 0; i < G.size(); i++)
    {
        if(G[i]._gold_num == temp)
        {
            if(V[G[i].id].rank > rank)
            {
                V[G[i].id].rank = rank;
                V[G[i].id].status = 3;
            }
            sum++;
        }
        else
        {
            temp = G[i]._gold_num;
            rank += sum;
            if(V[G[i].id].rank > rank)
            {
                V[G[i].id].rank = rank;
                V[G[i].id].status = 3;
            }
            sum = 1;
        }
    }

    sort(G.begin(), G.end(), cmp4);
    sum = 0, rank = 1;
    temp = G[0]._nums;
    for(int i = 0; i < G.size(); i++)
    {
        if(G[i]._nums == temp)
        {
            if(V[G[i].id].rank > rank)
            {
                V[G[i].id].rank = rank;
                V[G[i].id].status = 4;
            }
            sum++;
        }
        else
        {
            temp = G[i]._nums;
            rank += sum;
            if(V[G[i].id].rank > rank)
            {
                V[G[i].id].rank = rank;
                V[G[i].id].status = 4;
            }
            sum = 1;
        }
    }

    for(int i = 0; i < m; i++)
    {
        int id;
        cin >> id;
        if(i == 0)
            cout << V[id].rank << ":" << V[id].status;
        else
            cout << " " << V[id].rank << ":" << V[id].status;
    }
    cout << endl;
    return 0;
}

​

7-3 冒泡法排序 (20分)

将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

AC代码：

#include <bits/stdc++.h>
using namespace std;

const int maxn = 100000 + 5;
int a[maxn];

int main()
{
	int n, m;
    cin >> n >> m;
    for(int i = 0; i < n; i++)
    	cin >> a[i];
    for(int i = 0; i < m && i < n - 1; i++)
    {
		for(int j = 0; j < n - i - 1; j++)
        {
            if(a[j] > a[j + 1])
            {
                int t = a[j];
                a[j] = a[j + 1];
                a[j + 1] = t;
            }
        }
    }
    for(int i = 0; i < n; i++)
    {
        if(i == 0)
        	cout << a[i];
        else
        	cout << " " << a[i];
    }
    cout << endl;
    return 0;
}