leetcode系列题四----排序

leetcode系列题四----排序

已经很少见考冒泡的了，重点关注快排和归并

912.排序数组 （快排、归并）
913.对链表进行插入排序 （插入排序）
914.合并两个有序链表 （归并排序）
148.排序链表 (归并排序)
剑指 Offer 51. 数组中的逆序对 （归并排序）

快排

#快排模板
def quick_sort(l,r):
	if l >= r: return 
	ids = random.randrange(l,r+1)
	nums[l],nums[ids] = nums[ids],nums[l]
	i,j = l,r
	while i<j:
		while i<j and nums[j] >= nums[l]: j -= 1
		while i<j and nums[i] <= nums[l]: i += 1
		nums[i], nums[j] = nums[j],nums[i]
	nums[i],nums[l] = nums[l],nums[i]
	quick_sort(l,i-1)
	quick_sort(i+1,r)

最坏时间复杂度O(n^2), 平均O(nlogn),空间复杂度最坏需要O(n)的递归栈空间

但是平均来讲，快排要好于归并与堆排序的，1是因为最差情况的稀疏性，2是因为缓存使用效率高，3是常数系数低，比较赋值交换三种操作综合耗时最低。 因此sort等函数都使用的是快排

归并

归并的本质就是BFS+有序数组合并（双指针）。 类似的题目比如有序链表合并等等。

#归并模板
def merge_sort(l,r):
	if l >= r: return
	m = (l+r)//2 
	merge_sort(l,m)
	merge_sort(m+1,r)
	temp = nums[l:r+1]
	i,j = 0, m-l+1
	for k in range(l,r+1):
		if i == m-l+1:
			nums[k] = temp [j]
			j+=1
		elif j == r-l+1 or temp [i] <= temp [j]:
			nums[k] = temp [i]
			i+=1
		else:
			nums[k] = temp [j]
			j+=1

时间复杂度为O(nlogn)，最佳，最差，平均皆是如此。空间复杂度O(n),借助了辅助数组temp。如果是链表，空间复杂度可以优化至O(1)

对于链表，主要有两个注意点：
1、通过快慢指针找到中心点
2、借助辅助头节点，双指针排序链表

def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        if not head or not head.next: return head
        slow,fast = head, head.next
        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next
        mid, slow.next = slow.next, None
        left = self.sortList(head)
        right = self.sortList(mid)
        res = res_head = ListNode(0)
        while left and right:
            if left.val <= right.val:
                res.next = left
                left = left.next
                res = res.next
            else:
                res.next = right
                right = right.next
                res = res.next
        if left:
            res.next = left
        if right:
            res.next = right
        return res_head.next

堆排序

295. 数据流的中位数
296. 数组中的第K个最大元素
297. 前 K 个高频元素
     面试题40. 最小的k个数

1、代码模板

大根堆小根堆的问题：python自带库中的heap只是小根堆，没有直接建大根堆的模块，处理时直接将值取反用小根堆即可

常见的问题是100w的数取前k，由于基数很大，其他的排序算法会很慢，但是堆排序对这类问题比较有优势.堆排序的算法时间复杂度为O(nlogn)当只找前k个数时是O(nlogk),当k很小时，时间复杂度去向于O(n)

虽然python有内建库，但是面试往往会要求手写，所以两种方法都要会。

2、标题python内建库

heap = [] #创建了一个空堆
heappush(heap,item) #往堆中插入一条新的值
item = heappop(heap) #从堆中弹出最小值
item = heap[0] #查看堆中最小值，不弹出
heapify(x) #以线性时间讲一个列表转化为堆
item = heapreplace(heap,item) #弹出并返回最小值，然后将heapqreplace方法中item的值插入到堆中，堆的整体结构不会发生改变。这里需要考虑到的情况就是如果弹出的值大于item的时候我们可能就需要添加条件来满足function的要求

堆排序：

def heapsort(iterable):
    heap = []
    for value in iterable:
        heapq.heappush(heap,value) #[0, 1, 2, 6, 3, 5, 4, 7, 8, 9]
    return [heapq.heappop(heap) for i in range(len(heap))]
print (heapsort([1,3,5,7,9,2,4,6,8,0]))

对于前 K 个高频元素

def topkfrequent(nums,k):
	count = collections.Counter(nums)
	heap = []#小-》大
	for key,val in count.items():
		if len(heap) >= k:
			if val > heap[0][0]:
				heapq.heapreplace(heap,(val,key))
		else:
			heapq.heappush(heap, (val,key))
	return [item[1] for item in heap]

自己实现大顶堆小顶堆：

未完持续