Python入门教程-Python常见的排序算法

最新推荐文章于 2024-10-13 00:00:12 发布

chusheng1840

最新推荐文章于 2024-10-13 00:00:12 发布

阅读量1k

点赞数 14

分类专栏： Python 教程文章标签：排序算法 python 算法

本文链接：https://blog.csdn.net/chusheng1840/article/details/142070468

版权

Python 教程专栏收录该内容

41 篇文章 1 订阅

订阅专栏

算法是解决问题的步骤和流程，编程中的算法能够高效地处理数据、进行排序和查找等操作。对于初学者来说，理解一些常见的基础算法是掌握编程的重要一步。本文将介绍几种常见的算法，并使用 Python 代码来实现它们。

在这里插入图片描述

一、如何实现冒泡排序

冒泡排序是一种基础的排序算法，它通过不断比较相邻元素，将较大的元素“冒泡”到列表的后面，最终使得整个列表按升序排列。它的核心思想是重复地从头到尾遍历列表，并在每次遍历中将未排序部分中的最大元素移到正确的位置。

1. 冒泡排序的步骤

从列表的第一个元素开始，逐个比较相邻的两个元素。
如果前一个元素大于后一个元素，交换它们的位置。
每次遍历都会将未排序部分中最大的元素移到最后。
重复这个过程，直到没有需要交换的元素为止。

2. 冒泡排序的 Python 实现

下面是使用 Python 实现冒泡排序的代码：

python


复制代码
def bubble_sort(arr):
    n = len(arr)
    # 外层循环控制需要遍历的次数
    for i in range(n):
        # 内层循环控制每次遍历中需要比较的元素
        for j in range(0, n - i - 1):
            # 如果前一个元素大于后一个元素，交换它们
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]

# 测试冒泡排序
arr = [64, 34, 25, 12, 22, 11, 90]
bubble_sort(arr)
print("排序后的数组：", arr)

3. 冒泡排序的复杂度

冒泡排序的时间复杂度为 O(n²)，因为每次遍历都需要进行 n-1 次比较，最坏情况下需要进行 n 次遍历。尽管冒泡排序易于理解，但它的效率较低，通常在实际应用中更倾向于使用更高效的排序算法。

二、如何实现快速排序

快速排序是一种高效的排序算法，采用分治法将列表分成较小的子列表进行排序。它的核心思想是选取一个“基准”元素，将列表中的其他元素按大小分为两部分，一部分比基准小，另一部分比基准大，然后递归地对两部分进行排序。

1. 快速排序的步骤

选择一个基准元素，通常选择第一个或最后一个元素。
将列表分为两个子列表：所有比基准小的元素放在基准左边，所有比基准大的元素放在右边。
递归地对左子列表和右子列表进行快速排序，直到每个子列表只有一个元素或为空。

2. 快速排序的 Python 实现

下面是快速排序的 Python 实现：

python


复制代码
def quick_sort(arr):
    # 如果数组为空或只有一个元素，则直接返回
    if len(arr) <= 1:
        return arr
    else:
        # 选择基准元素（这里选择第一个元素）
        pivot = arr[0]
        # 小于基准的元素放在左边，大于基准的元素放在右边
        less = [x for x in arr[1:] if x <= pivot]
        greater = [x for x in arr[1:] if x > pivot]
        # 递归地对左右子列表进行排序
        return quick_sort(less) + [pivot] + quick_sort(greater)

# 测试快速排序
arr = [64, 34, 25, 12, 22, 11, 90]
sorted_arr = quick_sort(arr)
print("排序后的数组：", sorted_arr)

3. 快速排序的复杂度

快速排序的平均时间复杂度为 O(n log n)，最坏情况下时间复杂度为 O(n²)，当基准元素选择不当时（例如每次选择的基准都是最小或最大元素）。尽管最坏情况的时间复杂度较高，但在实际应用中，快速排序通常表现非常高效。

三、如何实现二分查找

二分查找是一种用于在有序列表中查找元素的高效算法。它通过反复将查找范围减半，快速缩小目标元素的可能位置。与线性查找（逐个遍历）相比，二分查找的效率要高得多。

1. 二分查找的步骤

确定列表的中间元素。
如果目标元素等于中间元素，查找成功。
如果目标元素小于中间元素，则继续在左半部分查找。
如果目标元素大于中间元素，则继续在右半部分查找。
重复这个过程，直到找到目标元素或查找范围为空。

2. 二分查找的 Python 实现

下面是使用 Python 实现二分查找的代码：

python


复制代码
def binary_search(arr, target):
    left, right = 0, len(arr) - 1
    while left <= right:
        mid = (left + right) // 2
        # 检查中间元素
        if arr[mid] == target:
            return mid
        # 如果目标元素在左半部分
        elif arr[mid] > target:
            right = mid - 1
        # 如果目标元素在右半部分
        else:
            left = mid + 1
    return -1  # 如果找不到目标元素

# 测试二分查找
arr = [11, 12, 22, 25, 34, 64, 90]
target = 25
result = binary_search(arr, target)
if result != -1:
    print(f"元素 {target} 在数组中的索引为 {result}")
else:
    print(f"元素 {target} 不在数组中")

3. 二分查找的复杂度

二分查找的时间复杂度为 O(log n)，因为每次查找都将范围减半。它只能在有序的数组中使用，如果数组无序，需要先对其排序。

四、如何找到列表中的最大值和最小值

在处理数据时，找到列表中的最大值和最小值是常见的任务。Python 提供了简单的方法来实现这一功能。我们可以使用内置的 max() 和 min() 函数，或者自己编写算法来查找。

1. 使用内置函数查找最大值和最小值

Python 的 max() 和 min() 函数可以直接用于查找列表中的最大值和最小值：

python


复制代码
arr = [64, 34, 25, 12, 22, 11, 90]
max_value = max(arr)
min_value = min(arr)
print(f"列表中的最大值是 {max_value}, 最小值是 {min_value}")

2. 手动查找最大值和最小值

我们也可以通过遍历列表，逐个比较元素的大小，手动查找最大值和最小值。以下是实现代码：

python


复制代码
def find_max(arr):
    max_value = arr[0]
    for num in arr:
        if num > max_value:
            max_value = num
    return max_value

def find_min(arr):
    min_value = arr[0]
    for num in arr:
        if num < min_value:
            min_value = num
    return min_value

# 测试最大值和最小值查找
arr = [64, 34, 25, 12, 22, 11, 90]
print(f"最大值是 {find_max(arr)}")
print(f"最小值是 {find_min(arr)}")