常见的排序算法

冒泡排序

def bubblesort(alist):
    """冒泡排序"""
    for i in range(len(alist)-1):
        stop = True
        # 就是挨个进行比较,大的或小的就后面放,一次确定一个最大值或者最小值
        for j in range(len(alist)-1-i):
            if alist[j] > alist[j+1]:
                alist[j],alist[j+1] = alist[j+1],alist[j]
                # 只要该循环进行了一次交换,就证明该列表还没排序好
                stop = False
        # 一次循环一次交换也没做,证明已经排序好了,直接跳出循环,你直接返回也是可以的
        if stop:
            break

选择排序

排序过程:

红色表示当前最小值,蓝色表示当前位置,黄色表示已经排序好的

def selectsort(alist):
	'''选择排序'''
    for i in range(len(alist) -1):
    	# 将当前i位置假设为最小值位置
        minindex = i
        for j in range(i+1,len(alist)):
        	# 遍历i后面的每一个元素,如果有比minindex位置上的值更小的值
        	# 就将该下标赋值给minindex
            if alist[j] < alist[minindex]:
                minindex = j 
        # 遍历完之后,就将minindex上对应的值与i位置上的值进行交换
        alist[minindex],alist[i] = alist[i],alist[minindex]
    '''
    n = len(alist)
    for i in range(n-1):
        for j in range(i+1,n):
            # 将第i=0个位置上的值与后面每一个位置相比较,
            # 只要有比i=0位置上值小的元素,就交换他们的值
            # 最后第i=0个就是最小值了,以此类推
            if alist[i] > alist[j]:
                alist[i],alist[j] = alist[j],alist[i]
    '''

插入排序

排序过程:

def insertsort(alist):
    '''插入排序'''
    n = len(alist)
    for i in range(1,n):
        # 直接从第2个元素开始进行比较,与前面的每一个进行比较
        # 相比于后面的元素,前面的元素都是排序好的
        # 也就是说第i个值只有比第i-1个值要小,才会进行下面的循环,也就是进行交换
        while i > 0 and alist[i] < alist[i-1]:
            alist[i],alist[i-1] = alist[i-1],alist[i]
            i -= 1

希尔排序

插入排序的延伸吧

def shellsort(alist):
	'''希尔排序'''
    n = len(alist)
    # 这个step看你怎么取,但是最后面还是要取到1的
    step = n//2
    while step > 0:
        for i in range(step,n):
            while i >= step and alist[i] < alist[i-step]:
                alist[i],alist[i-step] = alist[i-step],alist[i]
                i -= step
        step //= 2

快速排序

def quicksort(alist,start,end):
    '''快速排序'''
    if start >= end:
        return
    # 取当前start位置上的值为中值mid,也就是一遍排序之后,
    # 在mid右边的都比mid要大,在mid左边的都比mid要小(这是在不考虑有相同值的情况下)
    low = start
    high = end
    mid = alist[low]
    while low < high:
        # 注意下面两个循环的顺序是不能颠倒的
        # 如果你要颠倒他们的顺序,你需要将alist[high]赋值给mid
        # 就是你需要将你最开始被赋值位置的值记下,就比如下面这个循环最开始被赋值的是alist[low]

        # >=是因为列表中可能存在重复的值
        # 当high位置上数比中值mid要小的时候,就跳出循环,并将这个比mid小的值赋值给low位置
        # 反之就是high-=1
        while low < high and alist[high] >= mid:
            high -= 1
        alist[low] = alist[high]
		
		# 当low位置上数比中值mid要大的时候,就跳出循环,并将这个比mid大的值赋值给high位置
		# 反之就是low+=1
        while low < high and alist[low] < mid:
            low += 1
        alist[high] = alist[low]
    # 跳出循环就意味着low与high重合
    # 将记下的值赋值给重合位置
    alist[low] = mid
    # 再分别对重合位置左边和右边的序列进行迭代
    quicksort(alist,start,low-1)
    quicksort(alist,low+1,end)

上面这种可能要男理解一点,但是它的效率较下面这种肯定是要高效的

def qksort(l):
    if len(l) < 2:
        return l
    mid = l.pop()
    left = []
    right = []
    for i in l:
    	# 比mid大的就放左边,反之就放右边
        if i > mid:
            right.append(i)
        else:
            left.append(i)
    return qksort(left) + [mid] + qksort(right)

归并排序

排序过程:

def mergesort(alist):
    '''归并排序'''
    # 递归终止条件,拆分后的列表长度为1就终止
    # <0是为了应对传入的列表是空的情况
    if len(alist) <= 1:
        return alist
    n = len(alist)//2
    # 获取左半边列表
    left_l = mergesort(alist[:n])
    # 获取右半边列表
    right_l = mergesort(alist[n:])
    res = []
    # left和right分别是左右两个列表的下标
    left,right = 0,0
    # 左边列表和右边列表都从第0位开始比较,将跟小的一个添加到res
    # 直到有一边列表元素全部添加到res里面
    while left < len(left_l) and right < len(right_l):
        if left_l[left] < right_l[right]:
            res.append(left_l[left])
            left += 1
        else:
            res.append(right_l[right])
            right += 1
    # 只是一边列表别添加完,另一边列表肯定是还存在元素是没有添加的
    res = res + left_l[left:] + right_l[right:]
    return res