【leetcode】排序题（python）

简单难度
- 1370：上升下降字符串(type: easy)
- 349、两个数组的交集(type: easy)
- 1356、根据数字二进制下 1 的数目排序
- 922、按奇偶排序数组 II
- 1122、数组的相对排序
- 976、三角形的最大周长
- 1030、距离顺序排列矩阵单元格
- 242、有效的字母异位词
- 350、两个数组的交集 II
- 5376、非递增顺序的最小子序列
中等难度
- 面试题 16.21. 交换和
- 75、颜色分类
- 56、合并区间
- 面试题45、把数组排成最小的数
- 179、最大数
- 1387、将整数按权重排序
- 1329、将矩阵按对角线排序
- 面试16.16 部分排序
- 1333、餐厅过滤器
- 973、最接近原点的K个点

简单难度

1370：上升下降字符串(type: easy)

题目描述的复杂，其实就是不停地按字典序升序追加，降序追加，每次加一个
示例：

输入：s = "aaaabbbbcccc"
输出："abccbaabccba"
输入：s = "leetcode"
输出："cdelotee"

代码：
预排序+双栈实现，逻辑比较清晰

class Solution(object):def sortString(self, s):""":type s: str:rtype: str"""res = ''stack1 = sorted(s,reverse=True)stack2 = []while stack1 or stack2:while stack1:if len(stack1) == 1 or stack1[-1] < stack1[-2]:res+=stack1.pop()else:stack2.append(stack1.pop())while stack2:if len(stack2) == 1 or stack2[-1] > stack2[-2]:res += stack2.pop()else:stack1.append(stack2.pop())return res

349、两个数组的交集(type: easy)

给定两个数组，编写一个函数来计算它们的交集。
示例：

输入: nums1 = [1,2,2,1], nums2 = [2,2]
输出: [2]
输入: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出: [9,4]

代码：
主要用到了in和not in判断元素是否在某个数组里，为了减小运行时间，判断数组大小，以小的开始计算。

class Solution(object):def intersection(self, nums1, nums2):""":type nums1: List[int]:type nums2: List[int]:rtype: List[int]"""res = []if len(nums1) < len(nums2):for i in range(len(nums1)):if (nums1[i] in nums2) and (nums1[i] not in res):res.append(nums1[i])else:for i in range(len(nums2)):if (nums2[i] in nums1) and (nums2[i] not in res):res.append(nums2[i])return res

1356、根据数字二进制下 1 的数目排序

给你一个整数数组 arr 。请你将数组中的元素按照其二进制表示中数字 1 的数目升序排序。
如果存在多个数字二进制中 1 的数目相同，则必须将它们按照数值大小升序排列。
示例：

输入：arr = [0,1,2,3,4,5,6,7,8]
输出：[0,1,2,4,8,3,5,6,7]
输入：arr = [1024,512,256,128,64,32,16,8,4,2,1]
输出：[1,2,4,8,16,32,64,128,256,512,1024]

思路1： sorted()的功能就是对序列进行排序，key指定的函数将作用于list的每个元素上，并根据key函数返回的结果进行排序。
sorted(arr, key=lambda x:(bin(x).count(‘1’),x)):按照1的个数排列，1个数相同时，按照arr的顺序输出
lambda x:[bin(x).count(‘1’), x] : lambda改成输出为元组或list，sort在比较第一个数相同后，再比较第二个数
代码：

class Solution(object):def sortByBits(self, arr):""":type arr: List[int]:rtype: List[int]"""return sorted(arr, key=lambda x:[bin(x).count('1'), x])

思路2： 初始一个空字典，二进制1的个数为键，对应的数字为值，分别进行排序。
代码：

class Solution(object):def sortByBits(self, arr):""":type arr: List[int]:rtype: List[int]"""res = []dic = {}for i in arr:n = bin(i).count('1')    # 计算二进制1的个数if n not in dic:dic[n] =[]dic[n].append(i)  # ’二进制1的个数‘:对应的数字for i in sorted(dic):  # 按二进制1的个数排列res+=sorted(dic[i])   # 按对应数字排列return res

922、按奇偶排序数组 II

给定一个非负整数数组 A， A 中一半整数是奇数，一半整数是偶数。
对数组进行排序，以便当 A[i] 为奇数时，i 也是奇数；当 A[i] 为偶数时， i 也是偶数。
示例：

输入：[4,2,5,7]
输出：[4,5,2,7]
解释：[4,7,2,5]，[2,5,4,7]，[2,7,4,5] 也会被接受。

思路： 两个栈分别存储偶数和奇数，再按偶数奇数次序交替输出。学习的点：判断奇数偶数时，位操作（num&1）比余数操作（num%2）更快，占的内存更小。
代码：

class Solution(object):def sortArrayByParityII(self, A):""":type A: List[int]:rtype: List[int]"""stack_odd = []stack_even = []res = []for a in A:if a & 1:  # oddstack_odd.append(a)else:   # evenstack_even.append(a)for i in range(len(stack_even)):    res.append(stack_even[i])res.append(stack_odd[i])return res

1122、数组的相对排序

给你两个数组，arr1 和 arr2，
arr2 中的元素各不相同；arr2 中的每个元素都出现在 arr1 中
对 arr1 中的元素进行排序，使 arr1 中项的相对顺序和 arr2 中的相对顺序相同。未在 arr2 中出现过的元素需要按照升序放在 arr1 的末尾。
示例：

输入：arr1 = [2,3,1,3,2,4,6,7,9,2,19], arr2 = [2,1,4,3,9,6]
输出：[2,2,2,1,4,3,3,9,6,7,19]

代码：

class Solution(object):def relativeSortArray(self, arr1, arr2):""":type arr1: List[int]:type arr2: List[int]:rtype: List[int]"""res = []pop_num = 0for i in arr2:    # arr2按顺序循环，判断元素是否存在arr1中if i in arr1:pop_num = 0for j in range(len(arr1)):j = j - pop_numif arr1[j] == i:res.append(arr1.pop(j))    # 将对应索引pop到res，最后剩下未在arr2出现过的值。pop_num += 1return res + sorted(arr1)

976、三角形的最大周长

给定由一些正数（代表长度）组成的数组 A，返回由其中三个长度组成的、面积不为零的三角形的最大周长。
如果不能形成任何面积不为零的三角形，返回 0。
示例：

输入：[2,1,2]
输出：5
输入：[3,2,3,4]
输出：10

思路： 大到小排序后，判断相邻3个数是否满足三角形条件，如满足则为最大值。三角形条件：两短边之和大于长边；最大值如果小于两相邻较小值，则后续的值无需比较。
代码：

class Solution(object):def largestPerimeter(self, A):""":type A: List[int]:rtype: int"""A = sorted(A, reverse=True) # 大到小排序for a in range(len(A)-2):if A[a] < A[a+1] +A [a+2]:  # 满足两短边之和大于长边即可return  A[a] + A[a+1] +A [a+2]  # 周长return 0

1030、距离顺序排列矩阵单元格

给出 R 行 C 列的矩阵，其中的单元格的整数坐标为 (r, c)，满足 0 <= r < R 且 0 <= c < C。
另外，我们在该矩阵中给出了一个坐标为 (r0, c0) 的单元格。
返回矩阵中的所有单元格的坐标，并按到 (r0, c0) 的距离从最小到最大的顺序排，其中，两单元格(r1, c1) 和 (r2, c2) 之间的距离是曼哈顿距离，|r1 - r2| + |c1 - c2|。（你可以按任何满足此条件的顺序返回答案。）
示例：

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

代码： 此题思路和1356二进制排序一样

class Solution(object):def allCellsDistOrder(self, R, C, r0, c0):""":type R: int:type C: int:type r0: int:type c0: int:rtype: List[List[int]]"""dic = {}res = []for r in range(R):for c in range(C):distance = abs(r-r0)+abs(c-c0)if distance not in dic:dic[distance] = []dic[distance].append([r,c])for i in sorted(dic):res+=sorted(dic[i])return res

242、有效的字母异位词

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
示例：

输入: s = "anagram", t = "nagaram"
输出: true

代码： 解法比较取巧

class Solution(object):def isAnagram(self, s, t):""":type s: str:type t: str:rtype: bool"""return sorted(s) == sorted(t)

350、两个数组的交集 II

给定两个数组，编写一个函数来计算它们的交集。
示例：

输入: nums1 = [1,2,2,1], nums2 = [2,2]
输出: [2,2]

代码：

class Solution(object):def intersect(self, nums1, nums2):""":type nums1: List[int]:type nums2: List[int]:rtype: List[int]"""res = []if len(nums1) < len(nums2):for i in range(len(nums1)):if nums1[i] not in nums2: continuefor j in range(len(nums2)):if(nums1[i] == nums2[j]):res.append(nums2.pop(j))breakelse:for i in range(len(nums2)):if nums2[i] not in nums1: continuefor j in range(len(nums1)):if(nums2[i] == nums1[j]):res.append(nums1.pop(j))breakreturn res

5376、非递增顺序的最小子序列

给你一个数组 nums，请你从中抽取一个子序列，满足该子序列的元素之和严格大于未包含在该子序列中的各元素之和。同时，返回的答案应当按非递增顺序排列。
示例：

输入：nums = [4,3,10,9,8]
输出：[10,9]
输入：nums = [4,4,7,6,7]
输出：[7,7,6]   # 非递增排序

思路： 小到大排序，nums每次把最大值给res，计算和的大小
代码：

class Solution(object):def minSubsequence(self, nums):""":type nums: List[int]:rtype: List[int]"""nums = sorted(nums)res = []while 1:res.append(nums.pop())if len(nums) == 0 or sum(res[:]) > sum(nums[:]):return res

中等难度

面试题 16.21. 交换和

给定两个整数数组，请交换一对数值（每个数组中取一个数值），使得两个数组所有元素的和相等。
返回一个数组，第一个元素是第一个数组中要交换的元素，第二个元素是第二个数组中要交换的元素。若有多个答案，返回任意一个均可。若无满足条件的数值，返回空数组。
示例：

输入: array1 = [4, 1, 2, 1, 1, 2], array2 = [3, 6, 3, 3]
输出: [1, 3]

代码：

class Solution(object):def findSwapValues(self, array1, array2):""":type array1: List[int]:type array2: List[int]:rtype: List[int]"""diff = sum(array1) - sum(array2)if diff & 1: return []  # 差值一定为偶数，sum_1-set_1[i]+set_2[j] == sum_2-set_2[j]+set_1[i]diff >>= 1  # diff/2array1 = list(set(array1))  # 转集合再转列表减少参数s2 = set(array2)for a in array1:if a - diff in s2:return [a, a - diff]return []

75、颜色分类

给定一个包含红色、白色和蓝色，一共 n 个元素的数组，原地对它们进行排序，使得相同颜色的元素相邻，并按照红色、白色、蓝色顺序排列。
此题中，我们使用整数 0、 1 和 2 分别表示红色、白色和蓝色。
注意:不能使用代码库中的排序函数来解决这道题。
示例：

输入: [2,0,2,1,1,0]
输出: [0,0,1,1,2,2]

思路： 遍历数组，将0丢到p0位置，将2丢到p2位置，注意在把2丢到p2位置后，需要再判断相同位置的值（与2交换的值）。

代码：

class Solution(object):def sortColors(self, nums):""":type nums: List[int]:rtype: None Do not return anything, modify nums in-place instead."""p0 = 0p2 = len(nums)-1cur_pt = 0while cur_pt <= p2: # p2后面均正确if nums[cur_pt] == 0:nums[p0], nums[cur_pt] = nums[cur_pt], nums[p0]cur_pt += 1 # 确保前面均正确，移动到下一个元素p0 += 1elif nums[cur_pt] == 2:nums[p2], nums[cur_pt] = nums[cur_pt], nums[p2]p2 -= 1else:cur_pt += 1

56、合并区间

给出一个区间的集合，请合并所有重叠的区间。
示例：

输入: [[1,3],[2,6],[8,10],[15,18]]
输出: [[1,6],[8,10],[15,18]]
解释: 区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].

代码：

class Solution(object):def merge(self, intervals):""":type intervals: List[List[int]]:rtype: List[List[int]]"""intervals = sorted(intervals)  # 排序i = 0while i < len(intervals):j = i+1while j < len(intervals):if intervals[i][1] >= intervals[j][0]:   # 区间1后端大于或等于区间2前端，在区间1位置插入合并区间intervals.insert(i, [min(intervals[i][0], intervals[j][0]), max(intervals[i][1], intervals[j][1])])    # 注意合并区间大小intervals.pop(i+1)   # 丢掉原来的区间intervals.pop(j)   # j不用加1i -= 1  # 从合并区间位置继续循环breakj += 1i += 1return intervals

面试题45、把数组排成最小的数

输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。
示例：

输入: [3,30,34,5,9]
输出: "3033459"

代码： 字符串两两组合，判断组合后的大小。再用选择排序

class Solution(object):def minNumber(self, nums):""":type nums: List[int]:rtype: str"""str_nums = ''for i in range(len(nums)):for j in range(i+1, len(nums)):if str(nums[i])+str(nums[j]) > str(nums[j])+str(nums[i]):nums[i], nums[j] = nums[j], nums[i]for i in nums:str_nums = str_nums + str(i)return str_nums

179、最大数

给定一组非负整数，重新排列它们的顺序使之组成一个最大的整数。
示例：

输入: [3,30,34,5,9]
输出: 9534330

代码： 与上一题类似

class Solution(object):def largestNumber(self, nums):""":type nums: List[int]:rtype: str"""if max(nums) != 0:str_num = []for num in nums:str_num.append(str(num))for i in range(len(str_num)):for j in range(i+1, len(str_num)):if str_num[i]+str_num[j] < str_num[j]+str_num[i]:str_num[i], str_num[j] = str_num[j], str_num[i]res = ''for i in str_num:res += ireturn reselse:return '0'

1387、将整数按权重排序

我们将整数 x 的权重定义为按照下述规则将 x 变成 1 所需要的步数：
如果 x 是偶数，那么 x = x / 2；如果 x 是奇数，那么 x = 3 * x + 1
比方说，x=3 的权重为 7 。因为 3 需要 7 步变成 1 （3 --> 10 --> 5 --> 16 --> 8 --> 4 --> 2 --> 1）。
给你三个整数 lo， hi 和 k 。你的任务是将区间 [lo, hi] 之间的整数按照它们的权重升序排序，如果大于等于 2 个整数有相同的权重，那么按照数字自身的数值升序排序。
请你返回区间 [lo, hi] 之间的整数按权重排序后的第 k 个数。
注意，题目保证对于任意整数 x （lo <= x <= hi），它变成 1 所需要的步数是一个 32 位有符号整数。
示例：

输入：lo = 12, hi = 15, k = 2
输出：13
解释：12 的权重为 9（12 --> 6 --> 3 --> 10 --> 5 --> 16 --> 8 --> 4 --> 2 --> 1）
13 的权重为 9、14 的权重为 17、15 的权重为 17
区间内的数按权重排序以后的结果为 [12,13,14,15] 。对于 k = 2 ，答案是第二个整数也就是 13 。
注意，12 和 13 有相同的权重，所以我们按照它们本身升序排序。14 和 15 同理。

代码： 递归+关键字lambda排序

class Solution(object):def getKth(self, lo, hi, k):""":type lo: int:type hi: int:type k: int:rtype: int"""def getWeight(x):   # 递归计算权值if x == 1:  return 0return (getWeight(3*x+1) if x&1 else getWeight(x//2)) + 1res = list(range(lo, hi+1))res.sort(key=lambda x:(getWeight(x),x)) # (getWeight(x),x)先按权值排序，权值相等时按元素排序return res[k-1]

1329、将矩阵按对角线排序

给你一个 m * n 的整数矩阵 mat ，请你将同一条对角线上的元素（从左上到右下）按升序排序后，返回排好序的矩阵。
示例：

代码：

class Solution(object):def diagonalSort(self, mat):""":type mat: List[List[int]]:rtype: List[List[int]]"""R = len(mat)    # 行长度C = len(mat[0])   # 列长度start_point = []  # 左列和上行排序起始点for i in range(R):start_point.append([i, 0])for j in range(1, C):start_point.append([0, j])tmp = []for point in start_point: i, j = point[0], point[1]    # 起始点坐标while i < R and j < C:     # 暂存数据tmp.append(mat[i][j])i += 1j += 1tmp.sort(reverse=True)      # 大到小排序i, j = point[0], point[1]while i < R and j < C:       # 矩阵重新赋值mat[i][j] = tmp.pop()i += 1j += 1return mat

面试16.16 部分排序

给定一个整数数组，编写一个函数，找出索引m和n，只要将索引区间[m,n]的元素排好序，整个数组就是有序的。注意：n-m尽量最小，也就是说，找出符合条件的最短序列。函数返回值为[m,n]，若不存在这样的m和n（例如整个数组是有序的），请返回[-1,-1]。
示例：

输入： [1,2,4,7,10,11,7,12,6,7,16,18,19]
输出： [3,9]

代码： 只需要寻找最靠右的那个数（满足左边存在大于它的数），和最靠左的那个数（满足右边存在小于它的数）

class Solution(object):def subSort(self, array):""":type array: List[int]:rtype: List[int]"""sort_array = sorted(array)if array == sort_array:return [-1,-1]m = 0n = len(array) - 1MAX, MIN = array[m], array[n]for i in range(len(array)):if array[i] < MAX: n = i    # a[i]<max，则左边存在大于它的数else:   MAX = array[i]for i in range(len(array)-1, -1, -1):if MIN < array[i]:  m = i   # a[i]>min，则右边边存在于它的else:   MIN = array[i]return [m, n]

1333、餐厅过滤器

给你一个餐馆信息数组 restaurants，其中 restaurants[i] = [idi, ratingi, veganFriendlyi, pricei, distancei]。你必须使用以下三个过滤器来过滤这些餐馆信息。
其中素食者友好过滤器 veganFriendly 的值可以为 true 或者 false，如果为 true 就意味着你应该只包括 veganFriendlyi 为 true 的餐馆，为 false 则意味着可以包括任何餐馆。此外，我们还有最大价格 maxPrice 和最大距离 maxDistance 两个过滤器，它们分别考虑餐厅的价格因素和距离因素的最大值。
过滤后返回餐馆的 id，按照 rating 从高到低排序。如果 rating 相同，那么按 id 从高到低排序。简单起见， veganFriendlyi 和 veganFriendly 为 true 时取值为 1，为 false 时，取值为 0 。
示例：

输入：restaurants = [[1,4,1,40,10],[2,8,0,50,5],[3,8,1,30,4],[4,10,0,10,3],[5,1,1,15,1]], veganFriendly = 1, maxPrice = 50, maxDistance = 10
输出：[3,1,5]

代码：

class Solution(object):def filterRestaurants(self, restaurants, veganFriendly, maxPrice, maxDistance):""":type restaurants: List[List[int]]:type veganFriendly: int:type maxPrice: int:type maxDistance: int:rtype: List[int]""" i = 0while i < len(restaurants):  # 过滤餐厅if veganFriendly and restaurants[i][2] == 0 or restaurants[i][3] > maxPrice or restaurants[i][4] > maxDistance:restaurants.pop(i)else: i += 1restaurants.sort(reverse=True, key=lambda x:(x[1],x[0])) # 排序res = []for i in restaurants:res.append(i[0])return res

973、最接近原点的K个点

我们有一个由平面上的点组成的列表 points。需要从中找出 K 个距离原点 (0, 0) 最近的点。
（这里，平面上两点之间的距离是欧几里德距离。）
你可以按任何顺序返回答案。除了点坐标的顺序之外，答案确保是唯一的。
示例：

输入：points = [[1,3],[-2,2]], K = 1
输出：[[-2,2]]
解释：
(1, 3) 和原点之间的距离为 sqrt(10)，(-2, 2) 和原点之间的距离为 sqrt(8)，
由于 sqrt(8) < sqrt(10)，(-2, 2) 离原点更近。
我们只需要距离原点最近的 K = 1 个点，所以答案就是 [[-2,2]]。

代码： 缓存栈存储[distance, x, y]，倒序排序后取后K个值的坐标

class Solution:def kClosest(self, points: List[List[int]], K: int) -> List[List[int]]:stack = []res = []for x,y in points:dist =  (x**2+y**2)**0.5    # 计算欧式距离stack.append([dist, x, y])  stack = sorted(stack, reverse=True)for i in range(K):_, x, y = stack.pop()res.append([x, y])return res