5,python实现五种排序函数（冒泡、选择、插入、归并、堆、快速）

# #1.冒泡排序
# #2.选择排序
# #3.插入排序
# #4.归并排序
# #5.堆排序
# #6.快速排序
#
# def sort(n,num):  # n的数值为使用的上述第n个排序方法
#     if n==1:  #冒泡排序
#         for i in range(len(num)-1):
#             for j in range(len(num)-i-1):
#                 if num[j]>num[j+1]:
#                     num[j],num[j+1]=num[j+1],num[j]
#             # print(num)
#         return num
#
#     if n==2:  #选择排序
#         for i in range(len(num)-1):
#             min=num[i]
#             for j in range(i+1,len(num)):
#                 if num[j]<min:
#                     num[j],min=min,num[j]
#             num[i]=min
#             # print(num)
#         return num
#
#     if n==3:  #插入排序
#         for i in range(1,len(num)):
#             j=i-1
#             if num[i]<num[j]:
#                 temp=num[i]
#                 num[i]=num[j]
#                 j=j-1
#                 while j>=0 and num[j]>temp:
#                     num[j+1]=num[j]
#                     j=j-1
#                 num[j+1]=temp
#                 # print(num)
#         return num
#
#     if n==4:
#         def merge_sort(arr):
#             if len(arr) == 1:
#                 return arr
#             mid = len(arr) // 2
#             l = arr[:mid]
#             r = arr[mid:]
#             left = merge_sort(l)
#             right = merge_sort(r)
#
#             return merge(left, right)
#
#         def merge(left, right):
#             result = []
#             while len(left) > 0 and len(right) > 0:
#                 if left[0] <= right[0]:
#                     result.append(left.pop(0))
#                 else:
#                     result.append(right.pop(0))
#             if len(left) == 0:
#                 result += right
#             else:
#                 result += left
#             # print(result)
#             return result
#         return merge_sort(num)
#
#     if n==5:
#
#         def sift(data, low, high):
#             i = low  # 父节点
#             j = 2 * i + 1  # 左子节点
#             tmp = data[i]  # 父节点值
#             while j <= high:  # 子节点在节点中
#                 if j < high and data[j] > data[j + 1]:  # 有右子节点且右节点比父节点值大
#                     j += 1
#                 if tmp > data[j]:
#                     data[i] = data[j]  # 将父节点替换成新的子节点的值
#                     i = j  # 变成新的父节点
#                     j = 2 * i + 1  # 新的子节点
#                 else:
#                     break
#             data[i] = tmp  # 将替换的父节点值赋给最终的父节点
#
#         def heap_sort(data):
#             n = len(data)
#             # 创建堆
#             for i in range(n // 2 - 1, -1, -1):
#                 sift(data, i, n - 1)
#
#             # 挨个出数
#             for i in range(n - 1, -1, -1):  # 从大到小
#                 data[0], data[i] = data[i], data[0]  # 将最后一个值与父节点交互位置
#                 sift(data, 0, i - 1)
#
#         heap_sort(num)
#         return num
#
#     if n==6:
#         #详解：https://blog.csdn.net/code_ac/article/details/74158681
#         # 首先写挖坑的操作，挖坑操作只能处理序列成为两个小序列
#         # 至于小序列的从排序是不能自动处理的
#         # 所以一会还要有另一个函数来递归调用挖坑函数
#         # 达到使每一个小序列也进行挖坑操作的目的
#
#         # 指定序列a，左指针left，右指针right，左右指针表明了排序的区间
#         # 因为在处理小序列的时候，头尾就不再是0 和 len(a)-1 了
#         def wakeng(a, left, right):
#             # 这个x就是基准数，一般拿头就可以了
#             x = a[left]
#             # 当left right重合时，把x填进这个坑，然后结束本次挖坑操作
#             while left < right:
#                 # 开始尾巴找小的往左放
#                 # 这里加了left right条件是因为当序列初始就是排好基准数右边都比他大
#                 # right都到了left那边，都越界了，right还在自减，这可不行
#                 while left < right and a[right] > x:
#                     right -= 1
#                 # 同样的道理，要保证不越界
#                 if left < right:
#                     a[left] = a[right]
#                     left += 1
#
#                 # 开始从头找大的往右放
#                 while left < right and a[left] <= x:
#                     left += 1
#                 if left < right:
#                     a[right] = a[left]
#                     right -= 1
#             # 把x填进 left 和 right 同时指向的这个坑
#             a[left] = x
#             # 返回当前基准数的位置，作为下次小序列的边界。
#             return left
#
#         # 循环每个小序列的函数，分治
#         def fenzhi(a, left, right):
#             # 同样函数结束条件就是left == right
#             if left < right:
#                 # 拿到位置
#                 weizhi = wakeng(a, left, right)
#                 # 分别对两个小序列再分治挖坑
#                 fenzhi(a, left, weizhi - 1)
#                 fenzhi(a, weizhi + 1, right)
#
#         fenzhi(num, 0, len(num) - 1)
#         return num
#
# if __name__=='__main__':
#     print('请选择使用的排序算法\n'
#           '1.冒泡排序\n'
#           '2.选择排序\n'
#           '3.插入排序\n'
#           '4.归并排序\n'
#           '5.堆排序\n'
#           '6.快速排序')
#     n=int(input('请输入（1-6）：'))
#     while n<1 or n>6:
#         n = int(input('输入错误，重新输入（1-6）：'))
#
#     num=input('输入需要排序的数列：')
#     num=num.split(',')
#     num=[int(num[i]) for i in range(len(num))] #for循环，把每个字符转成int值
#     print('排序前:',num)
#     print('排序后:',sort(n,num))