冒泡排序

效率：O(n2)

原理：

1. 比较相邻的元素，如果第一个比第二个大，就交换他们两个；

2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。做完以后，最后的元素会是最大的数，这里可以理解为走了一趟；

3. 针对所有的元素重复以上的步骤，除了最后一个；

4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较，最后数列就是从大到小依次排列；

def bubble_sort(data):    """    冒泡排序    :param data:     :return:     """    for i in range(len(data)-1):  # 趟数        for j in range(len(data)-i-1):  # 遍历数据，依次交换            if data[j]>data[j+1]:  # 当较大数在前面                data[j],data[j+1]=data[j+1],data[j] #交换两个数的位置if __name__=='__main__':    import random    data_list=list(range(30))    random.shuffle(data_list)    print("pre:",data_list)    bubble_sort(data_list)    print("after:",data_list)#结果：#pre: [22, 11, 19, 16, 12, 18, 20, 28, 27, 4, 21, 10, 9, 7, 1, 6, 5, 29, 8, 0, 17, 26, 13, 14, 15, 24, 25, 23, 3, 2]#after: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]

选择排序

效率：O(n2)

原理：

1. 每一次从待排序的列表中选出一个元素，并将其与其他数依次比较，若列表中的某个数比选中的数小，则交换位置，把所有数比较完毕，则会选出最小的数，将其放在最左边（这一过程称为一趟）；

2. 重复以上步骤，直到全部待排序的数据元素排完；

def select_sort(data):    """    选择排序    :param data: 待排序的数据列表    :return:     """    for i in range(len(data)-1):  #趟数        min_index=i  # 记录i趟开始最小的数的索引，我们从最左边开始        for j in range(i+1,len(data)): # 每一次趟需要循环的次数            if data[j] < data[min_index]:  # 当数列中的某一个数比开始的数要小时候，更新最小值索引位置                min_index=j        data[i],data[min_index]=data[min_index],data[i]  # 一趟走完，交换最小值的位置，第一趟最小if __name__=='__main__':    import random    data_list=list(range(30))    random.shuffle(data_list)  # 打乱列表数据    print("pre:",data_list)    select_sort(data_list)    print("after:",data_list)#结果：#pre: [20, 11, 22, 0, 18, 21, 14, 19, 7, 23, 27, 29, 24, 4, 17, 15, 5, 10, 26, 13, 25, 1, 8, 16, 3, 9, 2, 28, 12, 6]#after: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]

插入排序

效率：O(n2)

原理：

1. 以从小到大排序为例，元素0为第一个元素，插入排序是从元素1开始，尽可能插到前面。

2. 插入时分插入位置和试探位置，元素i的初始插入位置为i，试探位置为i-1，在插入元素i时，依次与i-1,i-2······元素比较，如果被试探位置的元素比插入元素大，那么被试探元素后移一位，元素i插入位置前移1位，直到被试探元素小于插入元素或者插入元素位于第一位。

3. 重复上述步骤，最后完成排序；

def insert_sort(data):    """    插入排序    :param data: 待排序的数据列表    :return:     """    for i in range(1, len(data)): # 无序区域数据        tmp = data[i] # 第i次插入的基准数        for j in range(i, -1, -1):            if tmp < data[j - 1]:  # j为当前位置，试探j-1位置                data[j] = data[j - 1]  #  移动当前位置            else:  # 位置确定为j                break        data[j] = tmp  # 将当前位置数还原if __name__=='__main__':    import random    data_list=list(range(30))    random.shuffle(data_list)  # 打乱列表数据    print("pre:",data_list)    insert_sort(data_list)    print("after:",data_list)#结果：#pre: [7, 17, 10, 16, 23, 24, 13, 11, 2, 5, 15, 29, 27, 18, 4, 19, 1, 9, 3, 21, 0, 14, 12, 25, 22, 28, 20, 6, 26, 8]#after: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]

快速排序

效率:平均O(nlogn)

原理：

1. 从数列中随机挑选出一个数作为基数；

2. 重新排列数列，使得比基数小的元素在左边，比基数大元素在右边，相等的元素放左边或者右边都可以，最后使得该基数在处于数列中间位置，这个称为分区操作；

3. 递归上述操作，完成排序。

#!/usr/bin/env python3#_*_ coding:utf-8 _*_#Author:wddef quick_sort(data,left,right):    """    快速排序    :param data: 待排序的数据列表    :param left: 基准数左边元素的索引    :param right: 基准数右边元素的索引    :return:     """    if left < right:        mid = partition(data,left,right)  # 分区操作,mid代表基数所在的索引        quick_sort(data,left,mid-1)   # 对基准数前面进行排序        quick_sort(data,mid+1,right)  # 对基准数后面进行排序def partition(data,left,right):    tmp=data[left]  # 随机选择的基准数,从最左边开始选    while left < right:        while left < right and data[right] >= tmp:  # 右边的数比基准数大            right-=1  # 保留该数，然后索引指针往左移动        data[left]=data[right]   # 否则此时右边数比基数小，则将该数放到基准位置        while left < right and data[left] <= tmp: # 右边的数比基准数小            left+=1  # 此时保持该数位置不动，索引指针往前移动        data[right]=data[left]  # 否则此时左边的数比基数大，则将该数放到右边    data[left] = tmp  # 最后将基准数量放回中间    return left  # 返回基准数位置if __name__=='__main__':    data_list=[1,3,21,6,50,33,34,58,66]    quick_sort(data_list,0,len(data_list)-1)    print(data_list)###结果：[1, 3, 6, 21, 33, 34, 50, 58, 66]

堆排序

堆定义：本质是一个完全二叉树，如果根节点的值是所有节点的最小值称为小根堆，如果根节点的值是所有节点的最大值，称为大根堆。

效率：O(nlogn)

原理：

1. 将待排序数据列表建立成堆结构(建立堆)；

2. 通过上浮(shift_up)或下沉(shift_down)等操作得到堆顶元素为最大元素（已大根堆为例）；

3. 去掉堆顶元素，将最后的一个元素放到堆顶，重新调整堆，再次使得堆顶元素为最大元素（相比第一次为第二大元素）；

4. 重复3操作，直到堆为空，最后完成排序；

def sift(data, low, high):    """    调整堆函数    :param data: 带排序的数据列表    :param low: 值较小的节点的位置，可以理解为是根节点    :param high:值较大的节点的位置     :return:     """    i = low    j = 2 * i  # 父节点i所对应的左孩子    tmp = data[i]  # 最较小节点的值    while j <= high:        if j < high and data[j] < data[j + 1]:  # 如果右孩子比左孩子大则把j指向右节点            j += 1  # 指向右节点        if tmp < data[j]:  # 如果此时位置较小的节点值比该节点值小，则将该节点上浮最为新的父节点，并调整该节点双亲            data[i] = data[j]            i = j  # 调整该节点的双亲的位置            j = 2 * i        else:            break  # 否则代表本次调整已经完成，并且节点i已经无值    data[i] = tmp  # 最后将被调整节点的值放到i节点上（空出的位置）def heap_sort(data):    """    堆排序    :param data: 待排序的数据列表    :return:     """    n = len(data)    for i in range(n // 2 - 1, -1, -1):        sift(data, i, n - 1)    # 构建堆    for i in range(n - 1, -1, -1):  # 调整过程，从最后一个元素开始交换        data[0], data[i] = data[i], data[0]  # 交换        sift(data, 0, i - 1)  # 开始调整if __name__ == '__main__':    import random    data_list = [1, 3, 21, 6, 50, 33, 34, 58, 66]    random.shuffle(data_list)  # 打乱列表数据    print("pre:", data_list)    heap_sort(data_list)    print("after:", data_list)#结果：#pre: [66, 3, 58, 34, 1, 33, 21, 6, 50]#after: [1, 3, 6, 21, 33, 34, 50, 58, 66]

归并排序

效率：O(nlogn)

空间复杂度：O(n)

原理：

1. 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列；

2. 设定两个指针，最初位置分别为两个已经排序序列的起始位置；

3. 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置；

4. 重复步骤3直到某一指针达到序列尾；

5. 将另一序列剩下的所有元素直接复制到合并序列尾。

def merge(data, low, mid, high):    """    合并函数    :param data: 数据列表    :param low: 列表开头位置    :param mid: 分割中间位置    :param high: 列表最后位置    :return:     """    i = low  # 第一个指针    j = mid + 1  # 第二个指针    tmp = []  # 临时存放的列表    while i <= mid and j <= high:  # 分割的列表当两边都有数才进行        if data[i] < data[j]:            tmp.append(data[i])            i += 1  # 低的指针往右移动        else:            tmp.append(data[j])  # 右边大，存右边的数            j += 1  # 同时指针右移动    while i <= mid:  # 左边分割有剩下        tmp.append(data[i])        i += 1    while j <= high:  # 右边有剩下        tmp.append(data[j])        j += 1    data[low:high + 1] = tmp  # 最后将tmp中的数写入到原来的列表中def merge_sort(data, low, high):    """    归并排序    :param data: 待排序的数据列表    :param low: 数据列表开始位置    :param high: 数据列表结束位置    :return:     """    if low < high:  # 至少有两个元素才进行        mid = (low + high) // 2  # 分割        merge_sort(data, low, mid)  # 递归分割上一部分        merge_sort(data, mid + 1, high)  # 递归分割下一部分        merge(data, low, mid, high)  # 合并if __name__ == '__main__':    import random   data_list = [1, 3, 21, 6, 50, 33, 34, 58, 66]    random.shuffle(data_list)  # 打乱列表数据    print("pre:", data_list)    merge_sort(data_list, 0, len(data_list) - 1)    print("after:", data_list)#结果：#pre: [21, 3, 33, 58, 34, 66, 1, 6, 50]#after: [1, 3, 6, 21, 33, 34, 50, 58, 66]

希尔排序

效率：与增量有关，O(n1+￡)其中<0￡<1,如增量为2k-1 复杂度为O(n3/2)

原理：

1. 先取一个小于n的整数d1作为第一个增量，把文件的全部记录分组。所有距离为d1的倍数的记录放在同一个组中。

2. 先在各组内进行直接插入排序；

3. 取第二个增量d2<d1重复上述的分组和排序，直至所取的增量 =1( < …<d2<d1)，即所有记录放在同一组中进行直接插入排序为止。

def shell_sort(data):    """    希尔排序    :param data:待排序的数据列表     :return:     """    d1 = len(data) // 2  # 设置分割大小为d1，    while d1 > 0:        for i in range(d1, len(data)):            tmp = data[i]  # 当前分割元素位置            j = i - d1  # 上一个分割元素位置            while j >= 0 and tmp < data[j]:  # 上一个元素分割位置比当前分割位置要大，则需要调整位置                data[j + d1] = data[j]  # 后移动当前分割元素位置                j -= d1  # 往前移d1            data[j + d1] = tmp        d1 //= 2  # 继续分割if __name__ == '__main__':    import random    data_list = [1, 3, 21, 6, 50, 33, 34, 58, 66]    random.shuffle(data_list)  # 打乱列表数据    print("pre:", data_list)    shell_sort(data_list)    print("after:", data_list)#结果：#pre: [3, 66, 58, 34, 33, 50, 6, 21, 1]#after: [1, 3, 6, 21, 33, 34, 50, 58, 66]