八大排序算法 (python版本)

八大排序算法

个人学习笔记 如有问题欢迎指正交流

快速排序经常考， 如果只掌握一个排序算法的话，首选快速排序算法
八大排序算法通常指的是以下八种经典排序算法：

1. 冒泡排序 (Bubble Sort)

  • 使用场景：适用于小规模数据的排序，不推荐用于大规模数据排序。
  • 稳定性：稳定排序算法。
  • 时间复杂度：平均和最坏情况下 O(n^2)，最好情况下 O(n)（当输入数据已经有序时）。

2. 选择排序 (Selection Sort):

  • 使用场景：适用于小规模数据的排序，与冒泡排序类似，不适用于大规模数据排序。
  • 稳定性：不稳定排序算法。
  • 时间复杂度：都为 O(n^2)。

3. 插入排序 (Insertion Sort):

  • 使用场景：适用于小规模数据，也适用于部分有序的大规模数据。
  • 稳定性：稳定排序算法。
  • 时间复杂度：平均和最坏情况下 O(n^2)，最好情况下 O(n)（当输入数据已经有序时）。

4. 希尔排序 (Shell Sort):

  • 使用场景：适用于中等规模数据，对于大规模数据效果也不错。
  • 稳定性：不稳定排序算法。
  • 时间复杂度：最坏情况下取决于间隔序列，通常介于 O(n log n) 和 O(n^2) 之间。

5. 归并排序 (Merge Sort):

  • 使用场景：适用于大规模数据，对数据规模不敏感，效率稳定。
  • 稳定性：稳定排序算法。
  • 时间复杂度：始终为 O(n log n)，但需要额外的空间来存储中间结果。

6. 快速排序 (Quick Sort):

  • 使用场景：适用于大规模数据，且在大多数情况下效率较高。
  • 稳定性：不稳定排序算法。
  • 时间复杂度：平均情况下 O(n log n)，最坏情况下 O(n^2)（当选择的主元极不均匀时）。

7. 堆排序 (Heap Sort):

  • 使用场景：适用于大规模数据，且对内存要求较高，适合外部排序。
  • 稳定性：不稳定排序算法。
  • 时间复杂度：始终为 O(n log n)，且不需要额外空间。

8. 计数排序 (Counting Sort):

  • 使用场景：适用于数据范围不大，但是数据量较大的情况。
  • 稳定性：稳定排序算法。
  • 时间复杂度：最好情况下为 O(n + k)，其中 k 表示数据范围。

每种排序算法都有其独特的应用场景和特点，根据实际问题选择合适的排序算法能够有效提高程序的效率。

1. 冒泡排序

在这里插入图片描述

图1摘自菜鸟教程
  1. 冒泡排序(相邻比较冒泡) 遍历i时 (0, n-i)进行比较 (n-i, n)是有序的
    1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
    2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
      针对所有的元素重复以上的步骤，除了最后一个。

复杂度: O(n^2)
稳定性：稳定排序算法。
使用场景：适用于小规模数据的排序，不推荐用于大规模数据排序。
详细介绍: https://www.runoob.com/w3cnote/bubble-sort.html
视频讲解: https://www.bilibili.com/video/BV1Hg4y1q7tz

"""
1.冒泡排序(相邻比较冒泡) 遍历i次之后 (0, n-i)进行比较 (n-i, n)是有序的1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。针对所有的元素重复以上的步骤，除了最后一个。
复杂度: O(n^2)
稳定性：稳定排序算法。
使用场景：适用于小规模数据的排序，不推荐用于大规模数据排序。
详细介绍: https://www.runoob.com/w3cnote/bubble-sort.html
视频讲解: https://www.bilibili.com/video/BV1Hg4y1q7tz
"""
def bubble_sort(arr):for i in range(len(arr)):flag = Truefor j in range(len(arr)-i-1):if arr[j] > arr[j+1]:arr[j], arr[j+1] = arr[j+1], arr[j]flag = Falseif flag:breakreturn arrif __name__ == '__main__':arr = [5, 4, 3, 2, 1]res = bubble_sort(arr)print(f"res: {res}")

2. 选择排序

在这里插入图片描述

图2摘自菜鸟教程
  1. 选择排序 遍历i次之后 操作(0, i)是有序的 (i, n) 进行比较
    (选择最小(最大)的在未排序的最开始(末尾)位置) 针对(i, n)进行的排序
    1. 在每一轮循环中，找到未排序部分中的最小元素的索引，然后将最小元素与当前位置进行交换。
    2. 每一轮循环会将一个最小元素放到已排序部分的末尾。

复杂度: O(n^2)
稳定性：不稳定排序算法。
使用场景：适用于小规模数据的排序，与冒泡排序类似，不适用于大规模数据排序。
详细介绍: https://www.runoob.com/w3cnote/selection-sort.html
视频讲解: https://www.bilibili.com/video/BV1VK4y1475t

"""
2.选择排序 遍历i次之后 操作(0, i)是有序的 (i, n) 进行比较(选择最小(最大)的在未排序的最开始(末尾)位置) 针对(i, n)进行的排序1.在每一轮循环中，找到未排序部分中的最小元素的索引，然后将最小元素与当前位置进行交换。2.每一轮循环会将一个最小元素放到已排序部分的末尾。
复杂度: O(n^2)
稳定性：不稳定排序算法。
使用场景：适用于小规模数据的排序，与冒泡排序类似，不适用于大规模数据排序。
详细介绍: https://www.runoob.com/w3cnote/selection-sort.html
视频讲解: https://www.bilibili.com/video/BV1VK4y1475t
"""
def select_sort(arr):# l = 0n = len(arr)for i in range(n):min_index = imin = arr[i]for j in range(i+1, n):if arr[j] < min:min = arr[j]min_index = jprint(f"l:flag_index {i}:{min_index}")arr[i], arr[min_index] = arr[min_index], arr[i]return arr
if __name__ == '__main__':arr = [9, 5, 2, 7, 12, 4]print(f"before: {arr}")res = select_sort(arr)print(f"res: {res}")

3. 插入排序

在这里插入图片描述

图2摘自菜鸟教程
  1. 插入排序
    遍历i时 (0, i-1)是有序的 将i插入到(0, i-1)序列中 (i, n)无序的
    找到一个合适的所用在(0, i-1) 中找到一个合适的位置进行插入
    1. 在每一轮循环中，找到未排序部分中的最小元素的索引，然后将最小元素与当前位置进行交换。
    2. 每一轮循环会将一个最小元素放到已排序部分的末尾。

复杂度: O(n^2)
稳定性：稳定排序算法。
使用场景：适用于小规模数据，也适用于部分有序的大规模数据。
详细介绍: https://www.runoob.com/w3cnote/insertion-sort.html
视频讲解: https://www.bilibili.com/video/BV1TD4y1Q751

"""
3.插入排序遍历i时 (0, i-1)是有序的 将i插入到(0, i-1)序列中   (i, n)无序的找到一个合适的所用在(0, i-1) 中找到一个合适的位置进行插入1.在每一轮循环中，找到未排序部分中的最小元素的索引，然后将最小元素与当前位置进行交换。2.每一轮循环会将一个最小元素放到已排序部分的末尾。
复杂度: O(n^2)
稳定性：稳定排序算法。
使用场景：适用于小规模数据，也适用于部分有序的大规模数据。
详细介绍: https://www.runoob.com/w3cnote/insertion-sort.html
视频讲解: https://www.bilibili.com/video/BV1TD4y1Q751
"""
def insert_sort(arr):n = len(arr)for i in range(1, n):preIndex = i-1current = arr[i]# 大于current的元素向右移动while preIndex >= 0 and arr[preIndex] > current:arr[preIndex+1] = arr[preIndex]preIndex -= 1arr[preIndex+1] = currentprint(f"arr: {arr}")return currentif __name__ == '__main__':arr = [10, 8, 11, 7, 4, 12]insert_sort(arr)

4 希尔排序

在这里插入图片描述

图4摘自博客园

4.希尔排序 (gap为1就是插入排序)
希尔排序的基本思想是
1. 将数组中相距一定间隔(gap)的元素分成一组，
2. 对每组使用插入排序，然后逐步减小间隔直至为1，最终完成排序。

稳定性：不稳定排序算法。
使用场景：适用于中等规模数据，对于大规模数据效果也不错。
复杂度: 最坏情况下取决于间隔序列，通常介于 O(nlog n)和 O(n^2) 之间。
详细介绍: https://www.runoob.com/w3cnote/shell-sort.html
视频讲解: https://www.bilibili.com/video/BV1BK4y1478X

"""
4.希尔排序 (gap为1就是插入排序) 希尔排序的基本思想是1. 将数组中相距一定间隔(gap)的元素分成一组，2. 对每组使用插入排序，然后逐步减小间隔直至为1，最终完成排序。稳定性：不稳定排序算法。
使用场景：适用于中等规模数据，对于大规模数据效果也不错。
复杂度: 最坏情况下取决于间隔序列，通常介于 O(nlog n)和 O(n^2) 之间。
详细介绍: https://www.runoob.com/w3cnote/shell-sort.html
视频讲解: https://www.bilibili.com/video/BV1BK4y1478X
"""def shell_sort(arr):n = len(arr)gap = n // 3while gap > 0:for i in range(gap, n):  # 从gap开始因为要从第二个开始插入, 第一个元素已经是有序的current = arr[i]preIndex = i - gapwhile preIndex >= 0 and arr[preIndex] > current:arr[preIndex+gap] = arr[preIndex]preIndex -= gaparr[preIndex+gap] = currentgap //= 2return arrif __name__ == '__main__':# 测试arr = [12, 34, 54, 2, 3]shell_sort(arr)print("排序后的数组：", arr)

5. 归并排序

在这里插入图片描述

图5摘自菜鸟教程
  1. 归并排序算法步骤: (递归和栈)
    1. 先归(一致分)
    2. 然后并(比较排序)

时间复杂度：O(nlogn)但需要额外的空间来存储中间结果。
稳定性：稳定排序算法。
使用场景：适用于大规模数据，对数据规模不敏感，效率稳定。
复杂度: O(nlogn)
详细介绍: https://www.runoob.com/w3cnote/merge-sort.html
视频讲解: https://www.bilibili.com/video/BV1Pt4y197VZ

"""
5. 归并排序 (递归和栈)1. 先归(一致分)2. 然后并(比较排序)时间复杂度：O(nlogn)但需要额外的空间来存储中间结果。
稳定性：稳定排序算法。
使用场景：适用于大规模数据，对数据规模不敏感，效率稳定。
复杂度: O(nlogn)
详细介绍: https://www.runoob.com/w3cnote/merge-sort.html
视频讲解: https://www.bilibili.com/video/BV1Pt4y197VZ
"""
def merge_sort(arr):if len(arr) <= 1:return arrmid = len(arr) // 2left = arr[:mid]right = arr[mid:]# 归left = merge_sort(left)right = merge_sort(right)return merge(left, right) # 并
def merge(left, right): # left, right都是有序数组i = j = 0res_list = []while i < len(left) and j < len(right):if left[i] <= right[j]:res_list.append(left[i])i += 1else:res_list.append(right[j])j += 1res_list.extend(left[i:])res_list.extend(right[j:])return res_listif __name__ == '__main__':# 测试arr = [12, 11, 13, 5, 6, 7]sorted_arr = merge_sort(arr)print("排序后的数组：", sorted_arr)

6. 快速排序(重点!!!)

在这里插入图片描述

图6摘自菜鸟教程

算法步骤:

  1. 从数列中挑出一个元素，称为 “基准”（pivot）;
  2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
  3. 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序；

复杂度: O(nlogn) 最坏情况下 O(n^2) (当选择的主元极不均匀时)。
稳定性：不稳定排序算法。
使用场景：适用于大规模数据，且在大多数情况下效率较高。
详细介绍: https://www.runoob.com/w3cnote/quick-sort-2.html
视频讲解: https://www.bilibili.com/video/BV1WF41187Bp

6.1 方法1:

"""
6. 快速排序 是一种分治算法，它选择一个基准元素，将数组分成两个子数组，分别小于和大于基准元素，然后对子数组进行递归排序。
复杂度: O(nlogn) 最坏情况下 O(n^2) (当选择的主元极不均匀时)。
稳定性：不稳定排序算法。
使用场景：适用于大规模数据，且在大多数情况下效率较高。
详细介绍: https://www.runoob.com/w3cnote/quick-sort-2.html
视频讲解: https://www.bilibili.com/video/BV1WF41187Bp
"""
def quick_sort(arr):if len(arr) <= 1:return arrpivot = arr[len(arr)-1]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)if __name__ == '__main__':# arr =arr = [5, 3, 4, 2, 1]sorted_arr = quick_sort(arr)print("排序后的数组：", sorted_arr)

6.2 方法2:

"""
6. 快速排序 是一种分治算法，它选择一个基准元素，将数组分成两个子数组，分别小于和大于基准元素，然后对子数组进行递归排序。
复杂度: O(nlogn)
详细介绍: https://www.runoob.com/w3cnote/quick-sort-2.html
视频讲解: https://www.bilibili.com/video/BV1WF41187Bp
"""def quick_sort(arr, low, high):if low < high:pivot_index = partition(arr, low, high)quick_sort(arr, low, pivot_index-1)quick_sort(arr, pivot_index + 1, high)def partition(arr, low, high):pivot = arr[low]left = low + 1right = highflag = False#  退出循环的时候 arr[r]指向的肯定是小于pivotwhile True:while left <= right and arr[left] <= pivot:left = left + 1while left <= right and arr[right] >= pivot:right = right - 1if right < left:breakelse:arr[left], arr[right] = arr[right], arr[left]arr[low], arr[right] = arr[right], arr[low]return right# # 示例
# unsorted_list = [3, 6, 8, 10, 1, 2, 1]
# quick_sort(unsorted_list, 0, len(unsorted_list) - 1)
# print(unsorted_list)  # 输出：[1, 1, 2, 3, 6, 8, 10]if __name__ == '__main__':# arr = [12, 11, 13, 5, 6, 7]# sorted_arr = quick_sort(arr)# print("排序后的数组：", sorted_arr)nums = [5, 3, 4, 2, 1]# nums = [12, 11, 13, 5, 6, 7]# nums = [3, 6, 8, 10, 1, 2, 1]quick_sort(nums, 0, len(nums)-1)print("nums: ", nums)

7. 堆排序

在这里插入图片描述

图7摘自菜鸟教程
  1. 堆排序
    1. 维护堆的性质 复杂度O(logn)
      父节点大于等于左孩子与右孩子， 不满足的话依次和左孩子进行交换
    2. 建立大顶堆， 倒序依次遍历父节点n//2 -1 建立大顶堆
    3. 堆排序
      逐个从堆中提取最大值，并将其放置到已排序部分的末尾。
      提取的方式是将根节点与最后一个节点交换，然后对根节点进行堆化。

复杂度：始终为O(nlogn)，且不需要额外空间。
稳定性：不稳定排序算法。
使用场景：适用于大规模数据，且对内存要求较高，适合外部排序。
详细介绍: https://www.runoob.com/w3cnote/heap-sort.html
视频讲解: https://www.bilibili.com/video/BV1fp4y1D7cj

"""
7. 堆排序1. 维护堆的性质 复杂度O(logn)父节点大于等于左孩子与右孩子， 不满足的话依次和左孩子进行交换2. 维护大顶堆， 倒序依次遍历父节点  建立大顶堆3. 堆排序逐个从堆中提取最大值，并将其放置到已排序部分的末尾。提取的方式是将根节点与最后一个节点交换，然后对根节点进行堆化。复杂度：始终为O(nlogn)，且不需要额外空间。
稳定性：不稳定排序算法。
使用场景：适用于大规模数据，且对内存要求较高，适合外部排序。
详细介绍: https://www.runoob.com/w3cnote/heap-sort.html
视频讲解: https://www.bilibili.com/video/BV1fp4y1D7cj
"""def heapify(arr, n, i):     # 1.用来维护堆的性质""":param arr: 存储堆的数组:param n:   数组长度:param i:   待维护节点的下标:return:"""largest = i         # 初始化最大元素索引为根节点lson = 2 * i + 1    # 左子节点索引rson = 2 * i + 2   # 右子节点索引# 找到左右子节点中较大的索引if lson < n and arr[lson] > arr[largest]:largest = lsonif rson < n and arr[rson] > arr[largest]:largest = rson# 如果最大值不是根节点，则交换根节点与最大值if largest != i:arr[i], arr[largest] = arr[largest], arr[i]# 递归对受影响的子树进行堆化heapify(arr, n, largest)# 堆排序
def heap_sort(arr):n = len(arr)# 倒序依次遍历父节点，通过维护堆的性质， 构建大顶堆 注意这里n是数组长度而不是索引for i in range(n // 2 - 1, -1, -1):heapify(arr, n, i)# 一个个提取元素从堆排序for i in range(n - 1, 0, -1):arr[i], arr[0] = arr[0], arr[i]  # 交换根节点与最后一个节点heapify(arr, i, 0)  # 对剩余的堆进行堆化, 这里传入的是i, 交换之后已经脱离了if __name__ == '__main__':# 示例unsorted_list = [12, 11, 13, 5, 6, 7]heap_sort(unsorted_list)print(unsorted_list)  # 输出：[5, 6, 7, 11, 12, 13]

8 计数排序

在这里插入图片描述

图8摘自菜鸟教程
  1. 堆排序
    适用场景: 计数排序要求输入的数据必须是有确定范围的整数。
    （1）找出待排序的数组中最大和最小的元素
    （2）统计数组中每个值为i的元素出现的次数，存入数组C的第i项
    （3）对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）
    （4）反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1

稳定性：稳定排序算法。
复杂度: 最好情况下为O(n+k)，其中 k 表示数据范围。
使用场景：适用于数据范围不大，但是数据量较大的情况。
详细介绍: https://www.runoob.com/w3cnote/counting-sort.html
视频讲解: https://www.bilibili.com/video/BV1KU4y1M7VY

"""
8. 堆排序适用场景: 计数排序要求输入的数据必须是有确定范围的整数。（1）找出待排序的数组中最大和最小的元素（2）统计数组中每个值为i的元素出现的次数，存入数组C的第i项（3）对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）（4）反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1稳定性：稳定排序算法。
复杂度: 最好情况下为O(n+k)，其中 k 表示数据范围。
使用场景：适用于数据范围不大，但是数据量较大的情况。
详细介绍: https://www.runoob.com/w3cnote/counting-sort.html
视频讲解: https://www.bilibili.com/video/BV1KU4y1M7VY
"""
def countingSort(arr):maxValue = float("-inf")for element in arr:maxValue = max(maxValue, element)maxLen = maxValue+1countArray = [0] * maxLensortedIndex = 0arrLen = len(arr)for i in range(arrLen):# if not bucket[arr[i]]:#     bucket[arr[i]]=0countArray[arr[i]] += 1print(countArray)for j in range(maxLen):while countArray[j] > 0:arr[sortedIndex] = jsortedIndex += 1countArray[j] -= 1return arr
if __name__ == '__main__':# 示例unsorted_list = [12, 11, 13, 5, 6, 7]countingSort(unsorted_list)print(unsorted_list)  # 输出：[5, 6, 7, 11, 12, 13]

总结

稳定的排序方法有：

冒泡排序、插入排序、归并排序、计数排序。

不稳定的排序方法有

选择排序， 希尔排序， 快速排序， 堆排序

对于数据量少的情况

通常使用
插入排序或冒泡排序，因为它们的常数因子较小，适用于小规模数据集。

对于数据量较大的情况

  1. 归并排序：适用于大规模数据，效率稳定，但需要额外的内存空间。
  2. 快速排序：适用于大规模数据，平均情况下效率较高，但在最坏情况下可能会退化为 O(n^2)。
  3. 堆排序：适用于大规模数据，不需要额外空间，但常数因子较大，效率稍低于快速排序。

数据范围不大，数据量较大的情况

计数排序适用于数据范围不大，数据量较大的情况，但由于它需要额外的数组存储计数信息，所以适用场景相对有限。
在实际应用中，根据数据量大小、稳定性要求、时间复杂度等因素综合考虑，选择适合的排序方法能够提高程序的性能。
快速排序经常考， 如果只掌握一个排序算法的话，首选快速排序算法

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://xiahunao.cn/news/1619796.html

如若内容造成侵权/违法违规/事实不符，请联系瞎胡闹网进行投诉反馈，一经查实，立即删除！

相关文章

Ubuntu 3D桌面

Ubuntu 3D桌面

转自http://forum.ubuntu.org.cn/viewtopic.php?f94&t140531 [2010年8月17日更新] Ubuntu Linux 3D桌面完全教程&#xff0c;显卡驱动安装方法&#xff0c;compiz特效介绍&#xff0c;常见问题解答。 本教程的前身是一善鱼编写并发布在Ubuntu中文论坛forum.ubuntu.org.cn3…
阅读更多...
xendesktop更新计算机,XenDesktop7.12发布Win10周年更新版桌面

xendesktop更新计算机,XenDesktop7.12发布Win10周年更新版桌面

在上一篇XenCenter配置的资源池的基础上&#xff0c;本篇将使用该资源池作为基础环境搭建XenDesktop7.12发布Win10周年更新版桌面&#xff0c;XenDesktop7.12是上个月(2016年12月)才发布的版本&#xff0c;是目前最新版。本篇的主要内容包括&#xff1a;XenDesktop7.12安装、创…
阅读更多...
2020网吧无盘服务器配置,云更新 2020.5.15.14195_x64 | 专业网吧维护

2020网吧无盘服务器配置,云更新 2020.5.15.14195_x64 | 专业网吧维护

重点功能&#xff1a; 1.增强软件安全性 2.优化无盘启动&#xff0c;支持BIOS、UEFI、通用镜像自动适配 3.增加镜像转换工具&#xff0c;支持将BIOS或UEFI镜像转换为通用镜像 4.增加显卡纹理质量和低延迟模式的设置 其他更新&#xff1a; 5.优化显示器信息采集功能 6.优化控制台…
阅读更多...
BM80 买卖股票的最好时机(一)

BM80 买卖股票的最好时机(一)

目录 1.题目描述 2.题目分析 3.编写代码 4.总结 这是牛客网上的一道题目 1.题目描述 题目链接&#xff1a;买卖股票的最好时机(一)_牛客题霸_牛客网 (nowcoder.com) 2.题目分析 我们看到这个题目中一个数组表示每一天的股价&#xff0c;那么最大利润怎么算呢&#xff0c…
阅读更多...
MFC界面库

MFC界面库

好东西&#xff0c;果断收藏 刚开始用C做界面的时候&#xff0c;根本不知道怎么用简陋的MFC控件做出比较美观的界面&#xff0c;后来就开始逐渐接触到BCG Xtreme ToolkitPro v15.0.1&#xff0c;Skin,等界面库&#xff0c;以及一些网友自己写的界面库&#xff0c;开始对于C软件…
阅读更多...
android开源库合集

android开源库合集

android开源库合集 1、阿里巴巴开源的自定义viewpager&#xff0c;支持多重动画&#xff0c;横向纵向&#xff0c;多页面显示 项目地址&#xff1a;https://github.com/alibaba/UltraViewPager 2、android版本更新功能。使用retrfit2 rxjava2 okhttp3实现多文件多线程下载&am…
阅读更多...
10个前端动画库让你的交互更加炫酷

10个前端动画库让你的交互更加炫酷

Animate.css animate.css 是一个使用CSS3的animation制作的动画效果的CSS集合，里面预设了很多种常用的动画，且使用非常简单。 GitHub：github.com/animate-css… Hover.css Hover.css 是一套基于 CSS3 的鼠标悬停效果和动画，这些可以非常轻松的被应用到按钮、LOGO 以及图…
阅读更多...
VUE 常用炫酷动画库（拿来即用系列）

VUE 常用炫酷动画库（拿来即用系列）

目录 打字机效果Vue动画库 代码示例 效果 炫酷背景动画库 代码示例 效果 打字机效果Vue动画库 npm install vue-typical 代码示例 <template><div><v-typicalclass"blink":steps"[Hello, 1000, Hello World !, 600, Hello World ! &#…
阅读更多...
NPM酷库：lru-cache 基于内存的缓存管理

NPM酷库：lru-cache 基于内存的缓存管理

NPM酷库&#xff0c;每天两分钟&#xff0c;了解一个流行NPM库。 为了优化程序性能&#xff0c;我们常常需要奖数据缓存起来&#xff0c;根据实际情况&#xff0c;我们可以将数据存储到磁盘、数据库、redis等。 但是有时候要缓存的数据量非常小&#xff0c;或者项目规模非常小&…
阅读更多...
NPM酷库：jsdom，纯JS实现的DOM

NPM酷库：jsdom，纯JS实现的DOM

NPM酷库&#xff0c;每天两分钟&#xff0c;了解一个流行NPM库。 昨天认识了一个在Node.js环境下操作HTML的库 cheerio&#xff0c;cheerio实现了jQuery接口&#xff0c;用起来十分方便。为什么不直接用jQuery呢&#xff1f;因为Node.js环境中没有实现DOM对象。 jsdom 今天&…
阅读更多...
NPM酷库：string-random，生成随机字符串

NPM酷库：string-random，生成随机字符串

NPM酷库&#xff0c;每天两分钟&#xff0c;了解一个流行NPM库。 昨天&#xff0c;我们了解了如何使用uuid库快速生成UUID&#xff0c;UUID适用于分布式应用中ID的生成&#xff0c;因为UUID足够长&#xff0c;所以碰撞几率非常低。 此外&#xff0c;我们在很多时候不需要生成像…
阅读更多...
NPM酷库：vm2，安全的沙箱环境

NPM酷库：vm2，安全的沙箱环境

NPM酷库&#xff0c;每天两分钟&#xff0c;了解一个流行NPM库。 今天我们要了解的库是 vm2&#xff0c;则是一个Node.js 官方 vm 库的替代品&#xff0c;主要解决了安全问题。 不安全的vm 在Node.js官方标准库中有一个vm库&#xff0c;用来在V8虚拟机环境中编译执行JS代码。通…
阅读更多...
NPM酷库：uuid，生成随机ID

NPM酷库：uuid，生成随机ID

NPM酷库&#xff0c;每天两分钟&#xff0c;了解一个流行NPM库。 在中心化应用中&#xff0c;数据记录的ID往往是数据库生成的自增ID&#xff0c;但是在分布式应用中&#xff0c;就会存在一些问题&#xff1a; 保存数据之前就需要给数据标识ID数据规模超级大&#xff0c;中央数…
阅读更多...
NPM酷库：chokidar监视文件变化

NPM酷库：chokidar监视文件变化

NPM酷库&#xff0c;每天两分钟&#xff0c;了解一个流行NPM库。 像 webpack / grunt /gulp 等工具都提供watch模式&#xff0c;当磁盘文件变化后自动重新运行打包。今天我们要学习的chokidar就是一款专门用于文件监控的库。 Node.js 标准库 其实Node.js 标准库中提供 fs.watch…
阅读更多...
这几十个前端炫酷库你都知道吗？

这几十个前端炫酷库你都知道吗？

茶已备好&#xff0c;只待君来&#xff01;感谢关注 前端点线面 (>‿<&#xff09;&#xff0c;本号定期推荐原创深度好文&#xff0c;帮助每一位在前端领域打拼的伙伴们走向前列&#xff0c;此外关注我获取最前沿知识点、海量学习资料、《前端百题斩》、大量思维导图&am…
阅读更多...
NPM酷库：ip，IP地址处理

NPM酷库：ip，IP地址处理

NPM酷库&#xff0c;每天两分钟&#xff0c;了解一个流行NPM库。 今天我们来了解一个专门用来处理IP地址的库&#xff1a;ip&#xff0c;ip库能够获取本机IP地址、比较、转换、掩码/子网计算等各种和网络IP相关的操作&#xff1a; const ip require(ip);// 获取本机网卡IP ip.…
阅读更多...
NPM酷库：globby，增强版的glob

NPM酷库：globby，增强版的glob

NPM酷库&#xff0c;每天两分钟&#xff0c;了解一个流行NPM库。 昨天&#xff0c;我们学习了一个新库 glob&#xff0c;用于模式匹配目录文件。今天&#xff0c;我们要了解的globby&#xff0c;是基于 glob&#xff0c;并进一步得到了增强了功能。 globby 特性 相对于 glob&am…
阅读更多...
vue2 路由入门

vue2 路由入门

一、单页应用程序介绍 1.概念 单页应用程序&#xff1a;SPA【Single Page Application】是指所有的功能都在一个html页面上实现 2.具体示例 单页应用网站&#xff1a; 网易云音乐 https://music.163.com/ 多页应用网站&#xff1a;京东 https://jd.com/ 3.单页应用 VS 多页…
阅读更多...
c++ 判断基类指针指向的真实对象类型

c++ 判断基类指针指向的真实对象类型

在 c 面向对象使用中&#xff0c;我们常常会定义一个基类类型的指针&#xff0c;在运行过程中&#xff0c;这个指针可能指向一个基类类型的对象&#xff0c;也可能指向的是其子类类型的对象&#xff0c;那现在问题来了&#xff0c;我们如何去判断这个指针到底执行了一个什么类型…
阅读更多...
Markdown中的LaTeX公式详解

Markdown中的LaTeX公式详解

引言 LaTeX是一种用于排版科学和数学文档的排版系统&#xff0c;它能够以高质量的方式生成复杂的数学公式。在CSDN&#xff08;Cnblogs和CSDN&#xff09;这样的博客平台中&#xff0c;也支持使用LaTeX语法插入数学公式。本文将详细介绍在CSDN中使用LaTeX公式的方法和常用语法&…
阅读更多...
最新文章

Copyright @ 2022~2023