小码农进阶指南--数据结构之排序算法(动图展示)

Posted 2021-04-12 人工智能杂谈

今天给大家介绍下数据结构中常用的排序算法。

算法：

    算法就是指规定的时间内，给定规范的输入，得到规范的输出。

    逻辑（数据）结构：数据元素之间的逻辑关系

    存储（物理）结构：数据结构在计算机中的表示

    算法的设计取决于逻辑结构，而算法的实现依赖于采用的存储结构

    时间复杂度：定量描述了该算法的运行时间

    空间复杂度：空间复杂度是指执行这个算法所需要的内存空间

排序算法：

    所谓排序，顾名思义，就是将一个乱序的数组变得有序。

常见的排序算法有冒泡排序，选择排序，快速排序，归并排序，插入排序，希尔排序，堆排序，基数排序。

冒泡排序：

    

    冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。

    

    它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。

    

    这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”

Python代码实现如下：def bubble_sort(nums):
    for i in range(len(nums) - 1): # 这个循环负责设置冒泡排序进行的次数
        for j in range(len(nums) - i - 1): # j为列表下标
            if nums[j] > nums[j + 1]:
                nums[j], nums[j + 1] = nums[j + 1], nums[j]
    return nums
 
print(bubble_sort([45, 32, 8, 33, 12, 22, 19, 97]))
# 输出：[8, 12, 19, 22, 32, 33, 45, 97]

选择排序：

    选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法。

Python实现代码如下：
def selection_sort(list2):
  for i in range(0, len (list2)-1):
    min_ = i
    for j in range(i + 1, len(list2)):
      if list2[j] < list2[min_]:
        min_ = j
    list2[i], list2[min_] = list2[min_], list2[i] # swap

快速排序：

    

    快速排序（Quicksort）是对冒泡排序的一种改进。

    快速排序由C. A. R. Hoare在1960年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

    

Python代码实现如下：def sort(l):
    if len(l)<=1:
        return l
    left=sort([i for i in l[:-1] if i < l[-1]])
    right=sort([i for i in l[:-1] if i>l[-1]])
# 要遍历所有等于基准元素的元素（包括基准元素）
    mid=[i for i in l if i==l[-1]]
    return left+mid+right

归并排序：

    归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。归并排序是一种稳定的排序方法。

def hebing(l1,l2):
    result=[]
    # 3.重复1 - 2步，直到某一个列表为空
    while l1 and l2:
    # 1.分别从两个列表中取出第一个元素
        item1=l1[0]
        item2 = l2[0]
    # 2.比较两个元素的大小，将小的元素放入到结果数组中，并在原列表中移除该元素
        if item1>=item2:
            result.append(item2)
            l2.pop(0)
        else:
            result.append(item1)
            l1.pop(0)
    # 4.将不为空的列表剩余元素放入到结果数组中
    return result+l1+l2

#归并排序
def guibing(l):
    if len(l)<=1:
        return l
    return hebing(guibing(l[:len(l)//2]),guibing(l[len(l)//2:]))

插入排序：

    

    插入排序（Insertion sort）是一种简单直观且稳定的排序算法。如果有一个已经有序的数据序列，要求在这个已经排好的数据序列中插入一个数，但要求插入后此数据序列仍然有序，这个时候就要用到一种新的排序方法——插入排序法,插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为O(n^2)。是稳定的排序方法。插入算法把要排序的数组分成两部分：第一部分包含了这个数组的所有元素，但将最后一个元素除外（让数组多一个空间才有插入的位置），而第二部分就只包含这一个元素（即待插入元素）。在第一部分排序完成后，再将这个最后元素插入到已排好序的第一部分中。

    插入排序的基本思想是：每步将一个待排序的记录，按其关键码值的大小插入前面已经排序的文件中适当位置上，直到全部插入完为止。

def insert(L):
    for i in range(1,len(L)):
        value = L[i] #待插入元素
        j = i - 1
        while j >= 0:
            if L[j] > value:
                L[j + 1] = L[j]
                j -= 1
            else:
                break
        L[j + 1] = value

希尔排序：

    

    希尔排序(Shell's Sort)是插入排序的一种又称“缩小增量排序”（Diminishing Increment Sort），是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。该方法因D.L.Shell于1959年提出而得名。

     希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

def shell(L):
    n = len(L)
    gap = n // 2
    while gap > 0:
        for j in range(gap,n):
            i = j
            while (i - gap)>=0:
                if L[i] < L[i - gap]:
                    L[i],L[i - gap] = L[i - gap],L[i]
                    i = i - gap
                else:
                    break
        gap = gap//2

堆排序：

    堆排序（英语：Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

def HeapAdjust(L,s,e):
    t = 2 * s + 1
    while t < e :
 #找出较小的子节点
        if t + 1 < e and L[t + 1] < L[t]:
            t += 1
  #较小的子节点与父节点比较，若子节点小则交换 否则终止循环
        if L[t] < L[s] :
            L[t] , L[s] = L[s] , L[t]
        else:
            break
  #孩子节点与父节点交换后 继续向下进行筛选
        s = t
        t = 2 * s + 1

def HeapSort_X(L):
    if len(L) <= 1 :
        return L
    for i in range(0,len(L)//2)[::-1]:
        HeapAdjust(L,i,len(L))
    for j in range(1,len(L))[::-1]:
        L[j] , L[0] = L[0] , L[j]
        HeapAdjust(L , 0 , j)

基数排序：
    

    基数排序（radix sort）属于“分配式排序”（distribution sort），又称“桶子法”（bucket sort）或bin sort，顾名思义，它是透过键值的部份资讯，将要排序的元素分配至某些“桶”中，藉以达到排序的作用，基数排序法是属于稳定性的排序，其时间复杂度为O (nlog(r)m)，其中r为所采取的基数，而m为堆数，在某些时候，基数排序法的效率高于其它的稳定性排序法。

def RadixSort(L,lenght):
    
    for k in range(lenght) :
        Radix = [[] for i in range(10)]
        for i in L :
           m = int (i / (10**k) % 10)
           Radix[m].append(i)
        L = []
        # for i in Radix:
        # if len(i) :
        # L.extend(i)
        L = [ j for i in Radix for j in i]
    return L

以上就是数据结构中常见的八大排序了，不知道聪明的你有没有看懂呢？有什么意见和建议欢迎在下方留言，我会选择一些精品留言送出小礼物的。

你与世界

只差一个