老卫带你学---必须手撕的十大排序算法（干货！！！附python代码）

如果老卫的博客对你有帮助，记得点赞关注哈！大家的支持是老卫更新的动力！！

python代码：

插入排序：
插入排序就是将数组中的元素，逐一与已排好序的数据进行比较，将其放入合适的位置。

def insert_sort(nums):
    for i in range(1, len(nums)):
        tempt = nums[i]
        j = i - 1
        while (j >= 0 and nums[j] > tempt):
            nums[j + 1] = nums[j]
            j =j-1
        nums[j + 1] = tempt

递归快排：
快排就是在数组的元素中找到一个虚拟的中间值，并按此中间值将所有打算排序的数据分为两部分（小于中间值的数据放在左边，大于中间值的数据放在右边）。再以同样的方式分别处理左右两边的数据。

def quickSort(nums):
    if(len(nums)<=1):
        return nums
    base=nums.pop()
    leftnums=[]
    rightnums=[]
    for x in nums:
        if(x<=base):
            leftnums.append(x)
        else:
            rightnums.append(x)
    return quickSort(leftnums)+[base]+quickSort(rightnums)

非递归快排

def quick_sort_other(array, l, r):
    # '''
    # 算法导论里的思想
    # i表示[l,i]都比pivot小
    # j依次遍历元素
    # '''
    if l >= r:
        return
    stack = [l,r]
    while stack:
        low = stack.pop(0)
        high = stack.pop(0)
        if high <= low:
            continue
        pivot = array[high]
        i = low - 1 ###初始值是-1
        for j in range(low,high+1):
            ###如果小于pivot， 则交换，交换的目的是保证[l,i]都比pivot小
            if array[j] <= pivot:
                i += 1
                array[i],array[j]=array[j],array[i]
        stack.extend([low, i-1, i + 1, high])
    return array

冒泡排序：
冒泡排序就是将数组中的元素，从第一个元素开始比较相邻元素的大小，若大小顺序有误，则对调后再进行下一个元素的比较。

def bubbleSort(nums):
    n=len(nums)
    for i in range(n-1):
        for j in range(n-i-1):
            if nums[j]>nums[j+1]:
                nums[j],nums[j+1]=nums[j+1],nums[j]
    return nums

归并排序：
归并排序就是将数组中的元素，两两归并并排序，得到新的多个数列；再两两数列进行合并，依此类推。

def mergeSort(nums):
    n=len(nums)
    if(n<=1):
        return nums
    mid=n//2
    leftnums=mergeSort(nums[:mid])
    rightnums=mergeSort(nums[mid:])
    return merge_s(leftnums,rightnums)
def merge_s(leftnums,rightnums):
    l,r=0,0
    result=[]
    while(l<len(leftnums) and r<len(rightnums)):
        if(leftnums[l]<rightnums[r]):
            result.append(leftnums[l])
            l+=1
        else:
            result.append(rightnums[r])
            r+=1
    result.extend(leftnums[l:])
    result.extend(rightnums[r:])
    return result

直接选择排序：
选择排序就是将数组中的元素，从未排序的数列中取出最小值，加入到另一个数列中。

def selectSort(nums):
    n=len(nums)
    for i in range(n-1):
        min_value=nums[i]
        min_index=i
        for index in range(i+1,n):
            if(min_value>nums[index]):
                min_value=nums[index]
                min_index=index
        if(min_index!=i):
            nums[i],nums[min_index]=nums[min_index],nums[i]
    return nums

希尔排序：
希尔排序就是将数组中的元素，按照一定间隔分成多个小区间，再对每个小区间采用插入排序，最后慢慢缩短间隔的距离。

def shell_sort(nums:list):
    n=len(nums)
    jump=floor(n/2)
    while(jump!=0):
        for i in range(jump,n):
            tmp=nums[i]
            j=i-jump
            while(j>=0 and nums[j]>tmp):
                nums[j+jump]=nums[j]
                j=j-jump
            nums[jump+j]=tmp
        jump=floor(jump/2)
    return nums

桶排序：

def bucketSort(nums):
    max_num=max(nums)
    min_num=min(nums)
    bucket=[0 for _ in range(max_num-min_num+1)]
    for x in nums:
        bucket[x-min_num]+=1
    n=0
    current=min_num
    for i in bucket:
        while(i>0):
            nums[n]=current
            i-=1
            n+=1
        current+=1
    return nums

基数排序：

def RadixSort(list,d):
    for k in range(d):
        s=[[] for _ in range(10)]
        for i in list:
            s[int(i/(10**k)%10)].append(i)
        list=[j for i in s for j in i]
    return list

堆排序：

def heapify(heap):
    n=len(heap)
    for i in reversed(range(n//2)):
        siftup(heap,i)
    return heap

def heapPush(heap,item):
    heap.append(item)
    siftdown(heap,0,len(heap)-1)
    return heap

def heappop(heap):
    lastelt = heap.pop()
    if heap:
        returnitem = heap[0]
        heap[0] = lastelt
        siftup(heap, 0)
        return returnitem
    return lastelt

def siftdown(heap,startpos,pos):
    newitem=heap[pos]
    while(pos>startpos):
        parentpos=(pos-1)>>1
        parent=heap[parentpos]
        if(newitem<parent):
            heap[pos]=parent
            pos=parentpos
            continue
        break
    heap[pos]=newitem


def siftup(heap, pos):
    endpos = len(heap)
    startpos = pos
    newitem = heap[pos]
    childpos = 2*pos + 1
    while childpos < endpos:
        rightpos = childpos + 1
        if rightpos < endpos and not heap[childpos] < heap[rightpos]:
            childpos = rightpos
        # Move the smaller child up.
        heap[pos] = heap[childpos]
        pos = childpos
        childpos = 2*pos + 1
    heap[pos] = newitem
    siftdown(heap, startpos, pos)

def heapSort(heap):
    result=[]
    for i in range(len(heap)):
        pop_item=heappop(heap)
        print(pop_item)
        result.append(pop_item)
    return result

计数排序：

def count_sort(nums:list):
    max_val=max(nums)
    s=[0 for _ in range(max_val+1)]
    for x in nums:
        s[x]+=1
    n=0
    for i in range(len(s)):
        while(s[i]>0):
            nums[n]=i
            n+=1
            s[i]-=1
    return nums