排序算法总结对比

最新推荐文章于 2022-04-02 21:33:00 发布

XSD995366159

最新推荐文章于 2022-04-02 21:33:00 发布

阅读量154

点赞数

分类专栏：排序算法

本文链接：https://blog.csdn.net/qq_22070551/article/details/102673591

版权

排序算法专栏收录该内容

1 篇文章 0 订阅

订阅专栏

本文旨在记录分析经典的排序算法，如有错误欢迎提醒，代码由个人编写或者转载其它博客。

1.插入排序法

（1）基本原理，那后续的数值向前面的数字进行比较，当大于前一个值但小于后一个值时插入到两数之间的位置。图解如下图所示：
在这里插入图片描述
**(2)代码：

def insertionsort(arr,n):
   for i in range(1,n):
       key=arr[i]
       j=i-1
       while j>=0 and key<arr[j]:
           arr[j+1]=arr[j] #比key值小的元素立即向后移动一位
           j-=1
       arr[j+1]=key #当发现比key值大的元素时，停止，并且将当前位置赋值为key，就是插入位置
   return arr
arr=[3,2,23,8,19,49,20]
n=len(arr)-1
a=insertionsort(arr,n)
print(a)

2. 快速排序

(1)基本原理：
每次找一个基准元素，让小于基准的数放在基准的左侧，大于基准的数放在基准右侧。（找基准的方式可以是每次都去序列的第一个或者最后一个元素）在代码实现时把握“分治法”，结合递归的思想即可。
基本方法： 首先，选择序列的第一个元素作为基准key，设定两个标志位索引：low=0，high=len(arr)-1。比较arr[high]与arr[low](key)的大小，如果“>”那么说明arr[high]是应该放在基准的右侧的，所以将high减1，high的位置移动到前一位；如果“<”说明arr[hign]应该在基准的左侧，所以将arr[high]的值与arr[low]的交换。
交换后，再用arr[low]（key）与arr[i]比较，如果arr[low]<arr[i]，那么low加1（就是key的值变为arr[low+1]），如果arr[low]>arr[i]那么交换两元素的位置。
然后再拿arr[high]与其前面的元素比较，以此类推。直到low=high，退出此次循环。感觉就是“夹逼准则”一样，一步步确定基准在序列中的应该在的位置。动图解释如下图所示。
在这里插入图片描述
说不清楚。。。。看代码吧。
(2)代码：

def searchmid(arr,low,high):
   temp=arr[low]
   while low != high:
       while arr[high]>=temp and low!=high:
           high-=1
       arr[low],arr[high]=arr[high],arr[low]
       while arr[low]<=temp and low!=high:
           low+=1
       arr[high],arr[low]=arr[low],arr[high]
   if low==high:
       return high
def quicksort(arr,low,high):
   a=low
   if low<high:
       mid=searchmid(arr,low,high)
       quicksort(arr,low,mid - 1)
       quicksort(arr,mid + 1,high)
arr=[2,4,1,6,19,20,5]
n=len(arr)
quicksort(arr,0,n-1)
print(arr)

def partition(arr, low, high):
   i = (low - 1)  # 最小元素索引
   pivot = arr[high]  #将pivot看作是一个中间值，先将比她小的往左边方，最后在

   for j in range(low, high):

       # 当前元素小于或等于 pivot
       if arr[j] <= pivot:
           i = i + 1
           arr[i], arr[j] = arr[j], arr[i]

   arr[i + 1], arr[high] = arr[high], arr[i + 1]
   return (i + 1)


# arr[] --> 排序数组
# low  --> 起始索引
# high  --> 结束索引

# 快速排序函数
def quickSort(arr, low, high):
   if low < high:
       pi = partition(arr, low, high)

       quickSort(arr, low, pi - 1)
       quickSort(arr, pi + 1, high)


arr = [10, 7, 8, 9, 1, 5]
n = len(arr)
quickSort(arr, 0, n - 1)
print("排序后的数组:")
for i in range(n):
   print("%d" % arr[i]),

3.归并排序

** (1)基本原理：**
归并排序（英语：Merge sort，或mergesort），是创建在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。
分治法:
分割：递归地把当前序列平均分割成两半。
集成：在保持元素顺序的同时将上一步得到的子序列集成到一起（归并）。
将待排序的元素序列分成两个长度相等的子序列，对每一个子序列排序，然后将他们合并成一个序列。合并两个子序列的过程称为二路归并。
在这里插入图片描述
(2)代码实现

def merge(arr,l,m,r):  # l 与r 是索引下标
    q,w=0,0
    n1=m-l+1
    n2=r-m
    s1=[0]*n1
    s2=[0]*n2
    # for i in range(0,n1):
    #     s1[i]=arr[l+i]
    #
    # for j in range(0,n2):
    #     s2[j]=arr[m+1+j]
    for i in range(l,m+1):
        s1[q] = arr[i]
        q+=1

    for j in range(m+1,r+1):
        s2[w] = arr[j]
        w+=1
    i=0
    j=0
    while i<n1 and j<n2:
        if s1[i]>=s2[j]:
            arr[l]=s2[j]
            j+=1
        else:
            arr[l]=s1[i]
            i+=1
        l+=1
    while i<n1:
        arr[l]=s1[i]
        i+=1
        l+=1
    while j<n2:
        arr[l]=s2[j]
        j+=1
        l+=1


def mergesort(arr,l,r):
    if l<r:
        m=int((l+(r-1))/2)
        mergesort(arr,l,m)
        mergesort(arr,m+1,r)
        merge(arr,l,m,r)

arr =[12, 11, 13, 5, 6, 7]
l=0
r=len(arr)-1  #统一一下，输入和运算的都是下标，索引值
mergesort(arr,l,r)
print(arr)

4.冒泡排序

(1)基本原理：
冒泡排序（Bubble Sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端。
在这里插入图片描述
(2)代码实现：

def Bubble(arr):
    n=len(arr)
    for i in range(0,n): #排序n个位置的数
        for j in range(0,n-i-1): #每排序一次，就最后一位不用比较了，并且“-1” 是由于最后一位没有他的下一位了，否则会越界
            if arr[j]>arr[j+1]:#下面的大于上面的数时，需要冒泡
               arr[j],arr[j+1]=arr[j+1],arr[j] #冒泡的效果就是下面的值替代上面的值
arr = [10, 7, 8, 9, 1, 5]
Bubble(arr)
print(arr)

5.选择排序

(1)基本原理：
简单来讲就是从未排序的序列中寻找最小值，放到序列的前面，后面再在未排序序列中寻找最小值，放在排序过的序列的后面，依次类推。
在这里插入图片描述
(2)代码实现：

def selectsort1(arr): # 基于列表的索引的
    for i in range(0,len(arr)):
        min=arr[i]
        for j in range(i,len(arr)):
            if arr[j]<min:
                min=arr[j]
                k=j
        arr[i],arr[k]=arr[k],arr[i]

def selectsort2(arr): #基于列表的元素值的
    n=len(arr)
    result=[]
    for i in range(0,n):
        min = arr[0]
        for j in arr:
            if j<min:
                min=j
        result.append(min)
        arr.remove(min)
    return result

arr = [10, 7, 8, 9, 1, 5]
result=selectsort2(arr)
print(result)