数据结构：Python实现各种排序算法

摘要

• 共实现6种排序算法。
• 每个排序算法在代码片种都有核心思想的解释。
• 关于递归在本文最后有所补充。

---

代码：

冒泡排序：找到最大的，然后放最后。每一次循环都可能伴随着一次交换。

def bubble_sort(alist):
    '''冒泡排序'''
    n = len(alist)
    # 直接用n也可以
    for j in range(n-1):  # 控制每一次循环都能找到一个最大的。一直到倒数第二小和倒数第一小进行比较。
        count = 0  # 改进之后最优时间复杂度由n^2变为n
        for i in range(n-1-j):  # 每一次循环找到一个最大的放最后
            if alist[i] > alist[i+1]:
                alist[i], alist[i+1] = alist[i+1], alist[i]
                count += 1
        if count == 0:
            return


if __name__ == '__main__':
    li = [12,53,2,200, 5,101, 89, 98, 100]
    # li = [12]
    bubble_sort(li)
    print(li)
    
# 当相等时，不会交换位置，所以它是稳定的。

梳排序:类似冒泡排序，但是是按照1.3的标准取步长进行比较交换的。

def comb_sort(list_):
    lens = len(list_)
    if lens < 2:
        return list_
    else:
        i = int(lens / 1.3)
        while i >= 1:
            for j in range(lens):
                if i + j >= lens:
                    i = int(i / 1.3)
                    break
                else:
                    if list_[j] >= list_[j + i]:
                        list_[j], list_[j + i] = list_[j + i], list_[j]
        return list_


if __name__ == '__main__':
    the_list = [3, 44, 5, 21, 82, 7, 2, 3]
    print(comb_sort(the_list))

# 梳排序，类似冒泡排序，但是是按照一定的步长进行交换的，这类似希尔排序，这里取得步长是列表得长度除以1.3取整。
# 类似：8/1.3=6 6/1.3=4 ....一直到1/1.3<1结束
# 排序中心思想仍是：找到最大的，然后放最后。每一次循环都可能伴随着一次交换

选择排序：选一个最小的放最开始，循环结束确定最小的。

def select_sort(alist):
    '''选择排序'''
    n=len(alist)
    for j in range(n-1):  # 默认第一个是最小的索引
        min_num = j
        for i in range(1+j, n):  # 取出真正的最小的索引
            if alist[min_num] > alist[i]:
                min_num = i
        alist[j], alist[min_num] = alist[min_num], alist[j]  # 交换位置

# 当两数相等时，排序之后不会影响其原本所在的位置，即为稳定。
# 当以寻找最大数放置-1索引位置时，该函数是不稳定的。


alist = [17,20,93,54,77,31,44,55,226]

select_sort(alist)

print(alist)

插入排序：一直与前一个比较，比较之后再与前前一个比较，将每次比较出来的放置合适的位置。

# coding:utf-8
alist = [17,20,93,54,77,31,44,55,226]

def insert_sort(alist):
    '''插入排序'''
    n = len(alist)
    for j in range(n-1):      # 操作多少个数，代表多少次
        i = j+1  # i 代表从哪个数开始操作（索引）
        while i > 0:  # range(j,0,-1)
            if alist[i]<alist[i-1]:
                alist[i],alist[i-1] = alist[i-1],alist[i]
                i -= 1
            #     else 对程序本身没有影响，这是一个性能优化---o(n)2到o(n)（如果去掉else，需要把 i-=1（shift tab））
            else:
                break


insert_sort(alist)
print(alist)
# 稳定性：稳定。相同的元素的时候是不会进行交换操作的，所以稳定。

希尔排序：借助插入排序原理，但是比较的值不再是相邻的，而是按照一定的步长去比较。

# coding utf-8
alist = [17,20,93,54,77,31,44,55,226]
def shell_sort(alist):
    '''希尔排序'''
    n = len(alist)
    gap = n//2  # gap取中间值(其实它是不固定的，需要根据数学来计算?)
    while gap > 0:  # 将gap的值不断的缩小，当gap==1的时候，实际上便是利用插入排序操作了整个序列
        # 内层循环达到的效果是：每个以gap步长为基准的“子序列”是有序的，并不能代表整个序列是有序的。
        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步长
        gap //= 2

shell_sort(alist)
print(alist)
# 时间复杂度： 假设gap取1，那么就是一个很普通的插入排序，最坏时间复杂度是o(n^2);最优时间复杂度需要根据gap的值来确定。
# 稳定：因为分成几部分对待，所以相同的数可能不在一个“子序列”，于是不稳定。

快速排序：所有比他大的都在他的右边，所有比他小的都在他的左边（默认第一个值为中间值）。

# coding:utf-8


def quick_sort(alist,first,last):
    '''快速排序'''

    # 递归终止条件
    if first >= last:  # 为什么是>号，而不是==号？ 因为递归传参的时候可能存在传递的first和low-1中的low已经相等了，这个时候first是>low-1的，而这时候first和low-1作为索引对应的值在列表中还是可以找到的，所以仍会递归，于是出现递归错误。（这里判断条件有无=都可以）
        return
    # 规定第一个值为中间值
    mid_value = alist[first]
    low = first
    high = last

    while low < high:
        # 条件成立，height左移，循环不成立将小于中间值的放置左边
        while low < high and alist[high] >= mid_value:  # 等号存在的意义是将相等的数值放置右边（这是快速排序的思想决定的）。
        # 另外条件low<height是不可以去掉的，假设alist[high] >= mid_value一直满足，high就会一直变小，直到已经等于low，甚至小于low的时候还没有退出循环，就会超出索引的情况了。（在第一层循环满足的情况下，第二层循环在没退出的情况下是不受第一层循环限制的）。
            high -= 1
        alist[low] = alist[high]

        # 当退出上层循环的时候alist[height]的位置空着，所以我们判断左边的
        # 条件成立，low右移，循环不成立将大于中间值的放置右边
        while low < high and alist[low] < mid_value:  # 由于上一个同级别循环的限制，形成了即使low无限的+1，也一定会存在alist[low] == mid_value,即退出循环，所以这一个循环的判断条件，有无low < high都可以。
            low += 1
        alist[high] = alist[low]

    # 循环退出时 low==height
    alist[low] = mid_value

    # 递归
    # 对low左边列表执行快速排序（low是中间值，当然这个low也可以是high，因为中间值的时候就是alist[low]==alist[high]的时候）
    quick_sort(alist,first,low-1)
    # 对low右边列表执行快速排序
    quick_sort(alist,low+1,last)


if __name__ == '__main__':
    alist = [17, 20, 93, 54, 77, 31, 44, 55, 226]
    quick_sort(alist,0,len(alist)-1)
    print(alist)
# 最优时间复杂度是Nlogn.(logn是因为把n等分多少次而得的)n是每次拆分需要进行n次比较。
# 最坏时间复杂度是n2  第一个n是因为需要对每个元素操作  第二个n是因为每次对其中的一个元素操作的时候还要对n-1个元素操作。所以n*（n-1）约等于n^2
# 不稳定（参考二层循环中的第一个循环）

归并排序：先把数列拆开（拆到不能再拆了），然后依次往上按照升序来合并。

# coding:utf-8

def merge_sort(alist):
    '''归并排序'''
    n = len(alist)
    if n <= 1:  # 递归退出条件
        return alist  # 这个返回值是由最后一次调用递归的那个函数接受的（拆分到不能拆分了就返回了），也就是被left_li或者right_li接受了。这时并不会终止程序，只会终止此次递归,而后这次递归返回的数据也就是（left_li和right__li）都会进行下面的循环代码,之后返回值result_list便是可进行下面循环代码的递归函数来接受的，还是用（left_li或者right_li来接受），然后反复进行下面的循环，直到第一次调用这个函数得到了属于自己的返回值，代码运行结束。
    mid = n//2
    # 接受归并排序后左边的有序列表
    left_li = merge_sort(alist[:mid])
    # 接受归并排序后右边的有序列表
    right_li = merge_sort(alist[mid:])
    left_pointer, right_pointer = 0, 0
    result_list = []
    # 循环条件满足时，说明左右两边的游标都没有走到列表的末尾
    while left_pointer < len(left_li) and right_pointer < len(right_li):
        if left_li[left_pointer] <= right_li[right_pointer]:  # =号 是使排序稳定的作用
            result_list.append(left_li[left_pointer])
            left_pointer += 1
        else:
            result_list.append(right_li[right_pointer])
            right_pointer += 1

    # 退出循环后，让result_list需要和最后剩下的那个列表中的所有的元素都需要合并
    result_list += left_li[left_pointer:]
    result_list += right_li[right_pointer:]
    return result_list


if __name__ == '__main__':
    li = [17, 20, 93, 54, 77, 31, 44, 55, 226]

    print(merge_sort(li))

# 时间复杂度：nlogn n每次合并的最大次数，logn为拆分的总次数。由于必须从中间拆分（没有特殊情况）：所以最优最差时间复杂度都是nlogn
# 稳定：因为合并的时候并没有改变相同元素的排列位置。
# 拓展： 时间最短，但是它要新建一个列表，所以在空间上是有额外的开销的。

# 归并排序和快速排序的区别:
# 后者是在列表本身上操作，前者需要新建列表来接受“确定值”。
# 后者理念是：将大的放“某一个数”右边，小的放左边，然后再以“某一个数”为分界点拆开，拆开后还按照“大的在右，小的在左”的思想去操作。前者的理念是：全都拆开，然后一点点的比较，然后放置新的列表中并返回。

堆排序：将根节点和顶节点交换，然后砍断根节点，并恢复剩下数据的堆结构

# 堆是什么？
# 1、是一棵完全二叉树；2、所有父节点的值大于子节点的值--大顶堆（小顶堆相反）
# 如果用一个数组表示一个完全二叉树（下标顺序为从上到下，从左往右）的话，那么对于下标i而言，就会满足下面两个公式：parent=(i-1)//2  c1=2i+1 c2=2i+2。
# heapify：指的是使完全二叉树满足堆定义的操作。


def heapify(list_, n, i):
    largest = i
    c_left = 2 * i + 1
    c_right = 2 * i + 2

    if c_left < n and list_[i] < list_[c_left]:
        largest = c_left

    if c_right < n and list_[largest] < list_[c_right]:
        largest = c_right

    if largest != i:
        list_[i], list_[largest] = list_[largest], list_[i]  # 交换
        # 递归，继续对该节点的下面层做heapify(避免修改节点值之后，下面层不满足堆定义)。
        heapify(list_, n, largest)
    # 递归出口为 largest = i 的时候
    # return


def heap_sort(list_):
    n = len(list_)

    # 创建一个大顶堆
    # 循环的作用：倒着使每个节点都能做heapify
    for i in range(n, -1, -1):
        heapify(list_, n, i)
    # heapify(list_, n, i)
    print(list_)

    # 一个个交换元素
    for i in range(n - 1, 0, -1):
        list_[i], list_[0] = list_[0], list_[i]  # 交换
        heapify(list_, i, 0)  # 恢复剩下数据的堆结构
        # print("***", list_)


list_ = [12, 1, 14, 5, 20, 31, 6, 7]
heap_sort(list_)
print(list_)

# 堆排序原理：将根节点和顶节点交换，然后砍断根节点，并恢复剩下数据的堆结构。

二分查找：会用到索引，并且依次从中间分割，所以数据是有序的，数据结构是顺序表。

# coding: utf-8

li = [17,20,54,77,226]


def binary_search(alist,item):
    '''二分法查找'''
    n = len(alist)
    if n > 0:
        mid = n//2
        if alist[mid] == item:
            return True
        elif item <alist[mid]:
            # 需要有返回值的
            return binary_search(alist[:mid],item)
        else:
            return binary_search(alist[mid+1:],item)
    return False


def binary_search_02(alist,item):
    '''二分查找非递归'''
    n=len(alist)
    first=0
    last=n-1
    while first <= last:  # 等号也是成立的，刚好就是中间夹的那个值
        mid = (first+last)//2
        if alist[mid] == item:
            return True
        elif item < alist[mid]:
            last=mid-1
        else:
            first =mid+1
    return False


if __name__ == '__main__':
    print(binary_search(li,17))
    print(binary_search(li,100))
    print(binary_search(li,226))

    print(binary_search_02(li,17))
    print(binary_search_02(li,100))


# 递归和非递归的区别：
# 递归需要创建一个新的列表，非递归只是改变索引的位置。

# 二分查找（折半查找）会用到索引，并且依次从中间分割，所以必须是有序的，也就只能是顺序表。
# 时间复杂度：最差时间是logn（因为一直在等分），最优时间复杂度是 1 因为第一次找的时候就可以找到便是1了。
# 遍历方法的最优时间复杂度是：o(1) 第一个就是；最坏时间复杂度是o(n)，从头到尾。

补充：如何更好的理解递归?

• 1,递归需要终止条件
• 2,递归一般处理需要多次进行相同的操作。
• 3,递归一般需要返回值，如果没有返回值，它肯定也“改变”了什么。
• 本文仅服务作者本人。