冒泡、选择、插入、归并、快排

几种排序算法的理解？

冒泡排序：

扫描两趟，遇见不等的交换，第一趟扫描过后，最后一个必然是最大值。

特点，稳定，o（n^2），空间o(1)，in-space算法，改进方向有：标记最后一个发生交换的位置，在该趟走到这里得时候就可以结束。如果某一趟这个位置前没有发生交换，则已经完成了排序

插入排序：

插入排序就像打麻将，一个个放入的。以第一个数为标杆，第二个数小于值就往前，大于之都往后，则前两个数有序了；

之后再一个个地插入到有序序列的特定位置，运气好的时候，如全逆序，就爽歪歪了！

特点：稳定，inspace，时间复杂度 o(n^2)

def insert_sort(list):
    if len(list)<=1:
        return list
    for i in range(1,len(list)):
        for j in range(0,i):
            if list[j]>list[i]:
                list.insert(j,list.pop(i))
                break
    return list

选择排序：

选择排序选择的是什么呢？选择的是最小值，把最小值与第一位的元素互换；接着把后[n-1：]个元素继续进行这种操作。

特点：不稳定！ 不稳定！，时间上还是N^2空间上 是o(1), inspace

def select(list):
    x_min=float('inf')
    for i in range(len(list)):
        for j in range(i,len(list)):
            if list[j]<xmin:
                xmin=j
        list[i],list[xmin]=list[xmin],list[i]
    return list

归并排序：重点！！！稳定 nlogn，耗费空间O(n)

递归的思想，将一列数划分称为两部分，并且递归地分下去，如果只剩两个数，就左右互换位置。一般需要写两个函数，

一个是merge_sort函数，一个是merge函数。

特点：稳定，时间复杂度nlog（n）空间复杂度o（1），out-space！

代码：先写归后写并即可！！

def sort_merge(left,right):
    i=0
    j=0
    res=[]
    while i<len(left) and j<len(right):
        if left[i]<=right[j]:
            res.append(left[i])
        else:
            res.append(right[j])
        i+=1
        j+=1
    res=res+ (left[i:] or right[j:])
    return res

def sort(list):
    if len(list)<=1:
        return list
    mid = len(list)//2
    left=sort(list[:mid])
    right=sort(list[mid:])
    res=merge(left,right)
return res

 

 

快速排序：重点！！ 不稳定，nlogn，空间消耗小，o(n)

快速排序的思想：

选取一个轴点，一般可以选取第一个点，扫描全列，把小于轴点的放左边，大于轴点的放右边，也用到了分治的思想。

特点，不稳定，nlogn，空间消耗小。

def fast_sort(list):
    if len(list)<=1:
        return list
    pivot = list[0]
    left = fast_sort([lo for lo in pivot[1:] if lo<pivot])
    right = fast_sort([hi for hi in pivot[1:] if hi>=pivot])
    return left + [pivot] +right