【蓝桥杯软件赛 零基础备赛20周】第8周——排序算法及应用
文章目录
- 1. 快速排序
- 2. C++ STL sort()
- 3. Python的sort()和sorted()
- 4. Java的sort()
- 5. 例题
-
- 例1 排序的基本应用
- 例2 排序的基本应用
- 例3 自定义排序比较函数
- 例4 结构体排序
- 例5 结构体排序
- 6. 习题
在算法竞赛中，一般不需要自己写这些排序算法，而是直接使用库函数，例如C++的sort()函数，Python的sort()和sorted()函数，Java的sort()函数。
1. 快速排序
十大排序算法里，最常考，也是最常用的排序算法，就是快速排序，因此这里只单独讲一个快速排序算法。
很多算法题，不会直接考排序算法，而是考察排序算法中的思想。比如快速排序是怎么分治的，怎么分割的，要会变形，要会举一反三。
快速排序的思路是：把序列分成左右两部分，使得左边所有的数都比右边的数小；递归这个过程，直到不能再分为止。如何把序列分成左右两部分？最简单的办法是设定两个临时空间X、Y和一个基准数t；检查序列中所有的元素，比t小的放在X中，比t大的放在Y中。不过，其实不用这么麻烦，直接在原序列上操作就行了，不需要使用临时空间X、Y。
直接在原序列上进行划分的方法有很多种，下面的图示介绍了一种很容易操作的方法：
下面分析复杂度。
每一次划分，都把序列分成了左右两部分，在这个过程中，需要比较所有的元素，有O(n)次。如果每次划分是对称的，也就是说左右两部分的长度差不多，那么一共需要划分O(logn)次。总复杂度O(nlogn)。
如果划分不是对称的，左部分和右部分的数量差别很大，那么复杂度会高一些。在极端情况下，例如左部分只有1个数，剩下的全部都在右部分，那么最多可能划分n次，总复杂度是 O ( n 2 ) O(n^2) O(n2)。所以，快速排序的效率和数据本身有关。
不过，一般情况下快速排序效率很高，甚至比归并排序更好。读者可以观察到，下面给出的快速排序的代码比归并排序的代码更简洁，代码中的比较、交换、拷贝操作很少。 快速排序几乎是目前所有排序法中速度最快的方法。STL的sort()函数就是基于快速排序算法的，并针对快速排序的缺点做了很多优化。
（1）C++代码
#include（2）Java代码
import java.util.Scanner;
public class Main {
static int[] a = new int[100005];
static int n;
public static void qsort(int L, int R) {
int i = L, j = R;
int key = a[(L + R) / 2];
while (i <= j) {
while (a[i] < key) i++;
while (a[j] > key) j--;
if (i <= j) {
int temp = a[i];
a[i] = a[j];
a[j] = temp;
i++;
j--;
}
}
if (j > L) qsort(L, j);
if (i < R) qsort(i, R);
}
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
n = input.nextInt();
for (int i = 0; i < n; i++) a[i] = input.nextInt();
qsort(0, n - 1);
for (int i = 0; i < n; i++) System.out.print(a[i] + " ");
}
}
（3）Python代码
def qsort(L, R):
i, j = L, R
key = a[(L + R) // 2]
while i <= j:
while a[i] < key: i += 1
while a[j] > key: j -= 1
if i <= j:
a[i], a[j] = a[j], a[i]
i += 1
j -= 1
if j > L: qsort(L, j)
if i < R: qsort(i, R)
n = int(input())
a = list(map(int, input().split()))
qsort(0,n-1)
for i in range(n): print(a[i], end=" ")
2. C++ STL sort()
有以下排序函数。
- sort (first, last, comp) 对[first, last) 范围内的元素进行排序。注意排序的范围[first, last)，包括first，不包括last。comp是比较函数，sort()自带4种comp排序：less、greater、less_equal、greater_equal。缺省情况下，程序是按从小到大的顺序排序的，less可以不写。也可以用自定义的比较函数进行排序，见下面第3、4行的例子。
- stable_sort (first, last, comp) 和sort()相似，不同之处在于，对于 [first, last) 范围内值相同的元素，该函数不会改变它们的相对位置。
- partial_sort(first, middle, last, , comp) 以交换元素存储位置的方式实现部分排序，将 [first, last) 范围内最小（或最大）的 middle-first 个元素移动到 [first, middle) 区域中，并对这部分元素做升序（或降序）排序。
- nth_element(first, nth, last, comp) 采用默认的升序时，该函数从某个序列中找到第 k 小的元素e（序列下标从0开始），并将e移动到序列中第k的位置处。而且，整个序列经过nth_element()函数处理后，所有位于e之前的元素都比e小，所有位于e之后的元素都比e大。
- is_sorted (first, last, comp) 检测 [first, last) 范围内是否已经排好序，默认检测是否按升序排序。
下面是例子。
#include利用cmp()函数，sort()可以对结构体进行排序，见后面的例题。
C++的sort()有两个优点：（1）能在原数组上排序，不需要新的空间；（2）能在数组的局部区间上排序。
3. Python的sort()和sorted()
Python提供了两个排序函数，sort()和sorted()。
（1）sort和sorted()的区别
sort()是应用在list上的方法，而sorted 可以对所有可迭代的对象进行排序操作。
一个关键的区别是：sort是在原列表上排序，而sorted()产生一个新的列表，不改变原列表。
（2）sorted()
sorted(iterable, key=None, reverse=False)
参数说明：
- iterable：可迭代对象。
- key：用来进行比较的元素，只有一个参数，具体的函数的参数取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
- reverse：排序规则，reverse = True 降序，reverse = False 升序（默认）。
- 返回值：重新排序的列表。
（3）sort()和sorted()的例子
a = [3,7,9,3,4,1,2]
a.sort() #直接在a上升序排序，a改变了
print(a) #[1, 2, 3, 3, 4, 7, 9]
b = sorted(a,reverse = True)
print(b) #排序结果给b，输出：[9, 7, 4, 3, 3, 2, 1]
print(a) #a不变，输出：[1, 2, 3, 3, 4, 7, 9]
a.sort(reverse = True) #降序
print(a) #输出：[9, 7, 4, 3, 3, 2, 1]
a = "abadae"
print(sorted(a)) #输出：['a', 'a', 'a', 'b', 'd', 'e']
#这样是错的：a.sort()，因为sort()应用在list上，a不是list
s1 = [('b', 'A', 15), ('c', 'B', 12), ('e', 'B', 10)]
s2 = sorted(s1, key=lambda s: s[2]) # 按第3个排序，默认升序
print(s2) #输出：[('e', 'B', 10), ('c', 'B', 12), ('b', 'A', 15)]
s3 = sorted(s1, key=lambda s: s[2], reverse=True) # 按第3个排序，降序
print(s3) #输出：[('b', 'A', 15), ('c', 'B', 12), ('e', 'B', 10)]
s = "hello world"
s = ''.join(sorted(s, reverse=True))
#Python中字符串不可变，不能直接在原字符串上进行排序
#可以将字符串转换为列表进行排序，然后再转回字符串
print(s) #输出：wroolllhed 注意最后一个是空格
Python的sort()不能在数组的一部分上做排序，只能对整个数组排序；sorted()虽可以对一部分排序，但是不能直接在原数组上排序。
4. Java的sort()
有Arrays.Sort()、Collections.sort()。
Arrays.sort()可以对数组，字符串等排序。Collections.sort()是对list集合排序，list也可以放数字、字符串。自定义比较见后面的例题。
例子：
import java.util.*;
public class Main {
public static void main(String[] args) {
int[] a = {8, 3, 6, 2, 3, 5, 9};
Arrays.sort(a); //升序
for (int num : a) System.out.print(num+" "); //输出： 2 3 3 5 6 8 9
System.out.println();
Integer[] b = {2, 3, 4, 1, 0, 6, 5};
Arrays.sort(b,Collections.reverseOrder()); //降序
//不支持基本类型int，double，char，如果是int型需要改成Integer，float要改成Float
for (int num : b) System.out.print(num+" "); //输出： 6 5 4 3 2 1 0
System.out.println();
String s = "hello world";
char[] chars = s.toCharArray();
Arrays.sort(chars);
s = new String(chars);
//Java中字符串是不可变的，因此不能直接在原字符串上进行排序。可以将字符串转换为字符数组进行排序，然后再将排序后的字符数组转换回字符串。
System.out.println(s); //输出： dehllloorw
ArrayList<Integer> list = new ArrayList<>();
list.add(36);
list.add(52);
list.add(15);
Collections.sort(list);
System.out.print(list); //输出： [15, 36, 52]
}
}
5. 例题
例1 排序的基本应用
输油管道问题
已知n个油井的y坐标，把它们排个序， y 0 ≤ y 1 ≤ . . . ≤ y n − 1 y_0≤y_1≤...≤y_{n-1} y0≤y1≤...≤yn−1。
设主管道的y坐标是m，那么就是求 ∣ y 0 − m ∣ + ∣ y 1 − m ∣ + . . . + ∣ y n − 1 − m ∣ |y_0-m|+|y_1-m|+...+|y_{n-1}-m| ∣y0−m∣+∣y1−m∣+...+∣yn−1−m∣的最小值。
m肯定大于 y 0 y_0 y0小于 y n − 1 y_{n-1} yn−1，猜测是平均值，或者中位数。容易证明是中位数，例如n=7，m是 y 3 y_3 y3；n=8，m是 y 3 y_3 y3或 y 4 y_4 y4。
C++代码
#includeJava代码
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] y = new int[n];
for (int i = 0; i < n; i++) {
int x = sc.nextInt();
y[i] = sc.nextInt();
}
Arrays.sort(y);
int m = y[n/2];
int ans = 0;
for (int i = 0; i < n; i++) ans += Math.abs(m - y[i]);
System.out.println(ans);
}
}
Python代码
n = int(input())
y = []
for i in range(n):
x, yi = map(int, input().split())
y.append(yi)
y.sort()
m = y[n//2]
ans = 0
for i in range(n): ans += abs(m - y[i])
print(ans)
例2 排序的基本应用
肖恩的排序
先考虑简单直接的做法。题目要求“所有位置i都有A[i] > B[i]”，先对A从小到大排序，然后枚举B数组，对某个B[i]，若有个A[j]>B[i]，那么A[j]~A[n-1]都合法。找到所有这种排列，就是答案。但是这样做计算量极大。
题目只要求A[i]>B[i]，那么A[]和B[]内部的顺序对答案没有影响。对于位置i，A[i]可以是A[]中所有大于B[i]的元素。所以对A[]和B[]排序方便计算。
先从大到小对A[]和B[]排序，然后枚举B[]数组，步骤如下：
B[0]对应的A[]的元素，是大于B[0]的所有A[]的元素，设范围是A[i]~A[j]。
B[1]对应的A[]的元素，包括了两部分：第一部分是A[i]~A[j]，因为B[1] ≤
B[0]；第二部分是A[j]之后大于B[1]的那些A[]的元素。第一部分可以利用上一步的结果。另外，因为当前位置要选一个A[]，所以符合条件的数减一。
继续枚举其他B[]的元素，直到结束。
把每次符合要求的A[]的元素个数乘起来，就是答案。
C++代码。分析计算复杂度，第9行和第10行的sort()是O(nlogn)的，第12行和第13行合起来是O(n2)，总复杂度O(n2)。
#includeJava代码
import java.util.Arrays;
import java.util.Scanner;
public class Main {
static final int N = 100010;
static final int MOD = 1000000007;
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
int[] a = new int[N];
int[] b = new int[N];
for (int i = 0; i < n; i++) a[i] = scan.nextInt();
for (int i = 0; i < n; i++) b[i] = scan.nextInt();
Arrays.sort(a, 0, n); //从小到大排序
for (int i = 0; i < n/2; i++)
{int tmp=a[i]; a[i]=a[n-1-i];a[n-1-i]=tmp;} //从大到小
Arrays.sort(b, 0, n); //从小到大排序
for (int i = 0; i < n/2; i++)
{int tmp=b[i]; b[i]=b[n-1-i];b[n-1-i]=tmp;} //从大到小
long cnt = 0, ans = 1;
int j = 0;
for (int i = 0; i < n; i++) {
while (j < n && a[j] > b[i]) {
cnt++;
j++;
}
ans *= cnt;
cnt--;
ans %= MOD;
}
System.out.println(ans);
}
}
Python代码
```python
n = int(input())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
a.sort(reverse=True)
b.sort(reverse=True)
cnt, ans = 0, 1
j = 0
for i in range(n):
while j < n and a[j] > b[i]:
cnt += 1
j +=1
ans *= cnt
cnt -= 1
ans %= int(1e9+7)
print(ans)
例3 自定义排序比较函数
数位排序
用这一题熟悉sort()中的自定义比较函数。
C++代码。本题看似不好做，实际上可以利用sort (first, last, comp)中的自定义比较函数comp，简单地实现。
#includejava代码。注意Arrays.sort()如何自定义比较。
import java.util.*;
public class Main {
public static int sum(int num) {
int ans = 0;
while(num>0) {
ans+=num%10;
num/=10;
}
return ans;
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
int m = scanner.nextInt();
int [][]a = new int[n][2];
for (int i=0;i<n;i++){
a[i][0] = sum(i+1);
a[i][1] = i+1;
}
Arrays.sort(a,(v1,v2)->{
if (v1[0]!=v2[0]) return v1[0]-v2[0];
return v1[1]-v2[1];
});
System.out.println(a[m-1][1]);
}
}
Python代码。用lambda自定义比较。
def sum(x): # 计算每一个数的数位和
ans = 0
while x:
ans += x % 10
x //= 10
return ans
n=int(input())
m=int(input())
a=list(range(1,n+1)) #赋值a[0]~a[n]，注意rang(1,n+1)最后一个是a[n]
a.sort(key=lambda i:sum(i))
print(a[m-1])
例4 结构体排序
排队接水
用这一题熟悉结构体排序
C++代码
#includeJava代码
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
double time=0;
node[] a=new node[n+10];
for (int i = 1; i <=n ; i++)
a[i]=new node(i,sc.nextInt());
Arrays.sort(a,1,n+1,(x,y)->(x.t-y.t));
for (int i = 1; i <=n ; i++)
System.out.print(a[i].id+" ");
for (int i = 1; i <=n; i++)
time+=a[i].t*(n-i);
System.out.println();
System.out.printf("%.2f",time/n);
}
}
class node{
int id;
int t;
public node(int id, int t) {
this.id = id;
this.t = t;
}
}
Python代码
n = int(input())
t = list(map(int, input().split()))
a = [(id, e) for id, e in enumerate(t)]
a.sort(key=lambda x:x[1])
print(' '.join([str(i + 1) for i, e in a]))
time = [0] * n
tmp = 0
for i, (j, e) in enumerate(a):
time[i] = tmp
tmp += e
print('{:.2f}'.format(sum(time) / len(time)))
例5 结构体排序
分香蕉
这是一道有点啰嗦的排序题，需要做多次排序：（1）香蕉按质量排序；（2）猴子按分配到的香蕉排序；（3）猴子按编号排序。最好用结构体排序。
C++代码
#includeJava代码
import java.util.*;
public class Main {
static class Monkey {
int w, id, y; //猴子的重量、编号、吃到的香蕉
public Monkey(int w, int id, int y) {
this.w = w;
this.id = id;
this.y = y;
}
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
int m = scanner.nextInt();
ArrayList<Integer> banana = new ArrayList<>();
for (int i = 0; i < n; i++) banana.add(scanner.nextInt());
Collections.sort(banana);
ArrayList<Monkey> monkeys = new ArrayList<>();
for (int i = 0; i < m; i++)
monkeys.add(new Monkey(scanner.nextInt(), i + 1, 0));
Collections.sort(monkeys, (a, b) -> b.w - a.w); //猴子按重量排序
int[] part = new int[m];
for (int i = 0; i < n; i++)
part[i % m] += banana.get(n - i - 1); //把香蕉分成m份
for (int i = 0; i < m; i++)
monkeys.get(i).y = part[i % m]; //分给m个猴子
Collections.sort(monkeys, (a, b) -> a.id - b.id); //按编号排序，回到初始排序
for (int i = 0; i < m; i++)
System.out.print(monkeys.get(i).y + " "); //输出每个猴子的香蕉数量
}
}
Python代码
n,m=map(int,input().split())
banana=list(map(int,input().split())) #香蕉质量
banana.sort(reverse=True) #香蕉排序
monkey=list(map(int,input().split())) #猴子重量
id=[i for i in range(1,m+1)] #猴子编号
part=[0 for i in range(1,m+1)]
weight=list(zip(id,monkey,part))
weight=map(list,weight)
weight=sorted(weight,key=lambda x:x[1],reverse=True) #猴子按重量排序
for i in range(len(banana)): #把香蕉分成m份
weight[i%m][2] += banana[i]
weight.sort() #猴子按编号排序
for i in range(len(monkey)):
print(weight[i][2],end=' ')
6. 习题
统计数字
错误票据
奖学金
外卖店优先级
双向排序
第几个幸运数字
插入排序
排个序
图书管理员
瑞士轮
肖恩的大富翁