leetcode笔记｜第十三周 排序

第十三周 排序 python对于排序的题真是太偷懒了

242 有效的字母异位词

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        # 统计每个元素出现的次数用Counter()
        return Counter(s)==Counter(t)

922按奇偶排序数组 II

class Solution:
    def sortArrayByParityII(self, A: List[int]) -> List[int]:
        # 笨方法：将元素分为奇数偶数list，然后一边一个放进res
        res = []
        res_odd = []
        res_even = []
        for i in range(len(A)): # 其实可以for a in A：
            if A[i]%2==0:
                res_even.append(A[i])
            else:
                res_odd.append(A[i])
        for i in range(len(res_even)):
            res.append(res_even[i])
            res.append(res_odd[i])
        return res

        # 一遍：双指针，放了之后移到下面位置
        even = 1
        odd = 0 # odd奇数，但是第1个是0，所以“反了”
        res = [-1]*len(A)
        for a in A:
            if a % 2 ==0:
                res[odd] = a
                odd += 2
            else:
                res[even] = a
                even += 2
        return res

1329.将矩阵按对角线排序

class Solution:
    def diagonalSort(self, mat: List[List[int]]) -> List[List[int]]:
        # 思路：把每一对角线都列出list，然后sort()排序以后覆盖mat
        m,n = len(mat),len(mat[0])
        # 第一行和第一列是起点
        start = [(0,0)]+[(i,0) for i in range(m)]+[(0,j) for j in range(n)]
        # 对每个起点都建立sortlist是mat对角线元素的list然后sort()
        for (i,j) in start:
            sortlist = [mat[i+k][j+k] for k in range(min(m,n)) if i+k<m and j+k<n]
            sortlist.sort()
            # sortlist覆盖当前对角线元素值
            for k in range(len(sortlist)):
                mat[i+k][j+k] = sortlist[k]
        return mat

剑指 Offer 45. 把数组排成最小的数

输入[3,30]，输出"303"

class Solution:
    def minNumber(self, nums: List[int]) -> str:
        # 法1: python内置函数
        # [3,30]按照3/9和30/99大小排序，得到应该是303不是330
        tmp = sorted(nums, key=lambda x:x/(10**len(str(x))-1))
        # 将list的num按照str拼接
        return "".join(map(str, tmp))

        # 其实应该用快排的
        def fast_sort(l,r):
            if l>=r: return
            i,j = l,r
            while i<j:
                # i,j分别移动到比target=nums[i]大和小的位置，互换
                while i<j and nums[j]+nums[l]>=nums[l]+nums[j]: j-=1
                while i<j and nums[i]+nums[l]<=nums[l]+nums[i]: i+=1
                nums[i], nums[j] = nums[j], nums[i]
            # 然后左右两边分别快排
            nums[i], nums[l] = nums[l], nums[i]
            fast_sort(l,i-1)
            fast_sort(i+1,r)

        nums = [str(i) for i in nums]
        fast_sort(0, len(nums)-1)
        return "".join(nums)

面试题 17.14. 最小K个数

class Solution:
    def smallestK(self, arr: List[int], k: int) -> List[int]:
        # python 的各种函数 是很方便 但是好像真的很令人恼火
        arr.sort()
        return arr[:k]
        # 冒泡排序法，时间复杂度高，超时
        for i in range(len(arr)):
            for j in range(i+1,len(arr)):
                if arr[i]>arr[j]:
                    arr[i], arr[j] = arr[j], arr[i]
        return arr[:k]

1630 等差子数组

class Solution:
   def checkArithmeticSubarrays(self, nums: List[int], l: List[int], r: List[int]) -> List[bool]:
       # 自己写的，开心
       res = []
       for i in range(len(l)):
           tmp = nums[l[i]:r[i]+1]
           tmp.sort()
           flag = True
           if len(tmp)==0 or len(tmp)==1: break # 有没有都行
           # 很蠢的是遍历所有的前后差值是否为同一个值，用flag标注
           cha = tmp[1]-tmp[0]
           for j in range(2,len(tmp)):
               if tmp[j]-tmp[j-1]!=cha:
                   flag = False
                   break
           res.append(flag)
       return res

973 最接近原点的 K 个点

对list每个元素按照x^2+y2大小排序

class Solution:
    def kClosest(self, points: List[List[int]], K: int) -> List[List[int]]:
        res = []
        # 排序的第一种写法
        points = sorted(points, key=lambda x:x[0]**2+x[1]**2)
        # 排序的第二种写法
        points.sort(key=lambda x:x[0]**2+x[1]**2)
        return points[:K]