leetcode 排序

快排

class Soultion:
	def partition(self,ls,left,right):
		mid = ls[left]
		while left<right:
		#只有这个位置要带等号
			while left < right and ls[right]>=mid:
				right-=1
			ls[left] = ls[right]
			while left < right and ls[left]<=mid:
				left+=1
			ls[right] = ls[left]
		ls[left]=mid
		return left
		
	def quick_sort(self,ls, left, right):
		if left<rigth:
			mid = self.partition(ls,left,right)
			self.quick_sort(ls,left,mid-1)
			self.quick_sort(ls,mid+1,right)

找到第k大的数 leetcode 215

class Soultion:
	def partition(self,ls,left,right):
		mid = ls[left]
		while left<right:
		#只有这个位置要带等号
			while left < right and ls[right]>=mid:
				right-=1
			ls[left] = ls[right]
			while left < right and ls[left]<=mid:
				left+=1
			ls[right] = ls[left]
		ls[left]=mid
		return left
	
    def find_(self, nums, k, left, right):
        mid = self.partition(nums, left, right)
        if mid > k:
            # 说明在左半边
            return self.find_(nums, k, left, mid - 1)
        elif mid < k:
            # 说明在右半边
            return self.find_(nums, k, mid + 1, right)
        # nums[k]已经是第k+1大的数
        return nums[k]

    def findKthLargest(self, nums: List[int], k: int) -> int:
        return self.find_(nums, len(nums) - k, 0, len(nums) - 1)
	
	

• partition是共用的，作用是把某一个位置的顺序排好，并且把左右位置的大小关系给出来。
• 很重要的是有个return，dfs大多不需要return，因为dfs是进去改变一个状态，如果递归是要返回值的都需要在对应的内容处有值，比如归并排序是接这个值，然后再去做什么。快排不是，是得到值不需要在做啥了，直接要返回 。

import heapq
class Soultion:
    def findKthLargest(self, nums, k):
        l = []
        while k and nums:
            heapq.heappush(l,nums.pop())
            k-=1
        while nums:
            next = nums.pop()
            tmp = heapq.heappop(l)
            # 注意这是把大的放进去，意思是最小的都是大的
            val = tmp if tmp>next else next
            heapq.heappush(l,val)
        return heapq.heappop(l)

• 维护一个大小为k的堆

出现频率最多的 k 个元素 lc 347

class Solution:
    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
        adict = {}
        for i in nums:
            if i in adict:
                adict[i]+=1
            else:
                adict[i]=1
        tmp = sorted([(-value,key) for (key,value) in adict.items()])
        res = []
        for i,j in enumerate(tmp):
            if i<k:
                res.append(j[1])
        return res
        
   #第二种直接调用相关api
    def topKFrequent2(self,nums,k):
        d = Counter(nums)
        return [i[0] for i in d.most_common(k)]

• sorted的妙用，直接k，v反过来形成tuple然后取前几个的k。

根据字符出现频率排序 lc 451

输入:“tree”
输出:“eert”

class Solution:
    def frequencySort(self, s: str) -> str:
        adict = {}
        for i in s:
            if i not in adict:
                adict[i] = 1
            else:
                adict[i]+=1
        tmp = sorted([(-v,k) for k,v in adict.items()])
        res = ''
        for i in tmp:
            res+=abs(i[0])*i[1]
        return res