数据结构排序算法一

排序算法

如何分析一个排序算法

1. 排序算法的执行效率

• 时间复杂度
• 比较次数和交换（移动）次数

2. 排序算法的内存消耗
   原地排序算法就是指时间复杂度为O(1)的排序算法
3. 排序算法的稳定性
   当一个序列中存在两个相同的值，经过排序后相等值的元素的顺序不变，该排序算法就是稳定的。

递归

递归是一种算法，需满足一下条件

• 一个问题可以分解为若干个子问题
• 分解后的子问题除数据规模不同，求解思路一样
• 存在终止条件

注意，python中默认的递归深度为1000，当递归次数超过1000时会报错

练习
用递归的方式输出l=[‘jack’,(‘tom’,23),‘rose’,(14,55,67)] 列表内的每一个元素

l = ['jack',('tom',23),'rose',(14,55,67)] 

def func(item):
    if isinstance(item, (str, int)):
        print(item)
    else:
        for i in item:
            func(i)

func(l)

冒泡排序

冒泡排序（Bubble sort），是一种简单的排序算法。它重复遍历要排序的元素，并两两比较大小，如果前面的大后面的小就交换顺序，如果两个元素的大小一样，则保持不变，知道没有可以交换的元素，也就是该序列完成排序。

运作如下

• 比较相邻两个元素的大小，如果前面的大则交换位置
• 对每一个相邻的元素都做比较，一直到最后，此时最后一个是最大的
• 重复上述步骤，直到所有两两元素，按顺序排列

代码实现

import random
i = 0
l = []
# 因为想一个随机的序列很累，所以我生成一个
while i < 9:
    j = random.randint(1, 100)
    l.append(j)
    i += 1
# 打印随机生成的整数序列
print(l)

def dubble_sort(lis):
    # 冒泡排序需要的运算次数依次为，n,n-1,...,1
    for i in range(len(lis)-1, 0, -1):
        # j是两两元素的对比次数，对比次数依次为，n-1,n-2,...,1
        for j in range(i):
            # 如果前面的小于后面的，就交换
            if lis[j] > lis[j+1]:
                lis[j], lis[j+1] = lis[j+1], lis[j]

if __name__ == '__main__':
    dubble_sort(l)
    print(l)

# [73, 83, 2, 67, 17, 47, 18, 36, 21]
# [2, 17, 18, 21, 36, 47, 67, 73, 83]

冒泡算法是一种稳定排序，其时间复杂度为O(n**2)

plan B

l = [73, 83, 2, 67, 17, 47, 18, 36, 21]

def dubble_sort(lis):
    for i in range(len(lis)-1):
        for j in range(0, len(lis)-i-1):
            if lis[j] > lis[j+1]:
                lis[j], lis[j+1] = lis[j+1], lis[j]
dubble_sort(l)
print(l)

选择排序

选择排序（Selection sort)：在未排序的序列中找到最大（小）值，将其与序列的末尾（开头）元素交换，在从剩下的未排序的元素中找到最大（小）值，将其放入已排序的序列，直到结束。

import random
i = 0
l = []
while i < 9:
    j = random.randint(1, 100)
    l.append(j)
    i += 1

print(l)

def selection_sort(lis):
    for i in range(len(lis)-1, 0, -1):
        max_index = i
        for j in range(i):
            if lis[j] > lis[max_index]:
                max_index = j
        lis[i], lis[max_index] = lis[max_index], lis[i]

if __name__ == '__main__':
    selection_sort(l)
    print(l)
    
# [88, 30, 25, 85, 80, 82, 41, 81, 85]
# [25, 30, 41, 80, 81, 82, 85, 85, 88]

这里我选择用找最大值的方式，选择排序可以稳定也可以不稳定，依具体情况而定。

插入排序

插入排序（insertion sort):它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

这个图画的不是很好，第三行，当我们找到1往头部插入时，它不是直接插入的，它是通过一步一步交换换到第一个位置的，1-6,1-5,1-4，这样实现的。

插入排序包含两个操作，一是元素比较，二是元素移动。

import random
i = 0
l = []
while i < 9:
    j = random.randint(1, 100)
    l.append(j)
    i += 1

print(l)

def insert_sort(lis):
    n = len(lis)
    for i in range(1,n):
        for j in range(i):
            if lis[i] < lis[j-1]:
                lis[i], lis[j-1] = lis[j-1], lis[i]


if __name__ == '__main__':
    insert_sort(l)
    print(l)

# [26, 96, 69, 16, 45, 48, 19, 49, 30]
# [16, 19, 26, 30, 45, 48, 49, 96, 69]

其稳定性也是相对而言的，时间复杂度O(n**2)

希尔排序

希尔排序（shell sort):
是插入排序的一种，也称缩小增量排序，是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序。希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量的减少，每组包含的关键字越来越多，当增量减为1时，整个文件恰被分成一组，算法便终止。

"""希尔排序"""
import random
i = 0
l = []
while i < 9:
    j = random.randint(1, 100)
    l.append(j)
    i += 1

print(l)

def shell_sort(lis):
    mid = len(lis) // 2
    gap = len(lis) // 2
    while gap > 0:
        for i in range(gap, len(lis)):
            while i >= gap:
                if lis[i - gap] > lis[i]:
                    lis[i - gap], lis[i] = lis[i], lis[i - gap]
                i -= gap

        gap = gap // 2


if __name__ == '__main__':
    # l = [73, 83, 2, 67, 17, 47, 18, 36, 21]
    shell_sort(l)
    print(l)

快速排序

快速排序（Quick sort),又称为划分交换排序(partiton-exchange sort),
通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另一个部分的所有数据都小，然后再按此方法对这两部分数据进行快速排序，整个排序过程可以递归进行，这到变成有序序列。

操作步骤

1. 从序列中挑选一个元素，称为“基准”(pivot)。
2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准后面（相同的数可以放到任意一边），在分区结束后，基准元素就位于序列的中间，这步称为分区(partiton)操作。
3. 递归地(recursive)把小于基准值元素的子数列和大于基准值元素的子序列排序。

虽然会一直递归下去，但总有结束的时候，最坏的情况就是每次选到的值都是最大或最小值，就变成了一个冒泡排序。

快排分析

def quick_sort(lis, start, end):
    pivot = lis[start]
    low = start
    hight = end
    if start >= end:
        return
    while low < hight:
        while low < hight and lis[hight] >= pivot:
            hight -= 1
        lis[low] = lis[hight]
        while low < hight and lis[low] < pivot:
            low += 1
        lis[hight] = lis[low]

    lis[low] = pivot
    quick_sort(lis, start, low-1)
    quick_sort(lis, hight+1, end)


if __name__ == '__main__':
    l = [78, 99, 71, 53, 68, 79, 22, 9, 28]
    quick_sort(l, 0, len(l) - 1)
    print(l)