python 基本排序算法

 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 # @Time    : 2019/9/15 下午5:06
 # @Author  : lb
 # @File    : sort.py
 # @Desc    :
 import numpy as np
 arr = list(np.random.randint(20, size=10))
 #arr = [1, 11, 1, 2, 43, 11]
 def buble_sort(a):
     """
     冒泡排序: 两两比较，每次循环都找到最大的一个放到最右侧
     :param a:
     :return:
     """
     if len(a) < 2:
         return a
     for i in xrange(len(a)):
         for j in xrange(len(a)-i-1):
             if a[j] > a[j+1]:
                 a[j], a[j+1] = a[j+1], a[j]
     return a

 def sel_sort(a):
     """
     选择排序：每次循环都找到剩余的元素中最大的一个，与当前外层循环的位置进行交换
     :param a:
     :return:
     """
     if len(a) < 2:
         return a
     for i in xrange(len(a)-1):
         tmp = a[i]
         pos = i
         for j in xrange(i+1, len(a)):
             if a[j] < tmp:
                 tmp = a[j]
                 pos = j
         a[i], a[pos] = a[pos], a[i]
     return a

 def ins_sort(a):
     """
     插入排序：每次对已经排好的有序数列进行轮训，如果大于监哨，则当前的元素右移n（直接排序时：n=1, 希尔排序时：n=gap）个单位
     :param a:
     :return:
     """
     if len(a) < 2:
         return a
     for i in xrange(1, len(a)):
         tmp = a[i]
         j = i
         while j - 1 >= 0 and a[j-1] > tmp:
             a[j] = a[j-1]
             j -= 1
         a[j] = tmp

     return a

 def shell_sort(a):
     """
     希尔排序，改进的插入排序，一次移动gap个元素
     :param a:
     :return:
     """
     if len(a) < 2:
         return a
     gap = len(a) // 2
     while gap > 0:
         for i in xrange(gap, len(a)):
             tmp = a[i]
             j = i
             while j >= gap and a[j-gap] > tmp:
                 a[j] = a[j-gap]
                 j -= gap
             a[j] = tmp
         gap //= 2
     return a

 def quick_sort(a):
     """
     快速排序：分治原则，设置标准值mid，小于mid的放左侧，大于mid的放右侧，递归实现
     :param a:
     :return:
     """
     if len(a) < 2:
         return a
     L, R = [], []
     mid = a[len(a) // 2]
     a.remove(mid)
     for i in a:
         if i > mid:
             R.append(i)
         else:
             L.append(i)
     return quick_sort(L) + [mid] + quick_sort(R)

 def merge_sort(a):
     """
     归并排序，分治原则，将一路归并逐渐抽象到二路归并
     :param arr:
     :return:
     """
     def two_merge(L,R):
         index_L = index_R = 0
         ret = []
         while index_L < len(L) and index_R < len(R):
             if L[index_L] < R[index_R]:
                 ret.append(L[index_L])
                 index_L += 1
             else:
                 ret.append(R[index_R])
                 index_R += 1
         if index_L == len(L):
             ret.extend(R[index_R:])
         else:
             ret.extend(L[index_L:])
         return ret
     if len(a) < 2:
         return a
     mid = len(a) // 2
     L = merge_sort(a[:mid])
     R = merge_sort(a[mid:])
     return two_merge(L, R)