面试常问排序算法实现Python

常见排序算法实现Python

​ 摘自数据结构书上

冒泡排序
时间复杂度O(N^2)，额外空间复杂度O(1)，实现可以做到稳定性

def bubblesort(nums):
    for i in range(len(nums)):
        for j in range(0,len(nums)-i-1):
            if nums[j]>nums[j+1]:
                swap(nums,j,j+1)
    return nums
def swap(nums,x,y):
    nums[x],nums[y]=nums[y],nums[x]

选择排序
时间复杂度O(N^2)，额外空间复杂度O(1)，实现可以做到稳定性

def selectsort(nums):
    for i in range(len(nums)):
        for j in range(i+1,len(nums)):
            if nums[i]>nums[j]:
                swap(nums,i,j)
    return nums

插入排序
时间复杂度O(N^2)，额外空间复杂度O(1)，实现可以做到稳定性

def insertsort(nums):
    for i in range(len(nums)-1):
        for j in range(i+1,0,-1):
            if nums[j]<nums[j-1]:
                swap(nums,j,j-1)
            else:
                break
    return nums

随机快速排序
时间复杂度O(N*logN)，额外空间复杂度O(logN)，常规实现做不到稳定性。

def quicksort(nums):
    if len(nums)<2:
        return
    quicksorthelp(nums,0,len(nums)-1)
    return nums
def quicksorthelp(nums,l,r):
    if l<r:
        p = partition(nums,l,r)
        quicksorthelp(nums,l,p[0]-1)
        quicksorthelp(nums,p[1]+1,r)
def partition(nums,l,r):
    small = l-1
    big = r
    while l<big:
        if nums[l]<nums[r]:
            small += 1
            swap(nums,small,l)
            l += 1
        elif nums[l]>nums[r]:
            big -=1
            swap(nums,big,l)
        else:
            l += 1
    swap(nums,big,r)
    return [small+1,big]

归并排序
时间复杂度O(N*logN)，额外空间复杂度O(N)，实现可以做到稳定性

​ 归并操作适合用于处理存储在外存的大量数据。外存比较适合顺序处理，但不适合随机访问，归并操作过程中对数据的访问具有局部性，适合外存数据交换特点，特别适合处理一组记录形成的数据块。

def mergesort(nums):
    #1.拆开
    mid = len(nums)//2
    if mid<1:
        return nums
    #2.归并 Sort_Merge
    left = mergesort(nums[0:mid])
    right = mergesort(nums[mid:])
    res = []
    indexl,indexr=0,0
    while indexl <len(left) and indexr<len(right):
        if left[indexl]>right[indexr]:
            res.append(right[indexr])
            indexr += 1
        else:
            res.append(left[indexl])
            indexl += 1
    if indexl == len(left):
        res += right[indexr:]
    else:
        res += left[indexl:]
    return res

堆排序

时间复杂度O(N*logN)，额外空间复杂度O(1)，实现不能做到稳定性
关键步骤：heapInsert, heapify，堆的扩大和缩小操作

​ 堆排序也是一种选择排序。像是简单选择排序的优化，借助于二叉树这种数据结构，每趟从待排序的记录中选出关键字最小的记录，顺序放在已排序的记录序列末尾，直到全部排序结束为止。跟简单选择排序不同的是堆排序的待排序列是利用二叉树这种数据结构存储的。相比之下是更优化的。

注意：
1，堆排序中，建立堆的操作O(N)
2，堆排序的核心数据结构：堆，也可以说是优先级队列

堆排上一个地址（这老哥讲得很棒）：https://blog.csdn.net/u010452388/article/details/81283998
摘自数据结构书上