python的基本排序算法

一、冒泡排序

    原理：

每次比较两个相邻元素，将其按大小顺序排列。重复上述过程直到所有元素排列完成。由于此方法会将较小的元素一步一步的"浮"到队列前面来，因此命名为冒泡排序。

    步骤：

                1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
                2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
                3. 针对所有的元素重复以上的步骤，除了最后一个。

                4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

    代码：

import random

def get_lisy():
    l=[]
    for i in range(10):
        l.append(random.randrange(1,100))
    return l

def sort_list(list):
    for i in range(len(list)):
        for j in range(len(list)-i-1):
            # 对相邻元素进行比较排序
            if list[j]>list[j+1]:
                list[j],list[j+1]=list[j+1],list[j]
    return list

二、选择排序

    原理：

将最小元素依次取出按顺序排列

    步骤：

                1. 在序列中找出最小(大)元素，排在序列起始位置
                2. 在剩余未排序序列中找出最小(大)元素，放在已排序序列末尾
                3. 重复2，直到所有元素排列完毕

    代码：

def selection_sort(list):
    n = len(list)
    for i in range(n):
       min = i    # 标记最小值的下标
       for j in range(i+1, n):    # 未排序序列寻找最小值
           if list[j] < list[min]:
               min = j    # 有更小值时，更改下标
               list[min], list[i] = list[i], list[min]
    return list

三、插入排序

    原理：

构建有序序列，将未排序序列中的元素依次插入到有序序列相应位置处

    步骤：

                1. 序列第一个元素看作已被排序
                2. 取出下一个元素，在已排序序列中从后向前扫描
                3. 找到相应位置放入该元素
                 4. 重复2~3直到所有元素排序完成

    代码：

def insert_sort(a):  
    a_len = len(a)  
    for i in range(a_len):
        key = a[i]
        j = i - 1
        while a_len = 0 and a[j] > key:  
            a[j+1] = a[j]  
            j-=1  
        a[j+1] = key  
    return a  

四、快速排序

    原理：

使用分治法把一个序列拆成两个子序列。

    步骤：

                1. 从序列中挑出一个元素作为基准(pivot)。
                2. 比基准大的元素放在前面，比基准小的元素放在后面
                3.按上述方法递归的将前后两个子序列排序

    代码：

        普通版

def quick_sort(list):
    less = []
    pivotList = []
    more = []
    # 递归出口
    if len(list) <= 1:
        return list
    else:
        # 将第一个值做为基准
        pivot = list[0]
        for i in list:
            # 将比急转小的值放到less数列
            if i < pivot:
                less.append(i)
            # 将比基准打的值放到more数列
            elif i > pivot:
                more.append(i)
            # 将和基准相同的值保存在基准数列
            else:
                pivotList.append(i)
        # 对less数列和more数列继续进行排序
        less = quick_sort(less)
        more = quick_sort(more)
        return less + pivotList + more

        高手版

def qsort(arr):
    if len(arr) <= 1:
        return arr
    else:
        pivot = arr[0]
        return qsort([x for x in arr[1:] if x < pivot]) + \
               [pivot] + \
               qsort([x for x in arr[1:] if x >= pivot])

        大触版

qs = lambda xs : ( (len(xs) <= 1 and [xs]) or [ qs( [x for x in xs[1:] if x < xs[0]] ) + [xs[0]] + qs( [x for x in xs[1:] if x >= xs[0]] ) ] )[0]

五、归并排序

    原理：

将两个已排序的序列合并成一个序列

    步骤：

                1. 序列拆分，直到每个序列只包含一个元素，单元素序列可看作已排序序列
                2. 相邻两个序列合并，每个序列包含两个元素
                3. 重复2，直到所有元素排序完毕

    代码：

# 拆分
def merge_sort(list):
    # 认为长度不大于1的数列是有序的,设置递归出口
    if len(list) <= 1:
        return list
    # 二分列表
    middle = len(list) // 2
    # 递归调用序列拆分方法
    left = merge_sort(list[:middle])
    right = merge_sort(list[middle:])
    # 最后一次合并
    return merge(left, right)
# 合并
def merge(left, right):
    l,r=0,0
    result=[]
    while l<len(left) and r<len(right):
        if left[l] <right[r]:
            result.append(left[l])
            l+=1
        else:
            result.append(right[r])
            r +=1
        reslut +=left[l:]
        result+=right[r:]                
    return result