常见排序算法(冒泡排序/快速排序/插入排序/选择排序)

最新推荐文章于 2022-11-04 21:00:00 发布

原创最新推荐文章于 2022-11-04 21:00:00 发布 · 392 阅读

2 ·

CC 4.0 BY-SA版权

文章标签：

#python #算法 #数据结构 #排序算法

算法专栏收录该内容

1 篇文章

订阅专栏

本文详细介绍了五种排序算法（冒泡排序、快速排序、插入排序、选择排序）和二分查找算法的原理、动图演示及代码实现。通过直观的动图展示和清晰的代码解释，帮助读者理解各种算法的工作过程和特点。

文章目录

冒泡排序(Bubble Sort)

原理

比较相邻的元素，如果前一个元素大于后一个元素，则交换位置
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样最大的数会跑到最后
针对所有的元素重复以上的步骤，除了最后一个
重复步骤1-3，直到排序完成

时间复杂度 $O(n^2)$ ，空间复杂度 $O (1)$ ，稳定算法

稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面

不稳定：如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面

动图演示

在这里插入图片描述

代码实现

def bubble_sort(arr):
    length = len(arr)
    for i in range(length -1):
        # 如果一次循环完了之后没有进行交换，说明arr本身就有序，后续循环无需再做
        flag = False
        for j in range(length - i - 1):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
                flag = True
        if not flag:
            break
    return arr

快速排序(Quick Sort)

原理

利用递归的思想，一开始选择一个基准值，大于这个基准值的数存放到一个列表中，其他值存放到另一个列表中，然后这俩个列表进行递归操作

时间复杂度是 $O(nlog_{2}n)$ ，空间复杂度也是 $O(nlog_{2}n)$ ，不稳定算法

动图演示

在这里插入图片描述

代码实现

def quick_sort(arr):
    length = len(arr)
    if length <= 1:
        return arr
    else:
        pivot = arr.pop()
        greater, lesser = [], []
        for element in arr:
            if element > pivot:
                greater.append(element)
            else:
                lesser.append(element)
        return quick_sort(lesser) + [pivot] + quick_sort(greater)

插入排序(Insertion Sort)

原理

将第一个元素认为已经排号序
依次从剩余序列中取出待排序的元素，和已经排序的元素序列从后向前进行比较
如果已排序元素大于待排序元素，则将已排序元素移到下一位置
重复步骤3，直到找到已排序的元素小于或者等于未排序元素的位置，将待排序元素插入到该位置后

时间复杂度 $O(n^2)$ ，空间复杂度 $O (1)$ ，稳定算法

动图演示

在这里插入图片描述

代码实现

def insertion_sort(arr):
    for loop_index in range(1, len(arr)):
        insertion_index = loop_index
        while insertion_index > 0 and arr[insertion_index - 1] > arr[insertion_index]:
            arr[insertion_index - 1], arr[insertion_index] = arr[insertion_index], arr[insertion_index - 1]
            insertion_index -= 1
    return arr

选择排序(Selection Sort)

原理

首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕

时间复杂度 $O(n^2)$ ，空间复杂度 $O (1)$ ，不稳定算法

动图演示

在这里插入图片描述

代码实现

def select_sort(arr):
    length = len(arr)
    for i in range(length - 1):
        least = i
        for j in range(i + 1, length):
            if arr[j] < arr[least]:
                least = j
        arr[least], arr[i] = arr[i], arr[least]
    return arr

二分查找(Binary Search)

原理

将n个元素分成大致相等的两部分，取a[n/2]与x做比较，如果x=a[n/2]，则找到x，算法中止；如果x<a[n/2]，则只要在数组a的左半部分继续搜索x，如果x>a[n/2]，则只要在数组a的右半部搜索x

时间复杂度： $O(log_{2}n)$

代码实现

def binary_search(arr, num):
    left, right = 0, len(arr) - 1
    while left < right:
        mid = (left + right) // 2
        if arr[mid] == num:
            return mid
        elif arr[mid] > num:
            right = mid - 1
        else:
            left = mid + 1
    else:
        return None

注意：数组a必须是有序的