20分钟速成排序+查找算法（含模板）——二分查找，冒泡排序，快速排序

前言

排序，查找算法种类繁多， 全部熟记不太现实，或许在二者之中各找寻一个适合自己的算法熟练使用它会更好。因此今天我分享几种常见算法供大家参考，它们分别是：二分查找，冒泡排序与快速排序。代码不长，背诵记忆也是一个不错的选择，我这里提供了模板。如果哪一步不明白，可以多print几下看看数据的变化，或者手写模拟过程。

目录

前言

二分查找

模板

思路

复杂度

冒泡排序

模板

思路

复杂度

快速排序

模板

简介

思路

思考

模拟图解

默认参数

复杂度

想说的话

---

二分查找

模板

def binary_search(nums, target):
    # 二分查找前提是数据是要有序的
    nums.sort()
    # 左指针指向第一个元素
    left = 0
    # 右指针指向最后一个元素
    right = len(nums) - 1
    # 注意是小于等于
    while left <= right:
        # //2表示整除2向下取整
        mid = left + (right - left) // 2
        if nums[mid] == target:
            return mid
        # 如果大于目标右指针往左移 这样中值会变小
        elif nums[mid] > target:
            right = mid - 1
        # 小于目标左指针往右移
        else:
            left = mid + 1
    # 没找到返回-1
    return -1

思路

二分查找必须要在数据有序的条件下进行。左右指针分别位于数组左右边界，中值处于左右指针中点的位置，我们查找元素是依靠中值查找。决定中值的唯一条件就是左右指针的值。当中值与目标值不相等时，根据中值与目标值的大小判断进行移动左指针或右指针缩减范围。重复上述操作，直到找到元素或左右指针重合为止。

重合：当右指针为目标值时，左指针必须与右指针重合中值才能与目标值匹配，因此while条件必须是小于等于。

复杂度

时间复杂度：while循环的次数 -> O (log n)

空间复杂度：仅存在临时辅助变量left,right,mid -> O(1)

冒泡排序

模板

# 从小到大排序
def bubble_sort(nums):
    # 重复N-1次即可完成全部排序
    for i in range(1, len(nums)):
        # 每进行一次循环都交换出一个最大的数排在后面
        # 因为最后面的数已经排好序了，所以不用全部遍历比较 
        # i不从0开始是防止j+1越界
        for j in range(len(nums)-i):
            # 如果前者值大于后者，那么交换他两的值
            if nums[j] > nums[j+1]:
                nums[j], nums[j+1] = nums[j+1], nums[j]

思路

 每次大循环可以交换出一个最大值，进行N-1次交换即可完成排序。（如：若列表只有2个元素，那么进行2-1次交换即可完成排序。），而在小循环中，不断将前后元素相比较交换出更大的元素放在后面。小循环可以根据大循环的次数逐步缩小比较范围，因为后面元素已经排好序了，越靠后越大。

复杂度

时间复杂度：如果一开始就是正序一遍过的话复杂度是O(n)，如果一开始是反序（最坏情况）复杂度是O()，综上，总体时间复杂度 -> O()

空间复杂度：仅存在临时辅助变量i,j -> O(1)

快速排序

模板

def quick_sort(nums, start, end):
    # 递归结束条件
    if start >= end:
        return
    # 生成左右指针
    left = start
    right = end
    # 生成一个参考点，将小于中心点的值放在左边，大于中心点的值放在右边
    pivot = nums[right]
    while left < right:
        # 因为参考点在右边所以先从左指针开始寻找比参考点大的元素放在右侧右指针所指位置
        while left < right and nums[left] <= pivot:  # 如果想要倒序排序，将此处的<=,改成>=
            left += 1
        # 将左指针指向的元素赋值给右指针指向的位置，此时有两种情况，
        # 1.左右指针重合left=right，此时赋值与否元素值都不会改变
        # 2.找出了大于参考点值的元素，将其赋值给右指针指向的位置
        nums[right] = nums[left]
        # 移动右指针寻找比参考点小的元素
        while left < right and nums[right] >= pivot:  # 如果想要倒序排序，将此处的<=,改成>=,两处修改完后即为倒序排序
            right -= 1
        nums[left] = nums[right]
    # 跳出循环后，左右指针必定指向同一位置 然后将参考点放入两指针重合处
    nums[left] = pivot
    # 以相同方法继续排序支点左右两边元素
    quick_sort(nums, start, left-1)
    quick_sort(nums, left+1, end)

简介

快速排序是C.R.A.Hoare于1962年提出的一种划分交换排序。它采用的是一种分治策略，通常称其为分治法(Divide-and-ConquerMethod)，是对冒泡排序算法的一种改进。

思路

首先确定一个参考点，以及排序的区间。排序区间用两个指针表示，两指针分别位于左右区间。开始分别相向移动左右指针，将小于参考点的值放在左边左指针位置，大于参考点的值放在右边右指针位置。重复上述步骤，直到两指针重合为止。当两指针重合时，两指针左边的值全部都小于参考点的值，右边的值全部都大于参考点的值。然后将参考点的值放在两指针所指位置。最后将支点左右两边元素继续上述步骤进行交换排序，直到剩下一个元素不可再划分为止。当每个元素都不可在划分之时，列表已经排序完毕。

思考

找到符合条件的值后将其放在左指针或右指针的位置，这样做是否会覆盖掉原有的值造成数据丢失？

不会。因为一开始我们就确定了一个参考点，这个参考点会记录当前左指针或右指针所指的值（假设参考点记录右指针所指的值），记录后我们称此时右指针所指的值为虚值，因为它已经被记录了，它是否存在都不会影响数据的完整性。这时候它就作为我们数值交换的媒介，媒介在右边，那么就从左边开始移动左指针寻找符合条件的元素覆盖掉虚值。虚值被覆盖掉后左边又生成了一个新的虚值，那么现在就移动右指针寻找符合条件的元素覆盖掉虚值...重复上述步骤，直到两指针重合为止。而两指针所指之处必定是重复元素（虚值），因此可以将参考点放入两指针所指位置。

那么我们就发现了一个特点：如果参考点在左侧要右指针先移动，反之，左指针先移动。

模拟图解

结合思路看图解效果更佳噢！

 

默认参数

可以看到使用快速排序方法我们需要向里面传入三个参数，但也许有人就不希望在调用这方法的时候需要传入这么多参数，就想传个数组就好。这样的话我们就要对该方法做些微调，将参数设置为默认参数。

# 从小到大排序
def quick_sort(nums, start=0, end=-1):
    end = len(nums) - 1 if end == -1 else end

如果有传入参数那么就使用传入参数的值，否则就使用默认值。左区间默认从第一个元素开始，右区间默认从最后一个元素开始。  

复杂度

时间复杂度：最好情况是一遍过，时间复杂度为O(n)，最坏情况是每次所选的参考值是当前序列中的最大或最小元素，这样，长度为n的数据表的快速排序需要经过n趟划分，使得整个排序算法的时间复杂度为O(n2)。理想的情况下，每次划分所选择的中间数恰好将当前序列几乎等分，经过logn趟划分，便可得到长度为1的子表。这样，整个算法的时间复杂度为O(nlogn)。综上，时间复杂度为O(nlogn).

空间复杂度：尽管快速排序只需要几个元素的辅助空间，但快速排序需要一个栈空间来实现递归。最好的情况下，即快速排序的每一趟排序都将元素序列均匀地分割成长度相近的两个子表，所需栈的最大深度为log(n+1)；但最坏的情况下，栈的最大深度为n。综上，快速排序的空间复杂度为O(logn)。

想说的话

模板还是在理解的基础上记忆最好，那样才能达到事半功倍的效果。另外，如果大家对分治算法感兴趣的话可以尝试使用分治法实现pow函数，我这里有一篇参考文章嘻嘻..

python pow函数——幂运算 快速幂算法实现思路_lishuaigell的博客-CSDN博客https://blog.csdn.net/lishuaigell/article/details/122474662?spm=1001.2014.3001.5501