十大排序算法代码实现

目录

冒泡排序：

选择排序：

插入排序：

归并排序：

桶排序：

计数排序：

基数排序：

快速排序：

堆排序：

希尔排序：

---

小生花费些许时间将这十种基本排序算法都搞明白了，在次将python版本的代码分享给大家，如有需要，欢迎借鉴。^_^

冒泡排序：

def bubble_sort(nums):
    n=len(nums)
    for i in range(n):
        max=0
        for j in range(n-i):
            if nums[j]>nums[max]:
                max=j
        nums[max],nums[j]=nums[j],nums[max]

选择排序：

def select_sort(nums):
    n=len(nums)
    for i in range(n):
        for j in range(i,n):
            if nums[i]>nums[j]:
                nums[i], nums[j] = nums[j], nums[i]

插入排序：

def insert_sort(nums):
    n=len(nums)
    for i in range(1,n):
        for j in range(i,0,-1):
            if nums[j]<nums[j-1]:
                nums[j-1],nums[j]=nums[j],nums[j-1]
            else:
                break

归并排序：

def mergy(left,right):
    r=0
    l=0
    temp=[]
    while l<len(left) and r<len(right):
        if left[l]>right[r]:
            temp.append(right[r])
            r+=1
        else:
            temp.append(left[l])
            l+=1
    temp+=left[l:]
    temp+=right[r:]
    return temp
def mergy_sort(lists):
    if len(lists)<2:
        return lists
    mid=len(lists)//2
    left=mergy_sort(lists[:mid])
    right=mergy_sort(lists[mid:])
    return mergy(left,right)

桶排序：

def bucket_sort(nums):
    n=len(nums)
    mx=max(nums)
    mn=min(nums)
    size_bucket=(mx-mn)//n+1 #每个桶的容量
    num_bucket=(mx-mn)//size_bucket+1 #桶的数量
    bucket=[[] for _ in range(num_bucket)]
    for i in range(n):
        index_bucket=(nums[i]-mn)//size_bucket
        bucket[index_bucket].append(nums[i])
    for i in range(num_bucket):
        select_sort(bucket[i])
    index_nums=0
    for i in range(num_bucket):
        for j in range(len(bucket[i])):
            nums[index_nums]=bucket[i][j]
            index_nums+=1
   

计数排序：

def count_sort(nums):#必须是正整数
    n=len(nums)
    cntlen=max(nums)+1
    cnt=[0]*cntlen
    for x in nums:
        cnt[x]+=1
    index=0
    for i in range(cntlen):
        while cnt[i]:
            nums[index]=i
            index+=1
            cnt[i]-=1

基数排序：

def radix_sort(nums):
    base=1
    mx=max(nums)
    while base<mx:
        bucket=[[] for _ in range(10)]
        for x in nums:
            bucket_index=x//base%10
            bucket[bucket_index].append(x)
        index=0
        for i in range(10):
            for j in range(len(bucket[i])):
                nums[index]=bucket[i][j]
                index+=1
        base*=10

快速排序：

def qsortPivot(nums,start,end):
    pivot=start
    t=start+1
    for i in range(start+1,end+1):
        if nums[i]<=nums[pivot]:
            nums[i],nums[t]=nums[t],nums[i]
            t+=1
    nums[pivot],nums[t-1]=nums[t-1],nums[pivot]
    pivot=t-1
    return pivot
def qsort(nums,start,end):
    if start>=end:
        return
    pivot=qsortPivot(nums,start,end)
    qsort(nums,start,pivot-1)
    qsort(nums,pivot+1,end)

堆排序：

def heapadjust(nums,start,end):
        temp=nums[start]
        i=2*start+1
        while i<=end:
            if i<end and nums[i]<nums[i+1]:
                i+=1
            if nums[i]>temp:
                nums[start],nums[i]=nums[i],temp
                start=i
            else:
                break
            i=i*2+1  #子->父 i=(i-1)//2 父->子 i=2*i+1(or 2)
def heap_sort(nums):
    n=len(nums)
    for i in range((n-1-1)//2,-1,-1):
        heapadjust(nums,i,n-1)
    for i in range(n):
        nums[0],nums[n-1-i]=nums[n-1-i],nums[0]
        heapadjust(nums,0,n-2-i)

希尔排序：

def shell_sort(nums):
    n=len(nums)
    t=n
    while t>1:
        t//=2
        for i in range(n-t):
            while i>=0:
                if nums[i+t] < nums[i]:
                    nums[i+t],nums[i]=nums[i],nums[i+t]
                    i-=t
                else:
                    break