排序算法python

最新推荐文章于 2024-11-10 23:58:12 发布

SmiledrinkCat

最新推荐文章于 2024-11-10 23:58:12 发布

阅读量143

点赞数 1

分类专栏：编程题文章标签：排序算法 python 快速排序排序

本文链接：https://blog.csdn.net/SmiledrinkCat/article/details/118764073

版权

编程题专栏收录该内容

34 篇文章 0 订阅

订阅专栏

这篇博客介绍了几种常见的排序算法，包括插入排序、冒泡排序、选择排序、快速排序和归并排序，并提供了每种算法的Python实现。文章详细讨论了它们的时间复杂度和稳定性，其中快速排序在所有算法中运行时间最短，而归并排序虽然比快速排序慢，但具有稳定性优势。对于大规模数据排序，快速排序和归并排序是更好的选择。

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

描述

给定一个数组，请你编写一个函数，返回该数组排序后的形式。

示例1

输入：

[5,2,3,1,4]

返回值：

[1,2,3,4,5]

示例2

输入：

[5,1,6,2,5]

返回值：

[1,2,5,5,6]

备注

数组的长度不大于100000，数组中每个数的绝对值不超过10^9109

代码

class Solution:
    def MySort(self , arr ):
        # 1.插入排序,运行时间2001ms,超时
        for i in range(len(arr)):
            for j in range(i):
                if arr[i] < arr[j]:
                    arr.insert(j, arr.pop(i))
                    break
        return arr
        
        # 2.冒泡排序,运行时间2001ms,超时
        for i in range(0, len(arr)):
            for j in range(i+1, len(arr)):
                if arr[i] > arr[j]:
                    arr[i], arr[j] = arr[j], arr[i]
        return arr

        # 3.选择排序,运行时间2001ms,超时
        for i in range(len(arr) - 1):
            x = i
            for j in range(i, len(arr)):
                if arr[j] < arr[x]:
                    x = j
            arr[i], arr[x] = arr[x], arr[i]
        return arr

        # 4.快速排序,运行时间503ms,通过
        if arr == []:
            return arr
        else:
            first = arr[0]
            qless = Solution().MySort([l for l in arr[1:] if l < first])
            qmore = Solution().MySort([m for m in arr[1:] if m >= first])
            return qless + [first] + qmore
            
        # 5.归并排序,运行时间1896ms,通过
        def sort_arr(arr_l, arr_r):
            array = []
            while len(arr_l) and len(arr_r):
                if arr_l[0] < arr_r[0]:
                    array.append(arr_l.pop(0))
                elif arr_l[0] >= arr_r[0]:
                    array.append(arr_r.pop(0))
            if len(arr_l) != 0:
                array += arr_l
            elif len(arr_r) != 0:
                array += arr_r
            return array
            
        def recursive(array):
            if len(array) == 1:
                return array
            mid = len(array) // 2
            arr_l = recursive(array[:mid])
            arr_r = recursive(array[mid:])
            return sort_arr(arr_l, arr_r)
            
        return recursive(arr)

1.插入排序：插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序；首先将第一个作为已经排好序的，然后每次从后的取出插入到前面并排序；

时间复杂度：O(n²)
空间复杂度：O(1)
稳定性：稳定

class Solution:
    def MySort(self , arr ):
        # 1.插入排序,运行时间2001ms,超时
        for i in range(len(arr)):
            for j in range(i):
                if arr[i] < arr[j]:
                    arr.insert(j, arr.pop(i))
                    break
        return arr

2.冒泡排序：它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成

时间复杂度：O(n²)
空间复杂度：O(1)
稳定性：稳定

class Solution:
    def MySort(self , arr ):   
        # 2.冒泡排序,运行时间2001ms,超时
        for i in range(0, len(arr)):
            for j in range(i+1, len(arr)):
                if arr[i] > arr[j]:
                    arr[i], arr[j] = arr[j], arr[i]
        return arr

3.选择排序：第1趟，在待排序记录r1 ~ r[n]中选出最小的记录，将它与r1交换；第2趟，在待排序记录r2 ~ r[n]中选出最小的记录，将它与r2交换；以此类推，第i趟在待排序记录r[i] ~ r[n]中选出最小的记录，将它与r[i]交换，使有序序列不断增长直到全部排序完毕

时间复杂度：O(n²)
空间复杂度：O(1)
稳定性：不稳定

class Solution:
    def MySort(self , arr ):
        # 3.选择排序,运行时间2001ms,超时
        for i in range(len(arr) - 1):
            x = i
            for j in range(i, len(arr)):
                if arr[j] < arr[x]:
                    x = j
            arr[i], arr[x] = arr[x], arr[i]
        return arr

4.快速排序：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列

时间复杂度：O(nlog₂n)
空间复杂度：O(nlog₂n)
稳定性：不稳定

class Solution:
    def MySort(self , arr ):
        # 4.快速排序,运行时间503ms,通过
        if arr == []:
            return arr
        else:
            first = arr[0]
            qless = Solution().MySort([l for l in arr[1:] if l < first])
            qmore = Solution().MySort([m for m in arr[1:] if m >= first])
            return qless + [first] + qmore

5.归并排序：采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并

时间复杂度：O(nlog₂n)
空间复杂度：O(1)
稳定性：稳定

class Solution:
    def MySort(self , arr ):
        # 5.归并排序,运行时间1896ms,通过
        def sort_arr(arr_l, arr_r):
            array = []
            while len(arr_l) and len(arr_r):
                if arr_l[0] < arr_r[0]:
                    array.append(arr_l.pop(0))
                elif arr_l[0] >= arr_r[0]:
                    array.append(arr_r.pop(0))
            if len(arr_l) != 0:
                array += arr_l
            elif len(arr_r) != 0:
                array += arr_r
            return array
            
        def recursive(array):
            if len(array) == 1:
                return array
            mid = len(array) // 2
            arr_l = recursive(array[:mid])
            arr_r = recursive(array[mid:])
            return sort_arr(arr_l, arr_r)
            
        return recursive(arr)