常见排序算法及python实现

1、冒泡排序

冒泡排序的思想就是相邻元素两两比较，每一轮遍历把当前最大元素放到最后

def bubble_sort(seq):
    length = len(seq)  #获取seq长度
    for i in range(length):
        flag = True   #判断本轮seq是否发生改变的标志位
        for j in range(0, length-i-1):
            if seq[j] > seq[j+1]:  #相邻元素两两比较，较大的元素置于后面
                seq[j], seq[j+1] = seq[j+1], seq[j]
                flag = False   #确认本轮seq发生改变
        if flag:
            break  #若本轮未改变，则排序完成
    return seq

冒泡排序的平均时间复杂度为O()，空间复杂度为O(1)

 

2、直接插入排序

直接插入排序的思想是把每一个元素与之前所有的元素进行比较，每一轮都能保证当前元素之前的部分是有序的

def insert_sort(seq):
    length = len(seq)   #获取seq长度
    for i in range(length-1):
        j = i+1
        while j > 0:
            if seq[j] < seq[j-1]: #比较相邻位置j,j-1的大小，进行排序
                seq[j-1], seq[j] = seq[j], seq[j-1]
            j -= 1 #j减1
    return seq

直接插入排序的平均时间复杂度为O()，空间复杂度为O(1)

 

3、希尔排序

希尔排序（缩小增量排序）的思想是先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录"基本有序"时，再对全体记录进行依次直接插入排序

def shell_sort(seq):
    length = len(seq)  #取seq长度
    gap = length // 2  #初始间隔
    while gap > 0:
        for i in range(0, gap): 
            for j in range(i, length-gap, gap):  #以i位置元素作为起始点，gap为间隔，取元素，
                while j >= 0 and seq[j] > seq[j+gap]:  #插入排序
                    seq[j], seq[j+gap] = seq[j+gap], seq[j]
                    j -= gap
        gap = gap // 2   #缩小间隔

    return seq

希尔排序的平均时间复杂度为O()，空间复杂度为O(1)

 

4、直接选择排序

选择排序，每次选择当前序列的最小值，将其与当前序列的第一个元素交换位置，每迭代一次，当前序列长度减一。迭代结束，即可得到有序序列。

def select_sort(seq):
    length = len(seq)
    for i in range(0, length-1):
        temp = i   #i为当前序列的第一个元素
        for j in range(i, length):
            if seq[j] < seq[temp]:
                temp = j
        seq[i], seq[temp] = seq[temp], seq[i]  #交换位置
    return seq

直接选择排序的平均时间复杂度为O()，空间复杂度为O(1)

 

5、快速排序

快速排序的思想是分治。对于一个序列，首先从中选取一个数作为标准，小于这个数的值就被放在左边，大于这个数的值就被放在右边。然后，继续对左右两边进行快速排序。

快速排序在排序之前要打乱数组的顺序，使之随机排序。这对预测算法的运行时间特别重要，同时也是为了避免最坏情况的出现（第一次切分元素是最小值，第二次切分元素是第二小值，……）。

import random
def quicksort(seq):
    random.shuffle(seq)
    if len(seq) < 2:
        return seq
    else:
        left = []
        right = []
        base = []
        for item in seq:
            if item < seq[0]:
                left.append(item)
            elif item == seq[0]:
                base.append(item)
            else:
                right.append(item)
    return quicksort(left) + base + quicksort(right)

快速排序的平均时间复杂度为O()，空间复杂度为O()

 

6、归并排序

归并排序的思想也是分治，但是与快速排序不同，快速排序每一次都会选择一个标准数对子序列进行粗排，然后再递归返回。归并把待排序序列分为若干个子序列，对子序列进行排序。然后再把有序子序列合并为整体有序序列。

def merge(a, b):  #元素逐个比较排序
    i, j = 0, 0
    c = []
    while i < len(a) and j < len(b):  
        if a[i] < b[j]:
            c.append(a[i])
            i += 1
        else:
            c.append(b[j])
            j += 1
    if i == len(a):
        for item in b[j:]:
            c.append(item)
    else:
        for item in a[i:]:
            c.append(item)
    return c


def merge_sort(seq):
    if len(seq) < 2:
        return seq
    mid = len(seq) // 2
    left = merge_sort(seq[0:mid])  #左支
    right = merge_sort(seq[mid:len(seq)])  #右支
    return merge(left, right)

归并排序的平局时间复杂度为O()，空间复杂度为O(n)