sort 定制排序规则（配合functools.cmp_to_key()）

sort 定制排序规则（配合functools.cmp_to_key()）

配合例题学习
题目链接：179. 最大数
题目大意：给定一组非负整数 nums，重新排列每个数的顺序（每个数不可拆分）使之组成一个最大的整数。
注意：输出结果可能非常大，所以你需要返回一个字符串而不是整数。
注意：（1）1 <= nums.length <= 100；（2）0 <= nums[i] <= $10^9$。

示例：

输入：nums = [10,2]
输出："210"

输入：nums = [3,30,34,5,9]
输出："9534330"
 

参考代码：

class Solution:
    def largestNumber(self, nums: List[int]) -> str:
        def cmp(x,y):
            return 1 if x+y<y+x else -1
        nums = list(map(str,nums))
        nums.sort(key=functools.cmp_to_key(cmp))
        return ''.join(nums) if nums[0]!='0' else '0'

• 综合是用来 map容器，sort按照制定规则排序。

• 复杂度分析：时间上，由于是用来sort和functools，应该是二阶的，即$O(n^2)$，空间上，为$O(n)$.

• 23.2.27 补充一道题，区别于上面的定制函数，这里是 lambda 表达式了，题目链接为： 347. 前 K 个高频元素

题目链接：347. 前 K 个高频元素
题目大意：给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。你可以按 任意顺序 返回答案。

注意：（1）1 <= nums.length <= $10^5$；（2）k 的取值范围是 [1, 数组中不相同的元素的个数]；（3）题目数据保证答案唯一，换句话说，数组中前 k 个高频元素的集合是唯一的。

示例：

输入: nums = [1,1,1,2,2,3], k = 2
输出: [1,2]
示例 2:

输入: nums = [1], k = 1
输出: [1]
 

参考代码：

class Solution:
    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
        cnt = Counter(nums)
        return sorted(cnt,key=lambda x:-cnt[x])[:k]

• lambda 表达式 很需要好好学习。

• 复杂度分析：时间上，$O(nlogk)$，空间上，为$O(n)$.

• 23.2.28 补充一道题，也是 lambda 表达式了，题目链接为： 1030. 距离顺序排列矩阵单元格

题目链接：1030. 距离顺序排列矩阵单元格
题目大意：给定四个整数 rows , cols , rCenter 和 cCenter 。有一个 rows x cols 的矩阵，你在单元格上的坐标是 (rCenter, cCenter) 。
返回矩阵中的所有单元格的坐标，并按与 (rCenter, cCenter) 的 距离 从最小到最大的顺序排。你可以按 任何 满足此条件的顺序返回答案。
单元格(r1, c1) 和 (r2, c2) 之间的距离为 |r1 - r2| + |c1 - c2|。

注意：（1）1 <= rows, cols <= 100；（2）0 <= rCenter < rows；（3）0 <= cCenter < cols。

示例：

输入：rows = 1, cols = 2, rCenter = 0, cCenter = 0
输出：[[0,0],[0,1]]
解释：从 (r0, c0) 到其他单元格的距离为：[0,1]

输入：rows = 2, cols = 2, rCenter = 0, cCenter = 1
输出：[[0,1],[0,0],[1,1],[1,0]]
解释：从 (r0, c0) 到其他单元格的距离为：[0,1,1,2]
[[0,1],[1,1],[0,0],[1,0]] 也会被视作正确答案。

输入：rows = 2, cols = 3, rCenter = 1, cCenter = 2
输出：[[1,2],[0,2],[1,1],[0,1],[1,0],[0,0]]
解释：从 (r0, c0) 到其他单元格的距离为：[0,1,1,2,2,3]
其他满足题目要求的答案也会被视为正确，例如 [[1,2],[1,1],[0,2],[1,0],[0,1],[0,0]]
 

参考代码：

class Solution:
    def allCellsDistOrder(self, rows: int, cols: int, rCenter: int, cCenter: int) -> List[List[int]]:
        ans =  [[i,j] for i in range(rows) for j in range(cols)]
        ans.sort(key=lambda x:abs(x[0]-rCenter)+abs(x[1]-cCenter))
        return ans

• lambda 表达式 很好用啊。
• 复杂度分析：时间上，$O((m\times n)log(m\times n))$，空间上，为$O(log(m\times n)$，其中$m$和$n$分别为 $rows$ 和 $cols$ 的长度.