• python查找与排序算法详解（示意图+代码、看完基础不成问题）

     🔝🔝🔝🔝🔝🔝🔝🔝🔝🔝🔝🔝 

    🥰 博客首页：knighthood2001

    😗 欢迎点赞👍评论🗨️

    ❤️ 热爱python，期待与大家一同进步成长！！❤️

    👀给大家推荐一款很火爆的刷题、面试求职网站👀

    目录

    查找

    二分查找

    线性查找

    排序 

    插入排序

    快速排序

    选择排序

    冒泡排序

    归并排序

    堆排序

    计数排序

    希尔排序

    拓扑排序

    总结

            笔者最近在找一些经典算法，这时候发现牛客网中有许多，笔者根据源码并进行了一下细微的调整，现将整理好的代码及运行结果写出来，需要进行刷题的可以点此进行注册，开启刷题之旅！！

            当然，牛客网中有些代码所展示出来的格式不太好 ，比如print ()而不是print()、有些会在行后面加‘;’，不太符合python的写法。不过这些不是最主要的，接下来开启python查找与排序之旅吧！！ 

    查找

    二分查找

            二分搜索是一种在有序数组中查找某一特定元素的搜索算法。搜索过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜索过程结束；如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。如果在某一步骤数组为空，则代表找不到。这种搜索算法每一次比较都使搜索范围缩小一半。

    1. # 返回 x 在 arr 中的索引，如果不存在返回 -1
    2. def binarySearch (arr, l, r, x):
    3.     # 基本判断
    4.     if r >= l:
    5.         mid = int(l + (r - l)/2)
    6.         # 元素整好的中间位置
    7.         if arr[mid] == x:
    8.             return mid
    9.         # 元素小于中间位置的元素，只需要再比较左边的元素
    10.         elif arr[mid] > x:
    11.             return binarySearch(arr, l, mid-1, x)
    12.         # 元素大于中间位置的元素，只需要再比较右边的元素
    13.         else:
    14.             return binarySearch(arr, mid+1, r, x)
    15.     else:
    16.         # 不存在
    17.         return -1
    18.  
    19. # 测试数组
    20. arr = [ 2, 3, 4, 10, 40]
    21. x = int(input('请输入元素：'))
    22. # 函数调用
    23. result = binarySearch(arr, 0, len(arr)-1, x)
    24.  
    25. if result != -1:
    26.     print("元素在数组中的索引为 %d" % result)
    27. else:
    28.     print("元素不在数组中")

            运行结果： 

    1. 请输入元素：4
    2. 元素在数组中的索引为 2
    1. 请输入元素：5
    2. 元素不在数组中

    线性查找

            线性查找指按一定的顺序检查数组中每一个元素，直到找到所要寻找的特定值为止。 

    1. def search(arr, n, x):
    2.     for i in range (0, n):
    3.         if (arr[i] == x):
    4.             return i
    5.     return -1
    6.  
    7. # 在数组 arr 中查找字符 D
    8. arr = [ 'A', 'B', 'C', 'D', 'E' ]
    9. x = input("请输入要查找的元素：")
    10. n = len(arr)
    11. result = search(arr, n, x)
    12. if(result == -1):
    13.     print("元素不在数组中")
    14. else:
    15.     print("元素在数组中的索引为", result)

            运行结果： 

    1. 请输入要查找的元素：A
    2. 元素在数组中的索引为 0
    1. 请输入要查找的元素：a
    2. 元素不在数组中

    排序 

    插入排序

            插入排序（Insertion Sort）是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

    1. def insertionSort(arr):
    2.     for i in range(1, len(arr)):
    3.         key = arr[i]
    4.         j = i-1
    5.         while j >= 0 and key < arr[j]:
    6.                 arr[j+1] = arr[j]
    7.                 j -= 1
    8.         arr[j+1] = key
    9.  
    10. arr = [12, 11, 13, 5, 6, 7, 9, 9, 17]
    11. insertionSort(arr)
    12. print("排序后的数组:")
    13. print(arr)

            运行结果：  

    1. 排序后的数组:
    2. [5, 6, 7, 9, 9, 11, 12, 13, 17]

    当然也可以这样写，更简洁

    1. list1 = [12, 11, 13, 5, 6, 7, 9, 9, 17]
    2. for i in range(len(list1)-1, 0, -1):
    3.     for j in range(0, i):
    4.         if list1[i] < list1[j]:
    5.             list1[i], list1[j] = list1[j], list1[i]
    6. print(list1)

    快速排序

            快速排序使用分治法（Divide and conquer）策略来把一个序列（list）分为较小和较大的2个子序列，然后递归地排序两个子序列。

    步骤为：

    • 挑选基准值：从数列中挑出一个元素，称为"基准"（pivot）;
    • 分割：重新排序数列，所有比基准值小的元素摆放在基准前面，所有比基准值大的元素摆在基准后面（与基准值相等的数可以到任何一边）。在这个分割结束之后，对基准值的排序就已经完成;
    • 递归排序子序列：递归地将小于基准值元素的子序列和大于基准值元素的子序列排序。

    递归到最底部的判断条件是数列的大小是零或一，此时该数列显然已经有序。

    选取基准值有数种具体方法，此选取方法对排序的时间性能有决定性影响。

    1. def partition(arr, low, high):
    2.     i = (low-1)         # 最小元素索引
    3.     pivot = arr[high]
    4.  
    5.     for j in range(low, high):
    6.         # 当前元素小于或等于 pivot
    7.         if arr[j] <= pivot:
    8.             i = i+1
    9.             arr[i], arr[j] = arr[j], arr[i]
    10.  
    11.     arr[i+1], arr[high] = arr[high], arr[i+1]
    12.     return (i+1)
    13.  
    14. # arr[] --> 排序数组
    15. # low  --> 起始索引
    16. # high  --> 结束索引
    17.  
    18. # 快速排序函数
    19. def quickSort(arr, low, high):
    20.     if low < high:
    21.         pi = partition(arr, low, high)
    22.         quickSort(arr, low, pi-1)
    23.         quickSort(arr, pi+1, high)
    24.     return arr
    25.  
    26. arr = [10, 7, 8, 9, 1, 5]
    27. n = len(arr)
    28.  
    29. print("排序后的数组:")
    30. print(quickSort(arr, 0, n-1))

            运行结果：   

    1. 排序后的数组:
    2. [1, 5, 7, 8, 9, 10]

    选择排序

            选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理如下。

            首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

    1. A = [64, 25, 12, 22, 11]
    2. for i in range(len(A)): 
    3.     min_idx = i
    4.     for j in range(i+1, len(A)):
    5.         if A[min_idx] > A[j]:
    6.             min_idx = j
    7.  
    8.     A[i], A[min_idx] = A[min_idx], A[i]
    9.  
    10. print("排序后的数组：")
    11. print(A)

            运行结果：   

    1. 排序后的数组：
    2. [11, 12, 22, 25, 64]

    冒泡排序

            冒泡排序（Bubble Sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端。

    1. def bubbleSort(arr):
    2.     n = len(arr)
    3.     # 遍历所有数组元素
    4.     for i in range(n):
    5.         # Last i elements are already in place
    6.         for j in range(0, n-i-1):
    7.  
    8.             if arr[j] > arr[j+1]:
    9.                 arr[j], arr[j+1] = arr[j+1], arr[j]
    10.     return arr
    11.  
    12. arr = [64, 34, 25, 12, 22, 11, 90]
    13.  
    14. print("排序后的数组:")
    15. print(bubbleSort(arr))

            运行结果：   

    1. 排序后的数组:
    2. [11, 12, 22, 25, 34, 64, 90]

    归并排序

            归并排序（Merge sort，或mergesort），是创建在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。

    分治法:

    • 分割：递归地把当前序列平均分割成两半。
    • 集成：在保持元素顺序的同时将上一步得到的子序列集成到一起（归并）。

    1. def merge(arr, l, m, r):
    2.     n1 = m - l + 1
    3.     n2 = r - m
    4.  
    5.     # 创建临时数组
    6.     L = [0] * (n1)
    7.     R = [0] * (n2)
    8.  
    9.     # 拷贝数据到临时数组 arrays L[] 和 R[]
    10.     for i in range(0, n1):
    11.         L[i] = arr[l + i]
    12.  
    13.     for j in range(0, n2):
    14.         R[j] = arr[m + 1 + j]
    15.  
    16.     # 归并临时数组到 arr[l..r]
    17.     i = 0     # 初始化第一个子数组的索引
    18.     j = 0     # 初始化第二个子数组的索引
    19.     k = l     # 初始归并子数组的索引
    20.  
    21.     while i < n1 and j < n2:
    22.         if L[i] <= R[j]:
    23.             arr[k] = L[i]
    24.             i += 1
    25.         else:
    26.             arr[k] = R[j]
    27.             j += 1
    28.         k += 1
    29.  
    30.     # 拷贝 L[] 的保留元素
    31.     while i < n1:
    32.         arr[k] = L[i]
    33.         i += 1
    34.         k += 1
    35.  
    36.     # 拷贝 R[] 的保留元素
    37.     while j < n2:
    38.         arr[k] = R[j]
    39.         j += 1
    40.         k += 1
    41.  
    42. def mergeSort(arr, l, r):
    43.     if l < r:
    44.         m = int((l+(r-1))/2)
    45.         mergeSort(arr, l, m)
    46.         mergeSort(arr, m+1, r)
    47.         merge(arr, l, m, r)
    48.     return arr
    49.  
    50. print ("给定的数组")
    51. arr = [12, 11, 13, 5, 6, 7, 13]
    52. print(arr)
    53. n = len(arr)
    54. mergeSort(arr, 0, n-1)
    55. print("排序后的数组")
    56. print(arr)

            运行结果：   

    1. 给定的数组
    2. [12, 11, 13, 5, 6, 7, 13]
    3. 排序后的数组
    4. [5, 6, 7, 11, 12, 13, 13]

    堆排序

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

    1. def heapify(arr, n, i):
    2.     largest = i
    3.     l = 2 * i + 1     # left = 2*i + 1
    4.     r = 2 * i + 2     # right = 2*i + 2
    5.  
    6.     if l < n and arr[i] < arr[l]:
    7.         largest = l
    8.  
    9.     if r < n and arr[largest] < arr[r]:
    10.         largest = r
    11.  
    12.     if largest != i:
    13.         arr[i], arr[largest] = arr[largest], arr[i]  # 交换
    14.  
    15. def heapSort(arr):
    16.     n = len(arr)
    17.     # Build a maxheap.
    18.     for i in range(n, -1, -1):
    19.         heapify(arr, n, i)
    20.  
    21.     # 一个个交换元素
    22.     for i in range(n-1, 0, -1):
    23.         arr[i], arr[0] = arr[0], arr[i]   # 交换
    24.         heapify(arr, i, 0)
    25.     return arr
    26.  
    27. arr = [12, 11, 13, 5, 6, 7, 13, 18]
    28. heapSort(arr)
    29. print("排序后的数组")
    30. print(heapSort(arr))

            运行结果：   

    1. 排序后的数组
    2. [5, 6, 7, 12, 11, 13, 13, 18]

    计数排序

            计数排序的核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。

    1. def countSort(arr):
    2.  
    3.     output = [0 for i in range(256)]
    4.  
    5.     count = [0 for i in range(256)]
    6.  
    7.     ans = ["" for _ in arr]
    8.  
    9.     for i in arr:
    10.         count[ord(i)] += 1
    11.  
    12.     for i in range(256):
    13.         count[i] += count[i-1] 
    14.  
    15.     for i in range(len(arr)):
    16.         output[count[ord(arr[i])]-1] = arr[i]
    17.         count[ord(arr[i])] -= 1
    18.  
    19.     for i in range(len(arr)):
    20.         ans[i] = output[i]
    21.     return ans
    22.  
    23. arr = "wwwnowcodercom"
    24. ans = countSort(arr)
    25. print("字符数组排序 %s" %("".join(ans)))

            运行结果：   

    字符数组排序 ccdemnooorwwww

    希尔排序

            希尔排序，也称递减增量排序算法，是插入排序的一种更高效的改进版本。但希尔排序是非稳定排序算法。

            希尔排序的基本思想是：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录"基本有序"时，再对全体记录进行依次直接插入排序。

    1. def shellSort(arr):
    2.     n = len(arr)
    3.     gap = int(n/2)
    4.  
    5.     while gap > 0:
    6.         for i in range(gap, n):
    7.             temp = arr[i]
    8.             j = i
    9.             while j >= gap and arr[j-gap] > temp:
    10.                 arr[j] = arr[j-gap]
    11.                 j -= gap
    12.             arr[j] = temp
    13.         gap = int(gap/2)
    14.     return arr
    15.  
    16. arr = [12, 34, 54, 2, 3, 2, 5]
    17.  
    18. print("排序前:")
    19. print(arr)
    20. print("排序后:")
    21. print(shellSort(arr))

            运行结果：   

    1. 排序前:
    2. [12, 34, 54, 2, 3, 2, 5]
    3. 排序后:
    4. [2, 2, 3, 5, 12, 34, 54]

    拓扑排序

            对一个有向无环图(Directed Acyclic Graph简称DAG)G进行拓扑排序，是将G中所有顶点排成一个线性序列，使得图中任意一对顶点u和v，若边(u,v)∈E(G)，则u在线性序列中出现在v之前。通常，这样的线性序列称为满足拓扑次序(Topological Order)的序列，简称拓扑序列。简单的说，由某个集合上的一个偏序得到该集合上的一个全序，这个操作称之为拓扑排序。

            在图论中，由一个有向无环图的顶点组成的序列，当且仅当满足下列条件时，称为该图的一个拓扑排序（英语：Topological sorting）：

    • 每个顶点出现且只出现一次；
    • 若A在序列中排在B的前面，则在图中不存在从B到A的路径。

    1. from collections import defaultdict
    2.  
    3. class Graph:
    4.     def __init__(self, vertices):
    5.         self.graph = defaultdict(list)
    6.         self.V = vertices
    7.  
    8.     def addEdge(self, u, v):
    9.         self.graph[u].append(v)
    10.  
    11.     def topologicalSortUtil(self, v, visited, stack):
    12.  
    13.         visited[v] = True
    14.  
    15.         for i in self.graph[v]:
    16.             if visited[i] == False:
    17.                 self.topologicalSortUtil(i, visited, stack)
    18.  
    19.         stack.insert(0,v)
    20.  
    21.     def topologicalSort(self):
    22.         visited = [False]*self.V
    23.         stack = []
    24.  
    25.         for i in range(self.V):
    26.             if visited[i] == False:
    27.                 self.topologicalSortUtil(i, visited, stack)
    28.  
    29.         print(stack)
    30.  
    31. g= Graph(6)
    32. g.addEdge(5, 2)
    33. g.addEdge(5, 0)
    34. g.addEdge(4, 0)
    35. g.addEdge(4, 1)
    36. g.addEdge(2, 3)
    37. g.addEdge(3, 1)
    38.  
    39. print("拓扑排序结果：")
    40. g.topologicalSort()

            运行结果：   

    1. 拓扑排序结果：
    2. [5, 4, 2, 3, 1, 0]

    总结

            以上全部内容全部来自牛客网，以上很多代码笔者更改过，并且全部检验过，可以运行且能得出目标结果，使得结果更加贴近我们平时所需，以上有些排序比较重要与热门，比如vb中也会学到的二分查找、选择排序、冒泡排序，以上代码如有错误，请指正。

  • 相关阅读:
    前端工程化精讲第二十课 流程优化：部署流程中的构建流程策略优化
    网络编程 —— Http使用httpClient实现页面爬虫
    结构光照明的显微镜系统
    Elasticsearch许可证过期导致ES用不了的问题
    201、RabbitMQ 之 Exchange 典型应用模型 之 工作队列（Work Queue）
    学Java· 从new说对象实例化
    Python CNN卷积神经网络实例讲解，CNN实战，CNN代码实例，超实用
    若依+lodop+jasperreports+ireport 设计打印票据格式（一）
    目标检测（4）—— 经典算法和常用指标
    Docker实践：使用Docker搭建个人开发环境（极简版）
  • 原文地址：https://blog.csdn.net/knighthood2001/article/details/125729859