排序
概念理解
题目
029-最小的K个数(七种排序方法)
输入n个整数,找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字,则最小的4个数字是1,2,3,4。
方法一:蒂姆排序
蒂姆排序(时间复杂度O(nlogn),空间复杂度O(n))
蒂姆排序:结合使用了归并排序和插入排序
class Solution:
def GetLeastNumbers_Solution(self, tinput, k):
# write code here
if tinput==[] or len(tinput)<k:
return []
tinput.sort()
return tinput[:k]
方法二:冒泡排序
冒泡排序(时间复杂度O(n^2),空间复杂度O(1))
class Solution:
def GetLeastNumbers_Solution(self, tinput, k):
# write code here
def bubble_sort(lst):
for i in range(len(lst)):
for j in range(1,len(lst)-i):
if lst[j-1]>lst[j]:
lst[j-1], lst[j] = lst[j], lst[j-1]
return lst
if tinput==[] or len(tinput)<k:
return []
tinput = bubble_sort(tinput)
return tinput[:k]
方法三:快速排序
快速排序(时间复杂度O(n^2)~O(nlogn),空间复杂度O(logn))
class Solution:
def GetLeastNumbers_Solution(self, tinput, k):
# write code here
def quick_sort(lst):
if not lst:
return []
pivot = lst[0]
left = quick_sort([x for x in lst[1: ] if x < pivot])
right = quick_sort([x for x in lst[1: ] if x >= pivot])
return left + [pivot] + right
if tinput == [] or k > len(tinput):
return []
tinput = quick_sort(tinput)
return tinput[: k]
方法四:归并排序
归并排序(时间复杂度O(nlogn),空间复杂度O(n))
class Solution:
def GetLeastNumbers_Solution(self, tinput, k):
# write code here
def merge_sort(lst):
if len(lst)<=1:
return lst
mid = len(lst)//2
left = merge_sort(lst[:mid])
right = merge_sort(lst[mid:])
return merge(left,right)
def merge(left,right):
l,r,res = 0,0,[]
while l<len(left) and r<len(right):
if left[l] < right[r]:
res.append(left[l])
l += 1
else:
res.append(right[r])
r += 1
res += left[l:]
res += right[r:]
return res
if tinput==[] or len(tinput)<k:
return []
tinput = merge_sort(tinput)
return tinput[:k]
方法五:堆排序
堆排序(最大堆)(时间复杂度O(nlogn),空间复杂度O(1))
class Solution:
def GetLeastNumbers_Solution(self, tinput, k):
# write code here
def heap_sort(lst):
end = len(lst)
# 1.构建大顶堆,复杂度O(n)
for i in range(len(lst)//2-1,-1,-1): # i = [len(lst)//2-1, 0]
siftup(lst,lst[i],i,end)
# 2.交换定堆元素+调整堆结构,复杂度O((n-1)+nlogn)
for i in range(end-1,0,-1): # i = [end-1, 1]
temp,lst[i] = lst[i],lst[0] #将堆顶元素与末尾元素进行交换
siftup(lst,temp,0,i) #调整堆结构
return lst
def siftup(lst,temp,begin,end):
i,j = begin, begin*2+1 # 从i结点的左子结点开始,即2i+1处开始
while j<end:
if j+1<end and lst[j]<lst[j+1]:#若左子结点<右子结点,j指向右子结点
j += 1
if temp > lst[j]: # 若子节点<父节点,则不需要向下调整
break
else: # 若子节点>父节点
lst[i] = lst[j] # 父节点放入大值,子节点暂时不管
i,j = j,j*2+1 # 子节点晋升为”父“节点
lst[i] = temp
if tinput==[] or len(tinput)<k:
return []
tinput = heap_sort(tinput)
return tinput[:k]
堆排序(最小堆)(时间复杂度 O(nlogk) ,空间复杂度O(1))
class Solution:
def GetLeastNumbers_Solution(self, tinput, k):
# write code here
def heap_sort(lst,k):
end,res = len(lst),[]
for i in range(len(lst)//2-1,-1,-1):
siftup(lst,lst[i],i,end)
for i in range(end-1,end-1-k,-1):
temp,lst[i] = lst[i],lst[0]
res.append(lst[0])
siftup(lst,temp,0,i)
return res
def siftup(lst,temp,begin,end):
i,j = begin, begin*2+1
while j<end:
if j+1<end and lst[j]>lst[j+1]:
j += 1
if temp < lst[j]:
break
else:
lst[i] = lst[j]
i,j = j,j*2+1
lst[i] = temp
if tinput==[] or len(tinput)<k:
return []
res = heap_sort(tinput,k)
return res
方法六:直接选择排序
直接选择排序(时间复杂度O(n^2),空间复杂度O(1))
class Solution:
def GetLeastNumbers_Solution(self, tinput, k):
# write code here
def select_sort(lst):
for i in range(len(lst)):
f = -1 #f取列表最后一个数
for j in range(i,len(lst)):
if lst[j]<lst[f]:
f = j #取出当前未排序部分最小值所在索引
lst[i],lst[f]=lst[f],lst[i] #将第i个值替换为剩余未排序部分的最小值,以此类推
return lst
if tinput==[] or len(tinput)<k:
return []
tinput = select_sort(tinput)
return tinput[:k]
方法七:插入排序
插入排序(时间复杂度O(n^2),空间复杂度O(1))
class Solution:
def GetLeastNumbers_Solution(self, tinput, k):
# write code here
def insert_sort(lst):
for i in range(1,len(lst)):
temp = lst[i]
j=i
while j>0 and temp<lst[j-1]:
lst[j] = lst[j-1]
j -= 1
lst[j] = temp
return lst
if tinput==[] or len(tinput)<k:
return []
tinput = insert_sort(tinput)
return tinput[:k]
035-数组中的逆序对(归并排序)
在数组中的两个数字,如果前面一个数字大于后面的数字,则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。 即输出P%1000000007
归并排序(时间复杂度O(nlogn),空间复杂度O(n))
count = 0
class Solution:
def InversePairs(self, data):
# write code here
def merge_sort(data):
if len(data)<=1:
return data
mid = len(data)//2
right = merge_sort(data[mid:])
left = merge_sort(data[:mid])
return merge(right,left)
def merge(right,left):
global count
r,l,res = 0,0,[]
while r<len(right) and l<len(left):
if left[l]>right[r]:
res.append(left[l]) # 首位存入较大值
count += len(right) - r
l += 1
else:
res.append(right[r])
r += 1
res += right[r:]
res += left[l:]
return res
global count
merge_sort(data)
return count%1000000007