[刷题] MergeSort

题目1️⃣:

数组中的逆序对数.

思路:

利用归并排序的思想.

  1. 首先将数组分为两两组合, 再对两两组合排序, 排序的过程中记录是不是逆序对数.
  2. 然后再对这些组合排序, 在排序的过程中, 再对左右两边的子串进行逆序的计数.然后再对这些组合排序, 在排序的过程中, 再对左右两边的子串进行逆序的计数.
  3. 采用递归, 终止条件肯定是字符串的字数小于2.
  4. 每次对字符串分两组递归. 计数的条件是当前面的数组的元素大于后面数组的元素时, 这时计数累积的是前面数组的未排序元素的个数.
  5. O(nlogn)
count = 0
def MergeSort(nums):
	global count
	if nums <= 1 :
		return nums
	mid = len(nums) // 2
	left = MergeSort(nums[:mid])
	right = MergeSort(nums[mid:])
	l, r =0
	result = []
	while l < len(left) and r < len(right):
		if left[l] <= right[r]:
			result.append(left[l])
			l += 1
		else:
			reslut.append(right[r])
			r += 1
			count += len(left) - l
	result += left[l:]
	result += right[r:]
	return  result
			

题目2️⃣:

合并n个有序链表

思路:

也可以用分治的思想, 将n个有序链表两两合并. 不过时间复杂度很高, 另一种方法是使用堆来做.

def MergeKlists(lists):

	if not lists:
		return None
	if len(lists) == 1:
		return lists[0]
	if len(lists) == 2:
		return MergeTwo(lists[0], lists[1])
	mid = len(lists) // 2
	left = mergeKlists(lists[:mid])
	right = mergetKlists(lists[mid:])
	
	return mergeTwo(left,right)
	
def MergeTwo(l1,l2):
	dummy  = ListNode(0)
	pre = dummy
	while l1 and l2:
		if l1.val < l2.val:
			pre.next = l1
			l1 = l1.next
		else:
			pre.next = l2
			l2 = l2.next
		pre = pre.next
	pre.next = ll if l1 else l2
	return dummy.next

堆的方法:

import heapq
def mergeLists(lists):
	if not lists:
		return None
	heap = []
	for node in lists:
		if node:
			heapq.heappush(heap,(node.val, node))
		dummy = pre = ListNode(-1)
		while heap:
			_, cur = heapq.heappop(heap)
			if cur.next:
				heapq.heappush(heap,(cur.val,cur)
			pre.next = cur
			pre = cur
	return dummy.next
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值
>