1. def quick_sort(alist,start,end):
2. """
3.     :param alist:
4.     :return:alist.sort
5.     快速排序首先要选择一个基准，将其他数据与这个基准比较，比它大的放右边，比它小的放左边，循环这个过程，完成排序
6.     定义两个指针，一个low一个high,
7.     开始是high先做比较，如果high对应的元素比基准大就不懂，high--，如果比基准小，则与low对应的元素交换，然后low++
8.     直到low==high说明一趟快速排序已经完成，再将基准添加到序列中
9.     上面已经完成一次快速排序，再将左序列和右序列进行递归，注意设置一个出口，即可完成整个遍历
10.     以alist = [5,1,3,2,8,7,6,4]为例
11.     以alist = [4,1,3,2,8,7,6,4]为例
12.     """
13. # 递归的出口
14. if start >= end:
15. return
16.     mid = alist[start]  # 定义基准 5
17.     low = start  # 左指针
18.     high = end  # 右指针 7
19. # 判断high是不是大于mid,大于的话就不用交换，之间high--，直到小于的时候进行交换
20. while low <high:
21. while alist[high] >= mid and high > low:  #7>0
22.             high -=1
23.         alist[low] = alist[high]
24. #判断low是不是小于mid, 小于的话就不用交换，之间low++，直到大于的时候进行交换
25. while alist[low] < mid and high>low:
26.             low += 1
27.         alist[high] = alist[low]
28.     alist[low] = mid
29.     quick_sort(alist,0,low-1)
30.     quick_sort(alist,low+1,end)
31. return alist

1. def Merge_sort(alist):
2. """
3.     主要思想就是分治法，先拆分再合并
4.     整个框架是递归算法，既包括拆解成一个一个的列表，也包列表的缝合
5.     以为[5,1,3,2,8,7,6,4]例，拆解成[5],[1],[3],[2],[8],[7],[6],[4]
6.     第一次合并成[1,5],[2,3],[7,8],[4,6]
7.     第二次合并成[1,2,3,5],[4,6,7,8]
8.     第三次合并成[1,2,3,4,5,6,7,8]
9.     :param alist:
10.     :return: alist.sort
11.     """
12.     n = len(alist)
13.     mid = n //2
14. if n <= 1:
15. return alist
16.     left_list = Merge_sort(alist[0:mid])
17.     right_list = Merge_sort(alist[mid::])
18.     left_p = 0 # 定义左指针
19.     right_p = 0 # 定义右指针
20.     result_list =[]
21. while left_p < len(left_list) and right_p < len(right_list):
22. if left_list[left_p] < right_list[right_p]:
23.             result_list.append(left_list[left_p])
24.             left_p += 1
25. else:
26.             result_list.append(right_list[right_p])
27.             right_p += 1
28.     result_list.extend(left_list[left_p::])
29.     result_list.extend(right_list[right_p::])
30. 
31. return result_list