python实现交换排序

liulanba

已于 2024-07-17 18:08:14 修改

阅读量9k

点赞数 7

分类专栏：数据结构文章标签：数据结构快速排序

于 2021-03-23 19:48:56 首次发布

本文链接：https://blog.csdn.net/liulanba/article/details/113993892

版权

数据结构专栏收录该内容

31 篇文章 15 订阅

订阅专栏

本文介绍了两种常见的排序算法：冒泡排序和快速排序。冒泡排序通过相邻元素的比较和交换，逐步将最小元素移到序列末尾，时间复杂度为O(n²)。快速排序采用分治策略，选取基准元素并将其与其他元素对比，将序列分为两部分，然后递归排序，平均时间复杂度为O(nlog2N)，但最坏情况下为O(n²)。

摘要由CSDN通过智能技术生成

排序算法：
python实现基数排序
 python实现归并排序
 python实现交换排序
 python实现选择排序
 python实现插入排序
 python实现桶排序

冒泡排序
基本思想：假设待排序表长为n，从后往前或者从前往后两两比较相邻元素的值，若为逆序则交换它们，直到序列比较完。
每趟冒泡的结果是把待排序序列中的最小元素放到了序列的最终位置，这样最多n-1趟就可以把所有元素排好序。
在这里插入图片描述

def BubbleSort(A):
    le=len(A) #获取元素数目
    for i in range(le-1):#遍历le-1次
        for j in range(i,le):#每一趟冒泡，待排序元素数目都会-1
            if A[j]>A[j-1]:#逆序则交换
                A[j-1],A[j]=A[j],A[j-1]
        print(A)

tes=[23,34,243,1,28,7,56]
BubbleSort(tes)

输出为：

[34, 243, 23, 28, 7, 56, 1]
[243, 34, 28, 23, 56, 7, 1]
[243, 34, 28, 56, 23, 7, 1]
[243, 34, 56, 28, 23, 7, 1]
[243, 34, 56, 28, 23, 7, 1]
[243, 34, 56, 28, 23, 7, 1]

空间效率：使用了常数个辅助单元，因而空间复杂度为O(1)
时间效率：O(n²)
它是一种稳定的排序算法。

快速排序
基本思想：基于分治法，在待排序表L[1…n]中任取一个元素pivot作为基准，通过一趟排序将排序表划分为独立的两部分L[1…k-1]和L[k+1…n].使得L[1…k-1]中所有元素<privot，L[k+1…n]中所有元素>=privot,privot放在它的最终位置L[k]，这个过程为一趟快速排序。
然后分别递归地对两个子表重复上述过程，直到每部分只有一个元素或者为空为止，即所有元素都放在了其最终位置。
在这里插入图片描述

def quick_sort(alist, start, end):
    if start >= end:
        return
    low = start
    high = end
    mid = alist[low]

    while low < high:
        while low < high and mid < alist[high]:
            # 从右边开始找，如果元素小于基准，则把这个元素放到左边
            high -= 1
        alist[low] = alist[high]

        while low < high and mid >= alist[low]:
            # 从左边开始找，如果元素大于基准，则把元素放到右边
            low += 1
        alist[high] = alist[low]

    # 循环退出，low==high，把基准元素放到这个位置
    alist[low] = mid

    # 递归调用，重新排列左边的和右边的序列
    quick_sort(alist, start, low - 1)
    quick_sort(alist, low + 1, end)


# 示例使用
my_list = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
quick_sort(my_list, 0, len(my_list) - 1)
print(my_list)
# [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]

1.quick_sort 函数接受三个参数：alist（待排序的列表）、start（起始索引）和 end（结束索引）。
2.首先，函数进行一个基本的终止条件检查。如果 start >= end，表示列表只有一个元素或者没有元素，无需排序，直接返回。
3.然后，函数定义了三个变量：low（指向当前的起始索引）、high（指向当前的结束索引）和 mid（基准元素，取列表中的第一个元素 alist[low]）。
4.接下来是一个 while 循环，循环条件是 low < high。在每次循环中，通过两个内部的 while 循环来找到比基准元素小和大的元素，并将它们放到正确的位置。
5.第一个内部的 while 循环从列表的右侧开始（high 索引），如果当前元素大于基准元素，则将 high 索引向左移动一位。这样找到的元素小于基准元素，将它放到 low 的位置，并将 high 向左移动。
6.第二个内部的 while 循环从列表的左侧开始（low 索引），如果当前元素小于基准元素，则将 low 索引向右移动一位。这样找到的元素大于基准元素，将它放到 high 的位置，并将 low 向右移动。
7.当外部的 while 循环结束时，low 和 high 相等，将基准元素放到这个位置。
8.接下来，通过递归调用 quick_sort 函数，对基准元素的左侧和右侧子序列进行排序。左侧子序列的起始索引是 start，结束索引是 low-1；右侧子序列的起始索引是 low+1，结束索引是 end。
9.当递归调用结束时，整个列表将被原地排序。

快速排序算法的核心思想是通过选择一个基准元素，将列表分割成两个子序列，其中一个子序列的元素都小于基准元素，另一个子序列的元素都大于基准元素。然后对这两个子序列分别进行递归排序，最终实现整个列表的排序。

空间效率：由于排序算法是递归的，需要借助一个递归工作栈来保存每一层递归调用的必要信息，其容量应与递归调用的最大深度一致。空间复杂度最坏情况为O(n)，平均情况为O(log2 N)
时间效率：最坏为O(n²)；最好为O(nlog2 N)
它是一种不稳定的排序算法。

容易理解的解法：

def quick_sort(alist):
    if len(alist) < 2:
        return alist
    # 分别保存基准值左右两侧的元素
    left, right = [], []
    provit = alist[0]
    for i in range(1, len(alist)):
        if alist[i] < provit:
            left.append(alist[i])
        else:
            right.append(alist[i])
    left = quick_sort(left)
    right = quick_sort(right)
    # 拼接完整的列表，left + [provit]+right
    if left:
        cur = left + [provit]
    else:
        cur = [provit]
    if right:
        cur += right
    return cur


list_ls = [45, 23, 1, 43, 21, 12, 34, 21]
print(quick_sort(list_ls))
# [1, 12, 21, 21, 23, 34, 43, 45]