python数据结构与算法第五天_数据结构与算法python 第5周-CSDN博客

本文链接：https://blog.csdn.net/lyckid/article/details/103336011

文章目录

希尔排序

希尔排序是插入排序的一种。也称缩小增量排序，是直接插入排序算法的一种更有效的改进版本。希尔排序是非稳定排序算法。该方法因DL.Shell于1959年提出而得名。写入排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键次越来越多，多增量减至1时，整个文件恰被分成一组，算法便终止。

希尔排序过程

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

排序后变为：

如此下去，最终获得有序序列

# coding:utf-8

def shell_sort(alist):
    '''希尔排序'''
    n = len(alist)
    gap = n//2

    while gap > 0:
        for j in range(gap, n):
            i=j
            while i >0:
                if alist[i]<alist[i-gap]:
                    alist[i],alist[i-gap]=alist[i-gap],alist[i]
                i -=gap
        gap //=2

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

输出如下

[54, 26, 93, 17, 77, 31, 44, 55, 20]
[17, 20, 26, 31, 44, 54, 55, 77, 93]

时间复杂度

最优时间复杂度：根据步长序列的不同而不同
最坏时间复杂度：O（ $n^2$ ）
稳定性：不稳定。

快速排序

快速排序（Quicksort），由称划分交换排序，通过一趟帕西将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行每一次达到整个数据变成有序序列。
步骤为：

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

递归的最不情形，时数列的大小时零或一，也就是永远都已经被排序好了。虽然一致递归下去，但时这个算法总会结束，因为在每次的迭代中，它至少会把一个元素拜倒它最后的位置上去。
在这里插入图片描述

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]

    # 从循环退出
    alist[low] = mid_value

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

    # 对high右边元素进行快排
    quick_sort(alist, high + 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)

输出：

[54, 26, 93, 17, 77, 31, 44, 55, 20]
[17, 20, 26, 31, 44, 54, 55, 77, 93]

时间复杂度

最优时间复杂度：O（nlogn）
最坏时间复杂度：O（ $n^2$ ）
稳定性：不稳定

从一开始快速排序需要花费O（nlogn）时间的描述并不明显。但时不难观察到的时分区运算，数组的元素都会在每次循环中走访一次，时O(n)的时间。在使用结合的版本中，这项运算也是O(n)。
在最好的情况，每次我们运行一次分区，我们会把一个数列分为两个几近相等的片段。这个意思就是每次递归条用处理一般大小的数列。因此，在到达大小为一的数列前，我们只要做logn次签到的调用。这个意思就是调用数的深度为O（logn）。但是在同一层次结构的两个程序调用中，不会处理到原来数列的相同部分；因此，程序调用的每一层次结构全部仅需要O（n）的时间，因此这个算法的复杂度为O（nlogn）。