python实现选择排序、插入排序、希尔排序、快速排序、归并排序

#排序算法
#冒泡排序：比较两个数的大小，然后进行排序，每个循环最后一个数最大
def bubblesort(num):
    #注意外循环控制的是次数
    for i in range(len(num)-1):
        for j in range(len(num)-1,i,-1):
        #大数一直在往后排，直到大数最后一个
            if num[j] < num[j-1]:
                num[j],num[j-1] = num[j-1],num[j]
    return num

#选择排序：先选择最小的然后与每次循环中的开头进行交换，
#即每次在剩下的数中选择最小的排放在指定位置上
def selectsort(num):
    for i in range(len(num)-1):
        min_index = i
        for j in range(i,len(num)):
            if num[j] < num[min_index]:
                min_index = j
        if min_index != i:
            num[i],num[min_index] = num[min_index],num[i]
    return num

#插入排序：每个n是按照顺序排序的
def insertsort(num):
    for i in range(0,len(num)):
      #外部循环进行控制到哪一步
      #冒泡排序的区别在于保持前i个有序
        for j in range(i,0,-1):
           #内部循环进行排序
            if num[j-1] > num[j]:
                num[j-1],num[j] = num[j],num[j-1]
    return num

#希尔排序
def shellsort(ary):
    count = len(ary)
    gap = round(count / 2)
    # 双杠用于整除（向下取整），在python直接用 “/” 得到的永远是浮点数，
    # 用round()得到四舍五入值
    while gap >= 1:
        for i in range(gap, count):
            temp = ary[i]
            j = i
            while j - gap >= 0 and ary[j - gap] > temp:  # 到这里与插入排序一样了
                ary[j] = ary[j - gap]
                j -= gap
            ary[j] = temp
        gap = round(gap / 2)
    return ary

#快速排序：（1）双指针；（2）可以先分成比基准小的与比基准大的，然后进行递归
def quicksort(num):
    def quick(start,end,num):
        if start >= end:
            return
        s = start
        e = end
        temp = num[s]
        while s < e:
            while num[e] > temp and e > s:
                e -= 1
            num[s] = num[e]
            while num[s] <= temp and e > s:
                s += 1
            num[e] = num[s]
        num[s] = temp
        quick(start,s,num)
        quick(s+1,end,num)
        return num
    count = quick(0,len(num)-1,num)
    return count
def quicksort0(nums):
    def quick(num):
        if len(num)== 0:
            return num
        temp = num[0]
        left = []
        right = []
        for i in num[1:]:
            if i <= temp:
                left.append(i)
            else:
                right.append(i)


        left = quick(left)
        right = quick(right)
        num = left + [temp] + right
        return num
    nums = quick(nums)
    return nums

# 归并排序
def merge(left, right):
    '''合并操作，
    将两个有序数组left[]和right[]合并成一个大的有序数组'''
    res = []
    i = j = k = 0
    while (i < len(left) and j < len(right)):
        if left[i] < right[j]:
            res.append(left[i])
            i += 1
        else:
            res.append(right[j])
            j += 1

    res = res + left[i:] + right[j:]
    //不考虑剩下哪个，直接全部相连接
    return res
def merge_sort(ary):

    if len(ary) <= 1:
        return ary

    median = int(len(ary) / 2)  # 二分分解
    left = merge_sort(ary[:median])
    right = merge_sort(ary[median:])
    print('left',left)
    print('right',right)
    return merge(left, right)  # 合并数组
#left [19]
# right [20]
# left [17]
# right [13]
# left [19, 20]
# right [13, 17]
# left [28]
# right [14]
# left [23]
# right [15]
# left [14, 28]
# right [15, 23]
# left [13, 17, 19, 20]
# right [14, 15, 23, 28]
# [13, 14, 15, 17, 19, 20, 23, 28]




print(merge_sort([19,20,17,13,28,14,23,15]))