Python 实现十大经典排序算法-LeetCode案例版

最新推荐文章于 2024-05-18 09:49:11 发布
置顶 最新推荐文章于 2024-05-18 09:49:11 发布
阅读量1.4k 收藏 21
点赞数 8
分类专栏： 数据结构与算法分析 文章标签： 算法 数据结构 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44222014/article/details/105219751
版权

数据结构与算法-Python语言案例实现

十大经典排序算法

一、 引言

授人以鱼不如授人以渔~

实践是检验真理的唯一标准~

算法与数据结构实战-LeetCode题解

1.问题需求

排序数组

给你一个整数数组 nums，请你将该数组升序排列。

或对一个无序数组，根据某个关键字排序。

示例 1：

输入：nums = [5,2,3,1]
输出：[1,2,3,5]

示例 2：

输入：nums = [5,1,1,2,0,0]
输出：[0,0,1,1,2,5]

Python语言实现

2.方法分类

排序算法划分方法有：稳定性，内外排序，时空复杂度

  • 按照稳定性划分：稳定排序，如果a原本在b前面，而a=b，排序之后a仍然在b的前面；而不稳定可能出现在b之后
  • 按照内外排序划分：内排序，所有排序操作都在内存中完成；外排序 ：由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行
  • 按照时空复杂度划分：时间复杂度是指运行时间，空间复杂度运行完一个程序所需内存的大小

二、常见排序方法

1. 选择排序（Selection Sort）

算法描述：

在这里插入图片描述

这应该最符合人类思维的排序方法，工作原理，首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

稳定性：稳定；内排序

def selection_sort(nums):
    n = len(nums)
    for i in range(n):
        for j in range(i, n):
            if nums[i] > nums[j]:
                nums[i], nums[j] = nums[j], nums[i]
    return nums

# leetcode形式
class Solution:
    def sortArray(self, nums: List[int]) -> List[int]:
        # selection sort 
        n = len(nums)
        for i in range(n):
            for j in range(i,n):
                if nums[i] > nums[j]:
                    nums[i],nums[j] = nums[j],nums[i]
                    #print(nums)
        return nums

算法分析：
**在这里插入图片描述

2. 冒泡排序（Bubble Sort）

算法描述：

冒泡排序时针对相邻元素之间的比较，可以将大的数慢慢“沉底”(数组尾部)
在这里插入图片描述
在这里插入图片描述

def bubble_sort(nums):
    n = len(nums)
    # 进行多次循环
    for c in range(n):
        for i in range(1, n - c):
            if nums[i - 1] > nums[i]:
                nums[i - 1], nums[i] = nums[i], nums[i - 1]
    return nums

算法分析：

稳定排序，内排序，时间复杂度：
在这里插入图片描述

3. 插入排序（Insertion Sort）

算法描述：

插入排序是前面已排序数组找到插入的位置
在这里插入图片描述
在这里插入图片描述

def insertion_sort(nums):
    n = len(nums)
    for i in range(1, n):
        while i > 0 and nums[i - 1] > nums[i]:
            nums[i - 1], nums[i] = nums[i], nums[i - 1]
            i -= 1
    return nums

# LeetCode形式
class Solution:
    def sortArray(self, nums: List[int]) -> List[int]:
        # insert sort 
        n = len(nums)
        for i in range(1,n):
            while i > 0 and nums[i-1] > nums[i]:
                nums[i-1],nums[i] = nums[i],nums[i-1]
                i -= 1
        return nums

算法分析：

稳定排序，内排序，时间复杂度：
在这里插入图片描述

4. 希尔排序（Shell Sort）

插入排序进阶版

算法描述：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

def shell_sort(nums):
    n = len(nums)
    gap = n // 2
    while gap:
        for i in range(gap, n):
            while i - gap >= 0 and nums[i - gap] > nums[i]:
                nums[i - gap], nums[i] = nums[i], nums[i - gap]
                i -= gap
        gap //= 2
    return nums

算法分析：

非稳定排序，内排序；

希尔排序的时间复杂度和增量序列是相关的。
在这里插入图片描述

5. 归并排序（Merge Sort）

归并排序，采用是分治法，先将数组分成子序列，让子序列有序，再将子序列间有序，合并成有序数组。

算法描述：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

def merge_sort(nums):
    if len(nums) <= 1:
        return nums
    mid = len(nums) // 2
    # 分
    left = merge_sort(nums[:mid])
    right = merge_sort(nums[mid:])
    # 合并
    return merge(left, right)


def merge(left, right):
    res = []
    i = 0
    j = 0
    while i < len(left) and j < len(right):
        if left[i] <= right[j]:
            res.append(left[i])
            i += 1
        else:
            res.append(right[j])
            j += 1
    res += left[i:]
    res += right[j:]
    return res

# LeetCode
class Solution:
    def sortArray(self, nums: List[int]) -> List[int]:
        res = []
        mid = len(nums) //2
        left, right = nums[:mid],nums[mid:]
        if len(left) > 1: left = self.sortArray(left)
        if len(right) > 1: right = self.sortArray(right)

        while left and right:
            if left[-1] >= right[-1]:
                res.append(left.pop())
            else:
                res.append(right.pop())
        res.reverse()
        return (left or right) + res  # 将剩余left或right中的数和res合并

算法分析：

稳定排序，外排序（占用额外内存），时间复杂度：O(nlogn)。

6. 快速排序（Quick Sort）

快速排序是选取一个“哨兵”(pivot)，将小于pivot放在左边，把大于pivot放在右边，分割成两部分，并且可以固定pivot在数组的位置，在对左右两部分继续进行排序。

快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：

  • 步骤1：从数列中挑出一个元素，称为 “基准”（pivot ）；
  • 步骤2：重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
  • 步骤3：递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
    在这里插入图片描述
    在这里插入图片描述
def quick_sort(nums):
    n = len(nums)

    def quick(left, right):
        if left >= right:
            return nums
        pivot = left
        i = left
        j = right
        while i < j:
            while i < j and nums[j] > nums[pivot]:
                j -= 1
            while i < j and nums[i] <= nums[pivot]:
                i += 1
            nums[i], nums[j] = nums[j], nums[i]
        nums[pivot], nums[j] = nums[j], nums[pivot]
        quick(left, j - 1)
        quick(j + 1, right)
        return nums

    return quick(0, n - 1)

# LeetCode
class Solution:
    def sortArray(self, nums: List[int]) -> List[int]:
        n = len(nums)
        first = 0
        last = n - 1
        self.quickSorthepler(nums,first,last)
        return nums

    def partition(self, alist, first, last):
        left = first
        right = last
        pivot = alist[first]
        while left < right:
            while left < right and alist[right] >= pivot:
                right -= 1
            alist[left] = alist[right]
            while left < right and alist[left] <= pivot:
                left += 1
            alist[right] = alist[left]
        alist[left] = pivot
        return left
    
    def quickSorthepler(self, alist, first,last):
        if first < last:
            pointmark = self.partition(alist,first,last)
            self.quickSorthepler(alist,first,pointmark-1)
            self.quickSorthepler(alist, pointmark + 1, last)

算法分析：

不稳定排序，内排序，时间复杂度度O(nlogn)O(nlogn)。

7. 堆排序（Heap Sort）

堆排序是利用堆这个数据结构设计的排序算法。

算法描述：

  • 建堆，从底向上调整堆，使得父亲节点比孩子节点值大，构成大顶堆；
  • 交换堆顶和最后一个元素，重新调整堆。

调整堆方法写了递归和迭代，都很好理解！

def heap_sort(nums):
    # 调整堆
    # 迭代写法
    def adjust_heap(nums, startpos, endpos):
        newitem = nums[startpos]
        pos = startpos
        childpos = pos * 2 + 1
        while childpos < endpos:
            rightpos = childpos + 1
            if rightpos < endpos and nums[rightpos] >= nums[childpos]:
                childpos = rightpos
            if newitem < nums[childpos]:
                nums[pos] = nums[childpos]
                pos = childpos
                childpos = pos * 2 + 1
            else:
                break
        nums[pos] = newitem
    
    # 递归写法
    def adjust_heap(nums, startpos, endpos):
        pos = startpos
        chilidpos = pos * 2 + 1
        if chilidpos < endpos:
            rightpos = chilidpos + 1
            if rightpos < endpos and nums[rightpos] > nums[chilidpos]:
                chilidpos = rightpos
            if nums[chilidpos] > nums[pos]:
                nums[pos], nums[chilidpos] = nums[chilidpos], nums[pos]
                adjust_heap(nums, pos, endpos)

    n = len(nums)
    # 建堆
    for i in reversed(range(n // 2)):
        adjust_heap(nums, i, n)
    # 调整堆
    for i in range(n - 1, -1, -1):
        nums[0], nums[i] = nums[i], nums[0]
        adjust_heap(nums, 0, i)
    return nums

#  LeetCode
class Solution:
    def sortArray(self, nums: List[int]) -> List[int]:

        n = len(nums)
        def build_heap(nums, start, end):  # 建堆的同时调整堆
            newitem = nums[start]
            cur = start
            leftpos = 2 * cur + 1
            while leftpos < end:
                rightpos = leftpos + 1
                if rightpos < end and nums[rightpos] >= nums[leftpos]:
                    leftpos = rightpos
                if newitem < nums[leftpos]:
                    nums[cur] = nums[leftpos]
                    cur = leftpos
                    leftpos = 2 * cur + 1
                else:
                    break
            nums[cur] = newitem
        for i in reversed(range(n//2)):  # 建堆+调整
            build_heap(nums, i, n)
        for i in range(n-1,-1,-1):
            nums[0],nums[i] = nums[i],nums[0]  #排序
            build_heap(nums,0,i)  #调整
        return nums

# LeetCode
# 堆排序 递归写法
class Solution:
    def sortArray(self, nums: List[int]) -> List[int]:
        n = len(nums)
        self.build_heap(nums,n)
        print(nums)
        
        for i in range(n-1,-1,-1):
            nums[0],nums[i] = nums[i],nums[0]  #排序
            self.heapify(nums,0,i)  #调整
        return nums
    # 递归写法
    def heapify(self, nums, startpos, endpos):
        if startpos >= endpos: return 
        c1 = startpos * 2 + 1
        c2 = startpos * 2 + 2
        max_index = startpos
        if c1 < endpos and nums[c1] > nums[max_index]:
            max_index = c1
        if c2 < endpos and nums[c2] > nums[max_index]:
            max_index = c2
        if max_index != startpos:
            nums[startpos], nums[max_index] = nums[max_index], nums[startpos]
            self.heapify(nums, max_index, endpos)
    def build_heap(self, nums, n):
        last_node = n-1
        parent = (last_node-1) // 2
        for i in range(parent, -1,-1):
            self.heapify(nums,i,n)

算法分析：

不稳定排序，内排序，时间复杂度为O(nlogn)O(nlogn)。

8. 计数排序（Counting Sort）

计数排序是典型的空间换时间算法，开辟额外数据空间存储用索引号记录数组的值和数组值个数

算法描述：

  1. 找出待排序的数组的最大值和最小值
  2. 统计数组值的个数
  3. 反向填充目标数组
    在这里插入图片描述
def counting_sort(nums):
    if not nums: return []
    n = len(nums)
    _min = min(nums)
    _max = max(nums)
    tmp_arr = [0] * (_max - _min + 1)
    for num in nums:
        tmp_arr[num - _min] += 1
    j = 0
    for i in range(n):
        while tmp_arr[j] == 0:
            j += 1
        nums[i] = j + _min
        tmp_arr[j] -= 1
    return nums

# LeetCode
class Solution:
    def sortArray(self, nums: List[int]) -> List[int]:
        from collections import defaultdict

        def counter_sort(nums,key=lambda x:x):
            B,C = [], defaultdict(list)
            for x in nums:
                C[key(x)].append(x)  #  {1:1,2:2,......}
            for k in range(min(C), max(C) + 1):
                B.extend(C[k])
            return B
        res = counter_sort(nums)
        return res

算法分析：

稳定排序，外排序，时间复杂度O(n + k)，但是对于数据范围很大的数组，需要大量时间和内存。

9. 桶排序（Bucket Sort）

桶排序是计数排序的升级版，原理是：输入数据服从均匀分布的，将数据分到有限数量的桶里，每个桶再分别排序（有可能再使用别的算法或是以递归方式继续使用桶排序，此文编码采用递归方式）

算法描述：

  1. 人为设置一个桶的BucketSize，作为每个桶放置多少个不同数值（意思就是BucketSize = 5，可以放5个不同数字比如[1, 2, 3,4,5]也可以放 100000个3，只是表示该桶能存几个不同的数值）
  2. 遍历待排序数据，并且把数据一个一个放到对应的桶里去
  3. 对每个不是桶进行排序，可以使用其他排序方法，也递归排序
  4. 不是空的桶里数据拼接起来
    在这里插入图片描述
def bucket_sort(nums, bucketSize):
    if len(nums) < 2:
        return nums
    _min = min(nums)
    _max = max(nums)
    # 需要桶个数
    bucketNum = (_max - _min) // bucketSize + 1
    buckets = [[] for _ in range(bucketNum)]
    for num in nums:
        # 放入相应的桶中
        buckets[(num - _min) // bucketSize].append(num)
    res = []

    for bucket in buckets:
        if not bucket: continue
        if bucketSize == 1:
            res.extend(bucket)
        else:
            # 当都装在一个桶里,说明桶容量大了
            if bucketNum == 1:
                bucketSize -= 1
            res.extend(bucket_sort(bucket, bucketSize))
    return res

算法分析：

稳定排序，外排序，时间复杂度O(n + k)，k为桶的个数。

10. 基数排序（Radix Sort）

基数排序是对数字每一位进行排序，从最低位开始排序

算法描述：

  1. 找到数组最大值，得最大位数；
  2. 从最低位开始取每个位组成radix数组；
  3. 对radix进行计数排序（计数排序适用于小范围的特点）。
    在这里插入图片描述
def Radix_sort(nums):
    if not nums: return []
    _max = max(nums)
    # 最大位数
    maxDigit = len(str(_max))
    bucketList = [[] for _ in range(10)]
    # 从低位开始排序
    div, mod = 1, 10
    for i in range(maxDigit):
        for num in nums:
            bucketList[num % mod // div].append(num)
        div *= 10
        mod *= 10
        idx = 0
        for j in range(10):
            for item in bucketList[j]:
                nums[idx] = item
                idx += 1
            bucketList[j] = []
    return nums

算法分析：

稳定排序，外排序，时间复杂度 posCount * (n + n)，其中 posCount 为数组中最大元素的最高位数；简化下得：O( k *n ) ；其中k为常数，n为元素个数。

三、算法总结

在这里插入图片描述
图片名词解释：

n: 数据规模
k: “桶”的个数
In-place: 占用常数内存，不占用额外内存
Out-place: 占用额外内存

码字不易，看过的同学麻烦点个赞~

关注或留言，看客官心情咯~

欢迎交流，共同进步~

您的支持，是我不断创作的最大动力~

欢迎点赞，关注，留言交流~

深度学习，乐此不疲~

个人微信公众号，欢迎关注~
在这里插入图片描述

AI研习图书馆
关注
  • 8
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
十大经典排序算法的python实现
Alannah的个人学习记录
04-12 209
目录一 排序算法分类及时间复杂度二 算法讲解及python代码实现1.冒泡排序 Bubble Sort2.选择排序 Selection Sort3.插入排序 Insertion Sort4.快速排序 Quick Sort5.希尔排序 Shell Sort6.归并排序 Merge Sort7.堆排序 Heap Sort8.计数排序 Counting Sort9.桶排序 Bucket Sort10.基数排序 Radix Sort 贴一篇讲解贴，包含排序算法的动态展示图和算法讲解，本文将从该博客摘录重点并进行部分
python的十大经典排序算法
胖大xian
03-05 4005
十大经典排序算法 该文章参照菜鸟教程，也有自己的部分理解。 一、简介 排序算法是《数据结构与算法》中最基本的算法之一。 排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。用一张图概括： 关于时间复杂度： 平方阶 (O(n2)) 排序 各类简单排序： 直接插入、直接选择和冒泡排序。 线性对
十大排序算法Python实现-LeetCode题解（全面精简附解释）
算法之美
03-31 489
十大排序算法Python实现-LeetCode题解（全面精简附解释）
【LeetCode】快速排序（python版）
cxy885588的博客
07-05 474
快速排序： 以列表中的任意一个数为基准（一般选取第一个数），将列表分为左右（前后）两个子列表，左边子列表的数要比基数小，右边的子列表要比基数大，然后继续把左边子列表和右边子列表按同样的方法继续分解、比较，一直分到分无可分位置，然后按照左边子列表比基数小+基数+右边子列表（比基数大）的方式连接起来，最后得到一个有序的数列 import random import timeit def randomList(n): iList = [] for i in range(n): i
探索Python数据结构与算法之美：《Python数据结构与算法思维》开源实现
最新发布
gitblog_00042的博客
05-18 344
探索Python数据结构与算法之美：《Python数据结构与算法思维》开源实现 项目地址:https://gitcode.com/careermonk/data-structures-and-algorithmic-thinking-with-python 1、项目介绍 在软件开发的世界中，数据结构和算法是构建高效解决方案的基石。《Python数据结构与算法思维》是一本旨在帮助开发者深化对这两方面...
【力扣Leetcode】排序专题（Python刷题）：插入、选择、冒泡、快速、归并、堆排
m0_52023710的博客
05-12 1504
leetcode刷题，python实现排序，持续更新…… 基本排序模板： 复杂度O(n^2)：插入排序，选择排序，冒泡排序 复杂度O(nlogn)：快速排序，归并排序，堆排序 其它：希尔排序，计数排序，桶排序，基数排序
【leetcode】快速排序（快排）(python)
Rudy的博客
07-11 389
【代码】【leetcode】快速排序（快排）(python)
【LeetCode算法题】各类排序算法的Python实现
qq_53271322的博客
01-17 640
对于直接插入排序、折半插入排序、选择排序、冒泡排序、归并排序，快速排序、堆排序算法的Python实现进行记录。
Python算法题源代码-LeetCode(力扣)-搜索旋转排序数组
03-12
力扣热题Python源代码 题目33. 搜索旋转排序数组 整数数组 nums 按升序排列，数组中的值 互不相同 。 在传递给函数之前，nums 在预先未知的某个下标 k（0 ）上进行了 旋转，使数组变为 [nums[k], nums[k+1], ..., ...
Python算法题源代码-LeetCode(力扣)-寻找旋转排序数组中的最小值
03-13
力扣热题Python源代码 题目153. 寻找旋转排序数组中的最小值 提示 已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次 旋转 后，得到输入数组。例如，原数组 nums = [0,1,2,4,5,6,7] 在变化后可能得到： ...
青蛙过河leetcode-LeetCode:python3实现经典算法题
07-06
python3实现经典算法题 记录一些之前在leetcode上刷的题以及别的地方看到的有趣的东西，把还能看懂的上传一下，尽量标注题号 1、KMP算法---字符串匹配 利用字符串最长相同前缀后缀减少没必要的比较从而加快匹配 2、...
Python算法题源代码-LeetCode(力扣)-搜索插入位置
03-07
力扣热题Python源代码 题目35. 搜索插入位置 给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。 请必须使用时间复杂度为 O(log n) 的...
leetcode150python版-Leetcode-Algorithm-Python:Python中的Leetcode算法实践
06-30
Python版Leetcode-算法-Python Python中的Leetcode算法实践 所有简单的问题都更新了。 不带重复字符的中/3 最长子串 中型/11 容器，最多水 Hard/23-Merge K 排序列表 中/34-在排序数组中查找元素的第一个和最后一个...
leetcode题库-LeetCode_Python:LeetCode算法题Python实现
06-29
排序算法，如"快速排序"（Quick Sort），在Python中可以直观地展示分治思想。搜索算法，如"二分查找"（Binary Search），则是Python高效解决问题的经典案例。 在`LeetCode_Python-master`中，每个题目都有清晰的...
LeetCode912排序数组-总结十大排序算法
长舒的博客
03-10 176
class Solution { /** 练习一下排序方法 */ public int[] sortArray(int[] nums) { // bubble_sort(nums); // 冒泡排序 TLE 10/13 // quick_sort(nums,0,nums.length-1); // 快速排序 1018ms 54.4MB // insert_sort(nums); // 插入排序 TLE 11/13
【leetcode】排序题（python）
一路嵌行的博客
04-04 1203
1370：上升下降字符串(type: easy) 题目描述的复杂，其实就是不停地按字典序升序追加，降序追加，每次加一个 示例： 输入：s = "aaaabbbbcccc" 输出："abccbaabccba" 输入：s = "leetcode" 输出："cdelotee" 代码： 预排序+双栈实现，逻辑比较清晰 class Solution(object): def sortString...
十五个Python经典案例，学会这些，Python基础已过关！
码农黑羽的博客
11-09 8984
今天给大家搜集了十五道Python的经典案例，希望各位都能学会！不懂得大家可以在加群在群里发消息问问题，想要资料的也自取！ 一、猜数字 1到4能组成多少个互不相同且不重复数字的三位数？分别是？ 分析：可填在百位、十位、个位的数字都是1、2、3、4。组成所有的排列后再去 掉不满足条件的排列。 程序源代码： 二、公司发放的奖金的计算 分析：请利用数轴来分界，定位。注意定义时需把奖金定义成长整型。 程序源代码： 三、一个整数加上100后是一个完全平方数，再加168又是一个完
LeetCode与LintCode算法刷题笔记
"这是一份关于算法和数据结构的刷题笔记，主要涵盖LeetCode和Lintcode上的题目，包括Python和Java语言的实现。笔记详细梳理了基础数据结构、排序算法、基本算法策略等多个方面的知识，并对每个主题进行了深入的细分...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

AI研习图书馆

您的鼓励将是我创作的最大动力~

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值