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)