【剑指offer】具体算法类--排序--2题「fini」

概念理解

数据结构与算法——排序问题
排序

题目

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