Python实现几种常见的排序算法

目录

1.冒泡排序

2.选择排序

3.直接插入排序

4.归并排序

5.快速排序

6.堆排序

7.几种排序算法比较

---

1.冒泡排序

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

2.选择排序

def selectSort(nums):
    for i in range(0,len(nums)-1):
        Min = i
        for j in range(i+1,len(nums)):#应该从i的后一位开始查找，因为i之前的数已经是排好序的
            if nums[Min]>nums[j]:
                Min = j
        if Min!=i:
            nums[i],nums[Min] = nums[Min],nums[i]
    return nums

3.直接插入排序

def insertSort(nums):
    length = len(nums)
    for i in range(1,length):
        temp = nums[i] #将当前元素保存起来，以此和前面的元素相比
        j = i-1
        while j>=0 and temp<nums[j]:
            nums[j+1] = nums[j]#将小于temp的元素依次向后移位
            j -= 1
        nums[j+1] = temp #最后nums[j]要不小于0，要不小于temp，所以在后面插入temp
    return  nums

4.归并排序

def merge(left, right):  # 对left和right数组进行合并
    i, j = 0, 0
    result = []
    while i < len(left) and j < len(right):
        if left[i] <= right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1
    result += left[i:]
    result += right[j:]
    return result


def mergeSort(lists):
    # 归并排序
    if len(lists) <= 1:
        return lists
    num = len(lists) // 2
    left = mergeSort(lists[:num])  # left是数组，存放着数据
    right = mergeSort(lists[num:])
    return merge(left, right)  # 把left数组和right数组合并

5.快速排序

def quicksort(nums,low,high):

    if low<high:
        index = partition(nums,low,high)
        quicksort(nums,low,index-1)#每一趟排序将数组里小于index的数放在左边，大于index的数放在右边，
                                    # 所以要index-1和index+1
        quicksort(nums,index+1,high)
    return nums
def partition(nums,low,high):
    pivot = nums[low]
    while low<high:
        while (low<high) and pivot<=nums[high]:
            high -=1
        nums[low] = nums[high]
        while low<high and pivot>=nums[low]:
            low+=1
        nums[high] = nums[low]
    nums[low] = pivot
    return low

6.堆排序

def heapify(arr,n,i):
    large = i #父节点的下标为i
    left_child = 2*i+1 #左孩子下标
    right_child = 2*i+2
    if left_child<n and arr[left_child]>arr[large]:#如果左孩子的值大于父节点的值，将下标互换
        large = left_child
    if right_child<n and arr[right_child]>arr[large]:
        large = right_child
    if large != i:#如果下标换了，将最大子节点和父节点的值互换
        arr[large],arr[i] = arr[i],arr[large]
        heapify(arr,n,large)#将最大值的那个子树继续递归

def build_heap(arr,n):
    last_child = n-1
    last_parent = (last_child-1)//2 #从最后一个叶子节点的父节点开始以此向上调整
    for i in range(last_parent,-1,-1):
        heapify(arr,n,i)

def heap_sort(arr,n):
    build_heap(arr,n)
    for i in range(n-1,-1,-1):
        arr[0],arr[i] = arr[i],arr[0] #每次将最大的节点（根节点）与最后一个节点交换，然后去掉最后一个节点，继续调整为最大堆
        heapify(arr,i,0)
    return arr
arr = [0, 8, 6, 2, 4, 9, 1, 4, 6]
n = len(arr)
res = heap_sort(arr,n)
print(res)

稳定排序的定义：定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变。就是“有序元素自始至终不改变相对位置”

7.几种排序算法比较

排序算法比较

	时间复杂度（平均情况）	空间复杂度	稳定性
冒泡排序			稳定
选择排序			不稳定
直接插入排序			稳定
归并排序			稳定
快速排序			不稳定
堆排序			不稳定

8、和初始顺序无关的排序算法：

比较次数与初始元素顺序无关的排序算法（即最好、最坏情况的时间复杂度一样）

选择排序 O (n^2)

堆排序 O (nlogn)

归并排序 O (nlogn)

基数排序 O (tn)