算法案例学习

print("冒泡排序"+"*"*20)
# 冒泡排序
# 冒泡排序总结
# 有N个数据需要比较N-1趟
# 每趟比较N-i次,i表示第几趟，例如7个数据，第四趟需要比较 7-4 = 3次
def bubble_sort(numlist):
    # 需要排列的数据个数
    N = len(numlist)
    # i 控制一共需要多少趟 N-1
    for i in range(N - 1):

        # 定义一个变量，用于记录是否在本趟中发生了交换
        isChange = 0

        # j 控制每趟需要比较多少次(因为i是从0开始，所以N-i-1)
        for j in range(N - i - 1):
            # 判断j和j+1两个位置的数据大小
            if numlist[j] > numlist[j + 1]:
                # 交换（交换的代码有很多种写法）
                temp = numlist[j]
                numlist[j] = numlist[j + 1]
                numlist[j + 1] = temp
                # 只要发生了交换，我们就改变isChange的值为1
                isChange = 1

        # 只要isChange =0说明已经是正确顺序了，直接break即可
        if isChange == 0:
            break


list = [19, 2, 13, 8, 34, 25, 7]
print("排序前list = %s" % list)
bubble_sort(list)
print("排序后list = %s" % list)

print("选择排序"+"*"*20)
# 定义选择排序函数
def selection_sort(list):
    # 计算需要排序的列表元素个数
    N = len(list)
    # 需要N-1次选择操作
    for i in range( N -1):
        # 记录最小值的小标
        minNum_index = i
        # 未排序区域从i+1到末尾N处，属于未排序区，在未排序区在选出最小值处
        for j in  range( i +1 ,N):
            # 比较大小
            if list[minNum_index ] >list[j]:
                # 交换
                temp = list[minNum_index]
                list[minNum_index] = list[j]
                list[j] = temp

# 创建一个列表
numList = [19 ,2 ,13 ,8 ,34 ,25 ,7]

print("排序前：%s " %numList)
# 调用选择排序
selection_sort(numList)
print("排序后：%s " %numList)

print("插入排序"+"*"*20)
#定义插入排序函数
def insertion_sort(list):
    # 获取需要排序数据的个数
    N = len(list)
    # 插入排序的第一次插入从第二个数字开始选择，所以下标从1开始
    for i in range(1, N):
        # 从选择插入的数据，一次和它前一个比较，主要比前面的小就交换
        for j in range(i, 0, -1):
            # 判断大小
            if list[j] < list[j - 1]:
                # 交换
                temp = list[j]
                list[j] = list[j - 1]
                list[j - 1] = temp


numlist = [19, 2, 13, 8, 34, 25, 7]
print("排序前：%s" % numlist)
insertion_sort(numlist)
print("排序后：%s" % numlist)

print("希尔排序"+"*"*20)
# 创建一个希尔排序的函数
def shell_sort(alist):
    # 需要排序数组的个数
    N = len(alist)
    # 最初选取的步长
    gap = N // 2

    # 根据每次不同的步长，对分组内的数据进行排序
    # 如果步长没有减为1就继续执行
    while gap > 0:
        # 对每个分组进行插入排序，
        # 因为插入排序从第二个元素开始，而这里第二个元素的下标就是gap
        # 所以i的起始点是gap
        for i in range(gap, N):
            # 控制每个分组内相邻的两个元素,逻辑上相邻的两个元素间距为gap，
            # j的前一个元素比它少一个gap距离，所以for循环中j的步长为 -gap
            for j in range(i, 0, -gap):
                # 判断和逻辑上的分组相邻的两个数据大小
                if alist[j] < alist[j - gap] and j - gap >= 0:
                    # 交换
                    temp = alist[j]
                    alist[j] = alist[j - gap]
                    alist[j - gap] = temp
        # 改变步长
        gap = gap // 2


numlist = [5, 7, 8, 3, 1, 2, 4, 6, 9,10,5,5]
print("排序前：%s" % numlist)
shell_sort(numlist)
print("排序后：%s" % numlist)

print("快速排序"+"*"*20)
# 快速排序
def quick_sort(alist, start, end):
    # 递归的推出条件，递归一定要有出口
    if start >= end:
        return

    # 设置起始元素为要寻找为准的基准元素
    k = alist[start]
    # 设置变量i记录从左到右的查找
    i = start
    # 设置变量j记录从右到左的查找
    j = end

    # i<j说明还没有i和j还没有碰面，需要继续比较
    while i < j:

        # i<j,并且此时的数据要是都比k的话（从右到左比较）
        while i < j and alist[j] >= k:
            # j就递减，一直往前找，
            j -= 1
        # 出了while循环就说明找到需要交换的数据了
        temp = alist[j]
        alist[j] = alist[i]
        alist[i] = temp

        # i<j 并且此时的数据要是都比k小的话（从左右到比较）
        while i < j and alist[i] <= k:
            # i就递增，一直往后找
            i += 1
        # 出了while循环就说明找到需要交换的数据了
        temp = alist[j]
        alist[j] = alist[i]
        alist[i] = temp
    # 然后对左边的数据使用递归继续排序
    quick_sort(alist, start, i - 1)
    # 然后对右边的数据使用递归继续排序
    quick_sort(alist, i + 1, end)
# 创建一个数组
numlist = [6, 1, 2, 7, 9, 5, 4, 3, 10, 8]
print("排序前：%s" % numlist)
quick_sort(numlist, 0, len(numlist) - 1)
print("排序后：%s" % numlist)