各类排序算法对比及python代码实现

最新推荐文章于 2022-12-09 17:07:47 发布

R戎

最新推荐文章于 2022-12-09 17:07:47 发布

阅读量431

点赞数 1

分类专栏：数据结构

本文链接：https://blog.csdn.net/R18830287035/article/details/88321960

版权

数据结构专栏收录该内容

12 篇文章 0 订阅

订阅专栏

一、冒泡排序
按照从小到大排序
每次比较两个数的大小，把大的数放后面，第一次比较完之后，最大的数会放在最后。然后比较下一轮。

def bubble_sort(alist):
    """冒泡排序"""
    n = len(alist)
    for j in range(n-1):
    #判断是否要交换位置 
        count = 0
        for i in range(0, n-1-j):
            # 班长从头走到尾
            if alist[i] > alist[i+1]:
                alist[i],alist[i+1] = alist[i+1], alist[i]
                count += 1
         #如果count=0 即没有交换位置  数组是排序号的数字  此时的时间复杂度最低
        if 0 == count:
            return


# [1, 2,3 ,4 ,5, 6]



# i 0 ~ n-2   range(0, n-1) j=0
# i 0 ~ n-3   range(0, n-1-1) j=1
# i 0 ~ n-4   range(0, n-1-2) j=2
# j=n  i  range(0, n-1-j)
if __name__ == "__main__":
    li = [54, 26, 93, 17, 77, 31, 44, 55, 20]
    print(li)
    bubble_sort(li)
    print(li)

时间复杂度
最优时间复杂度：O(n) （表示遍历一次发现没有任何可以交换的元素，排序结束。）-----改进代码后才可以实现最优时间复杂度
最坏时间复杂度：O(n2)
稳定性：稳定
最优时间复杂度

二、选择排序
按照从小到大排序，每次都选择一个最小的数字放在最前面
alist = [54, 26, 93, 17, 77, 31, 44, 55, 20]
alist = [17, 20, 93,54,77,31,44,55,226]
0 1 2 3 4 5 6 7 8

j=0
min = 0 0+1
alist[0], alist[3] = alist[3], alist[0]

j=1
min = 1 1+1
alist[1], alist[8] = alist[8], alist[1]
j=2
min = 2 2+1

def select_sort(alist):
    """选择排序"""
    n = len(alist)
    for j in range(n-1): # j: 0 ~ n-2
        min_index = j
        for i in range(j+1, n):
            if alist[min_index] > alist[i]:
                min_index = i
       #遍历完成一次之后找到最终最小值的下标之后交换位置
        alist[j], alist[min_index] = alist[min_index], alist[j]

时间复杂度
最优时间复杂度：O(n2)
最坏时间复杂度：O(n2)
稳定性：不稳定（考虑升序每次选择最大的情况）

三、插入排序
相当于前面的数字是排好序的数字，后面的数字是没有排序的数
第一次取第一个数为排好序的数，然后第二个数与第一个数比较，如果比第一个数小则交换位置。
此时前面两个数排序完成。
然后第三个数与第二个数比较，如果比第二个数小则交换位置，交换完成之后与第一个数比较

def insert_sort(alist):
    # 从第二个位置，即下标为1的元素开始向前插入
    for i in range(1, len(alist)):
        # 从第i个元素开始向前比较，如果小于前一个元素，交换位置
        for j in range(i, 0, -1):#j = i [ i,i-1,i-2,i-3.....1]
            if alist[j] < alist[j-1]:
                alist[j], alist[j-1] = alist[j-1], alist[j]
 
def insert_sort2(alist):
    '插入排序代码另一种写法'
    n = len(alist)
    # 从右边的无序序列中取出多少个元素执行这样的过程
    for i in range(1, n):
        # i = [1, 2, 3, n-1]
        #j代表内层循环起始值
        j = i   #[j ,j-1,j-2,j-3.....1]
        #执行从右边的无序序列中取出的第一个元素，即i位置的元素，然后将其插入到前面的正确位置中
        while j > 0:
            if alist[j] < alist[j-1]:
                alist[j], alist[j-1] = alist[j-1], alist[j]
                j -= 1
            else: break# 本步对算法进行了优化
# 最优时间复杂度：O(n) （升序排列，序列已经处于升序状态）
# 最坏时间复杂度：O(n2)
 
if __name__=='__main__':
    alist = [54, 26, 93, 17, 77, 31, 44, 55, 20]
    insert_sort(alist)
    print(alist)
    alist = [54, 26, 93, 17, 77, 31, 44, 55, 20]
    insert_sort2(alist)
    print(alist)

时间复杂度
最优时间复杂度：O(n) （升序排列，序列已经处于升序状态）
最坏时间复杂度：O(n^2)
稳定性：稳定

四、希尔排序

希尔排序的基本思想是：将数组列在一个表中并对列分别进行插入排序，重复这过程，不过每次用更长的列（步长更长了，列数更少了）来进行。最后整个表就只有一列了。将数组转换至表是为了更好地理解这算法，算法本身还是使用数组进行排序。

例如，假设有这样一组数[ 13 14 94 33 82 25 59 94 65 23 45 27 73 25 39 10 ]，如果我们以步长为5开始进行排序，我们可以通过将这列表放在有5列的表中来更好地描述算法，这样他们就应该看起来是这样(竖着的元素是步长组成)：

13 14 94 33 82
25 59 94 65 23
45 27 73 25 39
10
然后我们对每列进行排序：

10 14 73 25 23
13 27 94 33 39
25 59 94 65 82
45
将上述四行数字，依序接在一起时我们得到：[ 10 14 73 25 23 13 27 94 33 39 25 59 94 65 82 45 ]。这时10已经移至正确位置了，然后再以3为步长进行排序：

10 14 73
25 23 13
27 94 33
39 25 59
94 65 82
45
排序之后变为：

10 14 13
25 23 33
27 25 59
39 65 73
45 94 82
94
最后以1步长进行排序（此时就是简单的插入排序了）

# coding:utf-8

def shell_sort(alist):
    """希尔排序"""
    # n=9
    n = len(alist)
    # gap =4
    gap = n // 2
    # i = gap
    # for i in range(gap, n):
    #     # i = [gap, gap+1, gap+2, gap+3... n-1]
    #     while:
    #     if alist[i] < alist[i-gap]:
    #         alist[i], alist[i-gap] = alist[i-gap], alist[i]

    # gap变化到0之前，插入算法执行的次数
    while gap > 0:
        # 插入算法，与普通的插入算法的区别就是gap步长
        for j in range(gap, n):
            # j = [gap, gap+1, gap+2, gap+3, ..., n-1]
            i = j
            while i > 0:
                if alist[i] < alist[i-gap]:
                    alist[i], alist[i-gap] = alist[i-gap], alist[i]
                    i -= gap
                else:
                    break
        # 缩短gap步长
        gap //= 2


if __name__ == "__main__":
    li = [54, 26, 93, 17, 77, 31, 44, 55, 20]
    print(li)
    shell_sort(li)
    print(li)

时间复杂度

最优时间复杂度：根据步长序列的不同而不同
最坏时间复杂度：O(n2)
稳定想：不稳定

五、快速排序

步骤为：

从数列中挑出一个元素，称为"基准"（pivot），
重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

具体思路： alist = [54, 26, 93, 17, 77, 31, 44, 55, 20]
将第一个数54作为基准，有两个指针，第一个low指向第一个位置的数字54，high指向最后一个位置的数字20.
比较low和high数字的大小，如果high>low high的指针往左移动，如果high<low 把high的数字放在low的位置，判断low和high，如果low<high low的位置右移一，如果low>high 把low的数字放在high的位置，直到low和high重合，此时找到了第一个数的排序后的位置。再重复第一个数左边和右边的数字排序。

# coding:utf-8


def quick_sort(alist, first, last):
    """快速排序"""
    if first >= last:
        return
    mid_value = alist[first]
    low = first
    high = last
    while low < high:
        # high 左移
        while low < high and alist[high] >= mid_value:
            high -= 1
        alist[low] = alist[high]

        while low <high and alist[low] < mid_value:
            low += 1
        alist[high] = alist[low]
    # 从循环退出时，low==high
    alist[low] = mid_value

    # 对low左边的列表执行快速排序
    quick_sort(alist, first, low-1)

    # 对low右边的列表排序
    quick_sort(alist, low+1, last)


if __name__ == "__main__":
    li = [54, 26, 93, 17, 77, 31, 44, 55, 20]
    print(li)
    quick_sort(li, 0, len(li)-1)
    print(li)

六、归并排序
归并排序是采用分治法的一个非常典型的应用。归并排序的思想就是先递归分解数组，再合并数组。

将数组分解最小之后，然后合并两个有序数组，基本思路是比较两个数组的最前面的数，谁小就先取谁，取了后相应的指针就往后移一位。然后再比较，直至一个数组为空，最后把另一个数组的剩余部分复制过来即可。

# coding:utf-8


def merge_sort(alist):
    """归并排序"""
    n = len(alist)
    if n <= 1:
        return alist
    mid = n//2

    # left 采用归并排序后形成的有序的新的列表
    left_li = merge_sort(alist[:mid])

    # right 采用归并排序后形成的有序的新的列表
    right_li = merge_sort(alist[mid:])

    # 将两个有序的子序列合并为一个新的整体
    # merge(left, right)
    left_pointer, right_pointer = 0, 0
    result = []

    while left_pointer < len(left_li) and right_pointer < len(right_li):
        if left_li[left_pointer] <=  right_li[right_pointer]:
            result.append(left_li[left_pointer])
            left_pointer += 1
        else:
            result.append(right_li[right_pointer])
            right_pointer += 1

    result += left_li[left_pointer:]
    result += right_li[right_pointer:]
    return result


if __name__ == "__main__":
    li = [54, 26, 93, 17, 77, 31, 44, 55, 20]
    print(li)
    sorted_li = merge_sort(li)
    print(li)
    print(sorted_li)

    # merge_sort   [54, 26, 93, 17, 77, 31, 44, 55, 20]
    #
    # left_li = merge_sort [54, 26, 93, 17]
    #
    #     left_li = merge_sort [54, 26]
    #     left_li = [26, 54]
    #
    #
    #              left_li = [54]
    #              right_li = [26]
    #              result = [26, 54]
    #              return result
    #
    #     right_li = merge_sort([93, 17])
    #
    #             left_li = merge_sort([93])
    #
    #                         return [93]
    #             left_li =[93]
    #
    #             right_li = merge_sort([17])
    #
    #                         return [17]
    #             right_li = [17]
    #
    #             result = [17, 93]
    #
    #             return result
    #
    #     right_li = [17, 93]
    #
    #     result = [17, 26, 54, 93]
    #
    #     return result
    #
    # left_li = [17, 26, 54, 93]
    #
    # right_li = merge_sort([77, 31, 44, 55, 20])
    #
    #
    # result = []
    # return result