个人介绍

hello hello~ ，这里是 code袁~💖💖 ，欢迎大家点赞🥳🥳关注💥💥收藏🌹🌹🌹

🦁作者简介：一名喜欢分享和记录学习的在校大学生
💥个人主页：code袁
💥 个人QQ：2647996100
🐯 个人wechat：code8896

专栏导航

code袁系列专栏导航
1.毕业设计与课程设计：本专栏分享一些毕业设计的源码以及项目成果。🥰🥰🥰
2.微信小程序开发：本专栏从基础到入门的一系开发流程，并且分享了自己在开发中遇到的一系列问题。🤹🤹🤹
3.vue开发系列全程线路：本专栏分享自己的vue的学习历程。

非常期待和您一起在这个小小的互联网世界里共同探索、学习和成长。💝💝💝 ✨✨ 欢迎订阅本专栏 ✨✨ 

排序算法学习笔记

1. 冒泡排序（Bubble Sort）

算法原理：冒泡排序是一种简单直观的排序算法，重复地遍历要排序的列表，依次比较相邻的两个元素，如果顺序不对则交换它们。

代码示例：

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

# 示例
arr = [64, 34, 25, 12, 22, 11, 90]
bubble_sort(arr)
print("排序后的列表：", arr)

2. 时间复杂度
   若文件的初始状态是正序的，一趟扫描即可完成排序。所需的关键字比较次数C和记录移动次数M均达到最小值：Cmin = N - 1, Mmin = 0。所以，冒泡排序最好时间复杂度为O(N)。

   但是上述代码，不能扫描一趟就完成排序，它会进行全扫描。所以一个改进的方法就是，当冒泡中途发现已经为正序了，便无需继续比对下去。改进方法一会儿介绍。

   若初始文件是反序的，需要进行 N -1 趟排序。每趟排序要进行 N - i 次关键字的比较(1 ≤ i ≤ N - 1)，且每次比较都必须移动记录三次来达到交换记录位置。在这种情况下，比较和移动次数均达到最大值：

   Cmax = N(N-1)/2 = O(N^2)

   Mmax = 3N(N-1)/2 = O(N^2)

   冒泡排序的最坏时间复杂度为O(N^2)。

   因此，冒泡排序的平均时间复杂度为O(N^2)。

   总结起来，其实就是一句话：当数据越接近正序时，冒泡排序性能越好。

算法稳定性
    假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，
    即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；
    否则称为不稳定的。

2. 快速排序（Quick Sort）

算法原理：快速排序是一种分治算法，通过选择一个基准值，将列表分割成两部分，小于基准值的放在左边，大于基准值的放在右边，然后递归地对左右两部分进行排序。

快速排序的图例

代码示例：

def quick_sort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quick_sort(left) + middle + quick_sort(right)

# 示例
arr = [64, 34, 25, 12, 22, 11, 90]
sorted_arr = quick_sort(arr)
print("排序后的列表：", sorted_arr)

3.2 时间复杂度
当数据有序时，以第一个关键字为基准分为两个子序列，前一个子序列为空，此时执行效率最差。
而当数据随机分布时，以第一个关键字为基准分为两个子序列，两个子序列的元素个数接近相等，此时执行效率最好。
所以，数据越随机分布时，快速排序性能越好；数据越接近有序，快速排序性能越差
3.3 时间复杂度
快速排序在每次分割的过程中，需要 1 个空间存储基准值。而快速排序的大概需要 logN次的分割处理，所以占用空间也是 logN 个。

3.4 算法稳定性

    在快速排序中，相等元素可能会因为分区而交换顺序，所以它是不稳定的算法。

3. 归并排序（Merge Sort）

算法原理
归并排序是一种分治算法，将列表分成两个子列表，分别对子列表进行排序，然后合并两个有序子列表。
算法思想
该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。

代码示例：

def merge_sort(arr):
    if len(arr) <= 1:
        return arr
    mid = len(arr) // 2
    left = merge_sort(arr[:mid])
    right = merge_sort(arr[mid:])
    return merge(left, right)

def merge(left, right):
    result = []
    i = j = 0
    while i < len(left) and j < len(right):
        if left[i] < right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1
    result += left[i:]
    result += right[j:]
    return result

# 示例
arr = [64, 34, 25, 12, 22, 11, 90]
sorted_arr = merge_sort(arr)
print("排序后的列表：", sorted_arr)

3.2 时间复杂度
归并排序的形式就是一棵二叉树，它需要遍历的次数就是二叉树的深度，而根据完全二叉树的可以得出它的时间复杂度是O(n*log2n)。
3.3 空间复杂度
由前面的算法说明可知，算法处理过程中，需要一个大小为n的临时存储空间用以保存合并序列。
3.4 算法稳定性
在归并排序中，相等的元素的顺序不会改变，所以它是稳定的算法。
3.5 归并排序和堆排序、快速排序的比较
若从空间复杂度来考虑：首选堆排序，其次是快速排序，最后是归并排序。
若从稳定性来考虑，应选取归并排序，因为堆排序和快速排序都是不稳定的。
若从平均情况下的排序速度考虑，应该选择快速排序。

堆的

堆（Heap）是一种特殊的树形数据结构，通常用于实现优先队列。堆分为最大堆和最小堆，最大堆中父节点的值大于或等于任何一个子节点的值，最小堆中父节点的值小于或等于任何一个子节点的值。以下是关于堆的学习笔记，包括堆的性质、实现方式和应用场景：

堆的性质

1. 堆是一个完全二叉树。
2. 在最大堆中，父节点的值大于或等于任何一个子节点的值。
3. 在最小堆中，父节点的值小于或等于任何一个子节点的值。

堆的实现

堆通常使用数组来表示，数组中的元素按照特定顺序排列以满足堆的性质。通过一些操作（如插入、删除、调整）来维护堆的性质。

堆的操作

1. 插入（Insert）：将新元素插入到堆中，并保持堆的性质。
2. 删除最大元素（Delete Max）：从最大堆中删除最大元素，并保持堆的性质。
3. 调整（Heapify）：将一个无序数组调整为堆结构。

代码示例

以下是一个使用Python实现最大堆的示例代码：

import heapq

class MaxHeap:
    def __init__(self):
        self.heap = []
    
    def push(self, val):
        heapq.heappush(self.heap, -val)
    
    def pop(self):
        return -heapq.heappop(self.heap)

# 示例
max_heap = MaxHeap()
max_heap.push(5)
max_heap.push(2)
max_heap.push(9)
print(max_heap.pop())  # 输出：9

堆的应用场景

1. 实现优先队列：堆可以高效地实现优先队列，保证每次取出的元素是优先级最高的。
2. 堆排序：利用堆的性质进行排序，时间复杂度为O(nlogn)。

参考文章

🎉写在最后

🍻伙伴们，如果你已经看到了这里，觉得这篇文章有帮助到你的话不妨点赞👍或 Star ✨支持一下哦！手动码字，如有错误，欢迎在评论区指正💬~

你的支持就是我更新的最大动力💪~