python数据结构-希尔快速归并排序

希尔排序

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

实现

# coding:utf-8

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

    while gap > 0:      # gap变化到0之前，插入算法执行的次数
        for j in range(gap, n):     # 与普通的插入算法区别就是gap的步长
            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 //= 2   # 缩短gap步长


if __name__ == "__main__":
    li = [25, 65, 54, 87, 19, 4, 35, 55]
    print(li)
    shell_sort(li)
    print(li)

运行结果

时间复杂度

最优时间复杂度: O(n)
最坏时间复杂度: O(n^2)
稳定性:不稳定
 

快速排序

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

图示

实现

# 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]
    alist[low] = mid_value      # 从循环推出时，low==high
    quick_sort(alist, first, low-1)        # 对low左边的列表执行快速排序
    quick_sort(alist, low+1, last)          # 对low右边的列表排序


if __name__ == "__main__":
    li = [25, 65, 54, 87, 19, 4, 35, 55, 99, 44]
    print(li)
    quick_sort(li, 0, len(li)-1)
    print(li)

运行结果

时间复杂度

最优时间复杂度: O(nlogn)
最坏时间复杂度: O(n^2)
稳定性:不稳定
 

归并排序

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

实现

# 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 = [25, 65, 54, 87, 19, 4, 35, 55, 99, 44]
    print(li)
    sorted_li = merge_sort(li)
    print(li)
    print(sorted_li)

运行结果

时间复杂度

最优时间复杂度: O(nlogn)
最坏时间复杂度: O(nlogn)
稳定性:稳定