小白备战大厂算法笔试(九)——九大排序算法

news2024/11/19 10:28:22

文章目录

  • 排序
    • 选择排序
    • 冒泡排序
    • 插入排序
    • 快速排序
      • 基准数优化
      • 尾递归优化
    • 归并排序
    • 堆排序
    • 桶排序
    • 计数排序
    • 基数排序
    • 排序算法对比

排序

评价维度：

  • 运行效率：我们期望排序算法的时间复杂度尽量低，且总体操作数量较少（即时间复杂度中的常数项降低）。对于大数据量情况，运行效率显得尤为重要。

  • 就地性：顾名思义，原地排序通过在原数组上直接操作实现排序，无须借助额外的辅助数组，从而节省内存。通常情况下，原地排序的数据搬运操作较少，运行速度也更快。

  • 稳定性：稳定排序在完成排序后，相等元素在数组中的相对顺序不发生改变。稳定排序是多级排序场景的必要条件。假设我们有一个存储学生信息的表格，第 1 列和第 2 列分别是姓名和年龄。在这种情况下，非稳定排序可能导致输入数据的有序性丧失。

# 输入数据是按照姓名排序好的
# (name, age)
  ('A', 19)
  ('B', 18)
  ('C', 21)
  ('D', 19)
  ('E', 23)

# 假设使用非稳定排序算法按年龄排序列表，
# 结果中 ('D', 19) 和 ('A', 19) 的相对位置改变，
# 输入数据按姓名排序的性质丢失
  ('B', 18)
  ('D', 19)
  ('A', 19)
  ('C', 21)
  ('E', 23)

  • 自适应性：自适应排序的时间复杂度会受输入数据的影响，即最佳、最差、平均时间复杂度并不完全相等。自适应性需要根据具体情况来评估。如果最差时间复杂度差于平均时间复杂度，说明排序算法在某些数据下性能可能劣化，因此被视为负面属性；而如果最佳时间复杂度优于平均时间复杂度，则被视为正面属性。

  • 是否基于比较：基于比较的排序依赖于比较运算符（<、=、>）来判断元素的相对顺序，从而排序整个数组，理论最优时间复杂度为 O(nlog⁡n) 。而非比较排序不使用比较运算符，时间复杂度可达 O(n) ，但其通用性相对较差。

理想排序算法应当运行快、原地、稳定、正向自适应、通用性好。

选择排序

选择排序的工作原理非常直接：开启一个循环，每轮从未排序区间选择最小的元素，将其放到已排序区间的末尾。

设数组的长度为 n，选择排序的算法流程如图 11-2 所示。

  1. 初始状态下，所有元素未排序，即未排序（索引）区间为 [0,n−1] 。
  2. 选取区间 [0,n−1] 中的最小元素，将其与索引 0 处元素交换。完成后，数组前 1 个元素已排序。
  3. 选取区间 [1,n−1] 中的最小元素，将其与索引 1 处元素交换。完成后，数组前 2 个元素已排序。
  4. 以此类推。经过 n−1 轮选择与交换后，数组前 n−1 个元素已排序。
  5. 仅剩的一个元素必定是最大元素，无须排序，因此数组排序完成。

image-20230914155717264

image-20230914155758034

image-20230914155806660

image-20230914155816305

image-20230914155823421

image-20230914155830231

image-20230914155837466

image-20230914155846707

image-20230914155853746

image-20230914155900206

image-20230914155906541

在代码中，用 k 来记录未排序区间内的最小元素。

Python：

def selection_sort(nums: list[int]):
    """选择排序"""
    n = len(nums)
    # 外循环：未排序区间为 [i, n-1]
    for i in range(n - 1):
        # 内循环：找到未排序区间内的最小元素
        k = i
        for j in range(i + 1, n):
            if nums[j] < nums[k]:
                k = j  # 记录最小元素的索引
        # 将该最小元素与未排序区间的首个元素交换
        nums[i], nums[k] = nums[k], nums[i]

Go：

/* 选择排序 */
func selectionSort(nums []int) {
    n := len(nums)
    // 外循环：未排序区间为 [i, n-1]
    for i := 0; i < n-1; i++ {
        // 内循环：找到未排序区间内的最小元素
        k := i
        for j := i + 1; j < n; j++ {
            if nums[j] < nums[k] {
                // 记录最小元素的索引
                k = j
            }
        }
        // 将该最小元素与未排序区间的首个元素交换
        nums[i], nums[k] = nums[k], nums[i]

    }
}
  • 时间复杂度为 O(n^2)、非自适应排序：外循环共 n−1 轮，第一轮的未排序区间长度为 n ，最后一轮的未排序区间长度为 2 ，即各轮外循环分别包含 n、n−1、…、3、2 轮内循环，求和为 (n−1)(n+2)2 。
  • 空间复杂度 O(1)、原地排序：指针 i 和 j 使用常数大小的额外空间。
  • 非稳定排序：元素 nums[i] 有可能被交换至与其相等的元素的右边，导致两者相对顺序发生改变。

image-20230914163642987

冒泡排序

冒泡排序通过连续地比较与交换相邻元素实现排序。冒泡过程可以利用元素交换操作来模拟：从数组最左端开始向右遍历，依次比较相邻元素大小，如果“左元素 > 右元素”就交换它俩。遍历完成后，最大的元素会被移动到数组的最右端。

设数组的长度为 n ，冒泡排序的步骤如下：

  1. 首先，对 n 个元素执行“冒泡”，将数组的最大元素交换至正确位置，
  2. 接下来，对剩余 n−1 个元素执行“冒泡”，将第二大元素交换至正确位置。
  3. 以此类推，经过 n−1 轮“冒泡”后，前 n−1 大的元素都被交换至正确位置。
  4. 仅剩的一个元素必定是最小元素，无须排序，因此数组排序完成。

image-20230914165005294

Python：

def bubble_sort(nums: list[int]):
    """冒泡排序"""
    n = len(nums)
    # 外循环：未排序区间为 [0, i]
    for i in range(n - 1, 0, -1):
        # 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
        for j in range(i):
            if nums[j] > nums[j + 1]:
                # 交换 nums[j] 与 nums[j + 1]
                nums[j], nums[j + 1] = nums[j + 1], nums[j]

Go：

/* 冒泡排序 */
func bubbleSort(nums []int) {
    // 外循环：未排序区间为 [0, i]
    for i := len(nums) - 1; i > 0; i-- {
        // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
        for j := 0; j < i; j++ {
            if nums[j] > nums[j+1] {
                // 交换 nums[j] 与 nums[j + 1]
                nums[j], nums[j+1] = nums[j+1], nums[j]
            }
        }
    }
}

如果某轮“冒泡”中没有执行任何交换操作，说明数组已经完成排序，可直接返回结果。因此，可以增加一个标志位 flag 来监测这种情况，一旦出现就立即返回。经过优化，冒泡排序的最差和平均时间复杂度仍为 O(n^2) ；但当输入数组完全有序时，可达到最佳时间复杂度 O(n) 。

Python：

def bubble_sort_with_flag(nums: list[int]):
    """冒泡排序（标志优化）"""
    n = len(nums)
    # 外循环：未排序区间为 [0, i]
    for i in range(n - 1, 0, -1):
        flag = False  # 初始化标志位
        # 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
        for j in range(i):
            if nums[j] > nums[j + 1]:
                # 交换 nums[j] 与 nums[j + 1]
                nums[j], nums[j + 1] = nums[j + 1], nums[j]
                flag = True  # 记录交换元素
        if not flag:
            break  # 此轮冒泡未交换任何元素，直接跳出

Go：

/* 冒泡排序（标志优化）*/
func bubbleSortWithFlag(nums []int) {
    // 外循环：未排序区间为 [0, i]
    for i := len(nums) - 1; i > 0; i-- {
        flag := false // 初始化标志位
        // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
        for j := 0; j < i; j++ {
            if nums[j] > nums[j+1] {
                // 交换 nums[j] 与 nums[j + 1]
                nums[j], nums[j+1] = nums[j+1], nums[j]
                flag = true // 记录交换元素
            }
        }
        if flag == false { // 此轮冒泡未交换任何元素，直接跳出
            break
        }
    }
}
  • 时间复杂度为 O(n^2)、自适应排序：各轮“冒泡”遍历的数组长度依次为 n−1、n−2、…、2、1 ，总和为 (n−1)n/2 。在引入 flag 优化后，最佳时间复杂度可达到 O(n) 。
  • 空间复杂度为 O(1)、原地排序：指针 i 和 j 使用常数大小的额外空间。
  • 稳定排序：由于在“冒泡”中遇到相等元素不交换。

插入排序

插入排序是一种简单的排序算法，它的工作原理与手动整理一副牌的过程非常相似。

具体来说，在未排序区间选择一个基准元素，将该元素与其左侧已排序区间的元素逐一比较大小，并将该元素插入到正确的位置。

插入排序的整体流程如下：

  1. 初始状态下，数组的第 1 个元素已完成排序。
  2. 选取数组的第 2 个元素作为 base ，将其插入到正确位置后，数组的前 2 个元素已排序。
  3. 选取第 3 个元素作为 base ，将其插入到正确位置后，数组的前 3 个元素已排序。
  4. 以此类推，在最后一轮中，选取最后一个元素作为 base ，将其插入到正确位置后，所有元素均已排序。

image-20230914172931044

Python：

def insertion_sort(nums: list[int]):
    """插入排序"""
    # 外循环：已排序区间为 [0, i-1]
    for i in range(1, len(nums)):
        base = nums[i]
        j = i - 1
        # 内循环：将 base 插入到已排序区间 [0, i-1] 中的正确位置
        while j >= 0 and nums[j] > base:
            nums[j + 1] = nums[j]  # 将 nums[j] 向右移动一位
            j -= 1
        nums[j + 1] = base  # 将 base 赋值到正确位置

Go：

/* 插入排序 */
func insertionSort(nums []int) {
    // 外循环：未排序区间为 [0, i]
    for i := 1; i < len(nums); i++ {
        base := nums[i]
        j := i - 1
        // 内循环：将 base 插入到已排序部分的正确位置
        for j >= 0 && nums[j] > base {
            nums[j+1] = nums[j] // 将 nums[j] 向右移动一位
            j--
        }
        nums[j+1] = base // 将 base 赋值到正确位置
    }
}
  • 时间复杂度 O(n^2)、自适应排序：最差情况下，每次插入操作分别需要循环 n−1、n−2、…、2、1 次，求和得到 (n−1)n/2 ，因此时间复杂度为 O(n^2) 。在遇到有序数据时，插入操作会提前终止。当输入数组完全有序时，插入排序达到最佳时间复杂度 O(n) 。
  • 空间复杂度 O(1)、原地排序：指针 i 和 j 使用常数大小的额外空间。
  • 稳定排序：在插入操作过程中，我们会将元素插入到相等元素的右侧，不会改变它们的顺序。

虽然冒泡排序、选择排序和插入排序的时间复杂度都为 O(n^2) ，但在实际情况中，插入排序的使用频率显著高于冒泡排序和选择排序，主要有以下原因。

  • 冒泡排序基于元素交换实现，需要借助一个临时变量，共涉及 3 个单元操作；插入排序基于元素赋值实现，仅需 1 个单元操作。因此，冒泡排序的计算开销通常比插入排序更高。
  • 选择排序在任何情况下的时间复杂度都为 O(n^2) 。如果给定一组部分有序的数据，插入排序通常比选择排序效率更高。
  • 选择排序不稳定，无法应用于多级排序。

快速排序

快速排序是一种基于分治策略的排序算法，运行高效，应用广泛。

快速排序的核心操作是“哨兵划分”，其目标是：选择数组中的某个元素作为“基准数”，将所有小于基准数的元素移到其左侧，而大于基准数的元素移到其右侧。

  1. 选取数组最左端元素作为基准数，初始化两个指针 i 和 j 分别指向数组的两端。
  2. 设置一个循环，在每轮中使用 i（j）分别寻找第一个比基准数大（小）的元素，然后交换这两个元素。
  3. 循环执行步骤 2. ，直到 i 和 j 相遇时停止，最后将基准数交换至两个子数组的分界线。

image-20230915150637977

image-20230915150653673

image-20230915150726605

image-20230915150740941

image-20230915150748836

image-20230915150757297

image-20230915150805277

image-20230915150812855

image-20230915150822427

哨兵划分完成后，原数组被划分成三部分：左子数组、基准数、右子数组，且满足“左子数组任意元素 ≤ 基准数 ≤ 右子数组任意元素”。接下来只需对这两个子数组进行排序。哨兵划分的实质是将一个较长数组的排序问题简化为两个较短数组的排序问题。然后，对左子数组和右子数组分别递归执行“哨兵划分”。持续递归，直至子数组长度为 1 时终止，从而完成整个数组的排序。

image-20230915152943600

Python：

def partition(self, nums: list[int], left: int, right: int) -> int:
    """哨兵划分"""
    # 以 nums[left] 作为基准数
    i, j = left, right
    while i < j:
        while i < j and nums[j] >= nums[left]:
            j -= 1  # 从右向左找首个小于基准数的元素
        while i < j and nums[i] <= nums[left]:
            i += 1  # 从左向右找首个大于基准数的元素
        # 元素交换
        nums[i], nums[j] = nums[j], nums[i]
    # 将基准数交换至两子数组的分界线
    nums[i], nums[left] = nums[left], nums[i]
    return i  # 返回基准数的索引

def quick_sort(self, nums: list[int], left: int, right: int):
    """快速排序"""
    # 子数组长度为 1 时终止递归
    if left >= right:
        return
    # 哨兵划分
    pivot = self.partition(nums, left, right)
    # 递归左子数组、右子数组
    self.quick_sort(nums, left, pivot - 1)
    self.quick_sort(nums, pivot + 1, right)

Go:

/* 哨兵划分 */
func (q *quickSort) partition(nums []int, left, right int) int {
    // 以 nums[left] 作为基准数
    i, j := left, right
    for i < j {
        for i < j && nums[j] >= nums[left] {
            j-- // 从右向左找首个小于基准数的元素
        }
        for i < j && nums[i] <= nums[left] {
            i++ // 从左向右找首个大于基准数的元素
        }
        // 元素交换
        nums[i], nums[j] = nums[j], nums[i]
    }
    // 将基准数交换至两子数组的分界线
    nums[i], nums[left] = nums[left], nums[i]
    return i // 返回基准数的索引
}

/* 快速排序 */
func (q *quickSort) quickSort(nums []int, left, right int) {
    // 子数组长度为 1 时终止递归
    if left >= right {
        return
    }
    // 哨兵划分
    pivot := q.partition(nums, left, right)
    // 递归左子数组、右子数组
    q.quickSort(nums, left, pivot-1)
    q.quickSort(nums, pivot+1, right)
}
  • 时间复杂度 O(nlog⁡n)、自适应排序：在平均情况下，哨兵划分的递归层数为 log⁡n ，每层中的总循环数为 n ，总体使用 O(nlog⁡n) 时间。在最差情况下，每轮哨兵划分操作都将长度为 n 的数组划分为长度为 0 和 n−1 的两个子数组，此时递归层数达到 n 层，每层中的循环数为 n ，总体使用 O(n^2) 时间。
  • 空间复杂度 O(n)、原地排序：在输入数组完全倒序的情况下，达到最差递归深度 n ，使用 O(n) 栈帧空间。排序操作是在原数组上进行的，未借助额外数组。
  • 非稳定排序：在哨兵划分的最后一步，基准数可能会被交换至相等元素的右侧。

image-20230915155404567

尽管快速排序的平均时间复杂度与“归并排序”和“堆排序”相同，但通常快速排序的效率更高，主要有以下原因。

  • 出现最差情况的概率很低：虽然快速排序的最差时间复杂度为 O(n^2) ，没有归并排序稳定，但在绝大多数情况下，快速排序能在 O(nlog⁡n) 的时间复杂度下运行。
  • 缓存使用效率高：在执行哨兵划分操作时，系统可将整个子数组加载到缓存，因此访问元素的效率较高。而像“堆排序”这类算法需要跳跃式访问元素，从而缺乏这一特性。
  • 复杂度的常数系数低：在上述三种算法中，快速排序的比较、赋值、交换等操作的总数量最少。这与“插入排序”比“冒泡排序”更快的原因类似。

基准数优化

快速排序在某些输入下的时间效率可能降低。举一个极端例子，假设输入数组是完全倒序的，由于我们选择最左端元素作为基准数，那么在哨兵划分完成后，基准数被交换至数组最右端，导致左子数组长度为 n−1、右子数组长度为 0 。如此递归下去，每轮哨兵划分后的右子数组长度都为 0 ，分治策略失效，快速排序退化为“冒泡排序”。为了尽量避免这种情况发生，可以优化哨兵划分中的基准数的选取策略。可以在数组中选取三个候选元素（通常为数组的首、尾、中点元素），并将这三个候选元素的中位数作为基准数。这样一来，基准数“既不太小也不太大”的概率将大幅提升。当然，还可以选取更多候选元素，以进一步提高算法的稳健性。采用这种方法后，时间复杂度劣化至 O(n^2) 的概率大大降低。

Python：

def median_three(self, nums: list[int], left: int, mid: int, right: int) -> int:
    """选取三个元素的中位数"""
    # 此处使用异或运算来简化代码
    # 异或规则为 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1
    if (nums[left] < nums[mid]) ^ (nums[left] < nums[right]):
        return left
    elif (nums[mid] < nums[left]) ^ (nums[mid] < nums[right]):
        return mid
    return right

def partition(self, nums: list[int], left: int, right: int) -> int:
    """哨兵划分（三数取中值）"""
    # 以 nums[left] 作为基准数
    med = self.median_three(nums, left, (left + right) // 2, right)
    # 将中位数交换至数组最左端
    nums[left], nums[med] = nums[med], nums[left]
    # 以 nums[left] 作为基准数
    i, j = left, right
    while i < j:
        while i < j and nums[j] >= nums[left]:
            j -= 1  # 从右向左找首个小于基准数的元素
        while i < j and nums[i] <= nums[left]:
            i += 1  # 从左向右找首个大于基准数的元素
        # 元素交换
        nums[i], nums[j] = nums[j], nums[i]
    # 将基准数交换至两子数组的分界线
    nums[i], nums[left] = nums[left], nums[i]
    return i  # 返回基准数的索引

Go：

/* 选取三个元素的中位数 */
func (q *quickSortMedian) medianThree(nums []int, left, mid, right int) int {
    // 此处使用异或运算来简化代码（!= 在这里起到异或的作用）
    // 异或规则为 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1
    if (nums[left] < nums[mid]) != (nums[left] < nums[right]) {
        return left
    } else if (nums[mid] < nums[left]) != (nums[mid] < nums[right]) {
        return mid
    }
    return right
}

/* 哨兵划分（三数取中值）*/
func (q *quickSortMedian) partition(nums []int, left, right int) int {
    // 以 nums[left] 作为基准数
    med := q.medianThree(nums, left, (left+right)/2, right)
    // 将中位数交换至数组最左端
    nums[left], nums[med] = nums[med], nums[left]
    // 以 nums[left] 作为基准数
    i, j := left, right
    for i < j {
        for i < j && nums[j] >= nums[left] {
            j-- //从右向左找首个小于基准数的元素
        }
        for i < j && nums[i] <= nums[left] {
            i++ //从左向右找首个大于基准数的元素
        }
        //元素交换
        nums[i], nums[j] = nums[j], nums[i]
    }
    //将基准数交换至两子数组的分界线
    nums[i], nums[left] = nums[left], nums[i]
    return i //返回基准数的索引
}

尾递归优化

在某些输入下，快速排序可能占用空间较多。以完全倒序的输入数组为例，由于每轮哨兵划分后右子数组长度为 0 ，递归树的高度会达到 n−1 ，此时需要占用 O(n) 大小的栈帧空间。为了防止栈帧空间的累积，我们可以在每轮哨兵排序完成后，比较两个子数组的长度，仅对较短的子数组进行递归。由于较短子数组的长度不会超过 n/2 ，因此这种方法能确保递归深度不超过 log⁡n ，从而将最差空间复杂度优化至 O(log⁡n) 。

Pyhton：

def quick_sort(self, nums: list[int], left: int, right: int):
    """快速排序（尾递归优化）"""
    # 子数组长度为 1 时终止
    while left < right:
        # 哨兵划分操作
        pivot = self.partition(nums, left, right)
        # 对两个子数组中较短的那个执行快排
        if pivot - left < right - pivot:
            self.quick_sort(nums, left, pivot - 1)  # 递归排序左子数组
            left = pivot + 1  # 剩余未排序区间为 [pivot + 1, right]
        else:
            self.quick_sort(nums, pivot + 1, right)  # 递归排序右子数组
            right = pivot - 1  # 剩余未排序区间为 [left, pivot - 1]

Go:

/* 快速排序（尾递归优化）*/
func (q *quickSortTailCall) quickSort(nums []int, left, right int) {
    // 子数组长度为 1 时终止
    for left < right {
        // 哨兵划分操作
        pivot := q.partition(nums, left, right)
        // 对两个子数组中较短的那个执行快排
        if pivot-left < right-pivot {
            q.quickSort(nums, left, pivot-1) // 递归排序左子数组
            left = pivot + 1                 // 剩余未排序区间为 [pivot + 1, right]
        } else {
            q.quickSort(nums, pivot+1, right) // 递归排序右子数组
            right = pivot - 1                 // 剩余未排序区间为 [left, pivot - 1]
        }
    }
}

归并排序

归并排序是一种基于分治策略的排序算法，包含“划分”和“合并”阶段。

  1. 划分阶段：通过递归不断地将数组从中点处分开，将长数组的排序问题转换为短数组的排序问题。
  2. 合并阶段：当子数组长度为 1 时终止划分，开始合并，持续地将左右两个较短的有序数组合并为一个较长的有序数组，直至结束。

image-20230916112021379

“划分阶段”从顶至底递归地将数组从中点切分为两个子数组。

  1. 计算数组中点 mid ，递归划分左子数组（区间 [left, mid] ）和右子数组（区间 [mid + 1, right] ）。
  2. 递归执行步骤 1. ，直至子数组区间长度为 1 时，终止递归划分。

“合并阶段”从底至顶地将左子数组和右子数组合并为一个有序数组。需要注意的是，从长度为 1 的子数组开始合并，合并阶段中的每个子数组都是有序的。归并排序与二叉树后序遍历的递归顺序是一致的。

  • 后序遍历：先递归左子树，再递归右子树，最后处理根节点。
  • 归并排序：先递归左子数组，再递归右子数组，最后处理合并。

Python：

def merge(nums: list[int], left: int, mid: int, right: int):
    """合并左子数组和右子数组"""
    # 左子数组区间 [left, mid]
    # 右子数组区间 [mid + 1, right]
    # 初始化辅助数组
    tmp = list(nums[left : right + 1])
    # 左子数组的起始索引和结束索引
    left_start = 0
    left_end = mid - left
    # 右子数组的起始索引和结束索引
    right_start = mid + 1 - left
    right_end = right - left
    # i, j 分别指向左子数组、右子数组的首元素
    i = left_start
    j = right_start
    # 通过覆盖原数组 nums 来合并左子数组和右子数组
    for k in range(left, right + 1):
        # 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
        if i > left_end:
            nums[k] = tmp[j]
            j += 1
        # 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
        elif j > right_end or tmp[i] <= tmp[j]:
            nums[k] = tmp[i]
            i += 1
        # 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
        else:
            nums[k] = tmp[j]
            j += 1

def merge_sort(nums: list[int], left: int, right: int):
    """归并排序"""
    # 终止条件
    if left >= right:
        return  # 当子数组长度为 1 时终止递归
    # 划分阶段
    mid = (left + right) // 2  # 计算中点
    merge_sort(nums, left, mid)  # 递归左子数组
    merge_sort(nums, mid + 1, right)  # 递归右子数组
    # 合并阶段
    merge(nums, left, mid, right)

Go：

/* 合并左子数组和右子数组 */
// 左子数组区间 [left, mid]
// 右子数组区间 [mid + 1, right]
func merge(nums []int, left, mid, right int) {
    // 初始化辅助数组 借助 copy 模块
    tmp := make([]int, right-left+1)
    for i := left; i <= right; i++ {
        tmp[i-left] = nums[i]
    }
    // 左子数组的起始索引和结束索引
    leftStart, leftEnd := left-left, mid-left
    // 右子数组的起始索引和结束索引
    rightStart, rightEnd := mid+1-left, right-left
    // i, j 分别指向左子数组、右子数组的首元素
    i, j := leftStart, rightStart
    // 通过覆盖原数组 nums 来合并左子数组和右子数组
    for k := left; k <= right; k++ {
        // 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
        if i > leftEnd {
            nums[k] = tmp[j]
            j++
            // 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
        } else if j > rightEnd || tmp[i] <= tmp[j] {
            nums[k] = tmp[i]
            i++
            // 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
        } else {
            nums[k] = tmp[j]
            j++
        }
    }
}

/* 归并排序 */
func mergeSort(nums []int, left, right int) {
    // 终止条件
    if left >= right {
        return
    }
    // 划分阶段
    mid := (left + right) / 2
    mergeSort(nums, left, mid)
    mergeSort(nums, mid+1, right)
    // 合并阶段
    merge(nums, left, mid, right)
}

实现合并函数 merge() 存在以下难点。

  • 需要特别注意各个变量的含义。nums 的待合并区间为 [left, right] ，但由于 tmp 仅复制了 nums 该区间的元素，因此 tmp 对应区间为 [0, right - left] 。
  • 在比较 tmp[i] 和 tmp[j] 的大小时，还需考虑子数组遍历完成后的索引越界问题，即 i > leftEnd 和 j > rightEnd 的情况。索引越界的优先级是最高的，如果左子数组已经被合并完了，那么不需要继续比较，直接合并右子数组元素即可。

算法特性：

  • 时间复杂度 O(nlog⁡n)、非自适应排序：划分产生高度为 log⁡n 的递归树，每层合并的总操作数量为 n ，因此总体时间复杂度为 O(nlog⁡n) 。
  • 空间复杂度 O(n)、非原地排序：递归深度为 log⁡n ，使用 O(log⁡n) 大小的栈帧空间。合并操作需要借助辅助数组实现，使用 O(n) 大小的额外空间。
  • 稳定排序：在合并过程中，相等元素的次序保持不变。

堆排序

堆排序是一种基于堆数据结构实现的高效排序算法。可以利用“建堆操作”和“元素出堆操作”实现堆排序。

  1. 输入数组并建立小顶堆，此时最小元素位于堆顶。
  2. 不断执行出堆操作，依次记录出堆元素，即可得到从小到大排序的序列。

设数组的长度为 n：

  1. 输入数组并建立大顶堆。完成后，最大元素位于堆顶。
  2. 将堆顶元素（第一个元素）与堆底元素（最后一个元素）交换。完成交换后，堆的长度减 1 ，已排序元素数量加 1 。
  3. 从堆顶元素开始，从顶到底执行堆化操作（Sift Down）。完成堆化后，堆的性质得到修复。
  4. 循环执行第 2. 和 3. 步。循环 n−1 轮后，即可完成数组排序。

image-20230916174604587

image-20230916174659782

image-20230916174711026

image-20230916174722623

image-20230916174733095

image-20230916174743478

image-20230916174754378

image-20230916174802725

image-20230916174828849

image-20230916174839857

image-20230916174850861

image-20230916174859507

Python：

def sift_down(nums: list[int], n: int, i: int):
    """堆的长度为 n ，从节点 i 开始，从顶至底堆化"""
    while True:
        # 判断节点 i, l, r 中值最大的节点，记为 ma
        l = 2 * i + 1
        r = 2 * i + 2
        ma = i
        if l < n and nums[l] > nums[ma]:
            ma = l
        if r < n and nums[r] > nums[ma]:
            ma = r
        # 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
        if ma == i:
            break
        # 交换两节点
        nums[i], nums[ma] = nums[ma], nums[i]
        # 循环向下堆化
        i = ma

def heap_sort(nums: list[int]):
    """堆排序"""
    # 建堆操作：堆化除叶节点以外的其他所有节点
    for i in range(len(nums) // 2 - 1, -1, -1):
        sift_down(nums, len(nums), i)
    # 从堆中提取最大元素，循环 n-1 轮
    for i in range(len(nums) - 1, 0, -1):
        # 交换根节点与最右叶节点（即交换首元素与尾元素）
        nums[0], nums[i] = nums[i], nums[0]
        # 以根节点为起点，从顶至底进行堆化
        sift_down(nums, i, 0)

Go：

/* 堆的长度为 n ，从节点 i 开始，从顶至底堆化 */
func siftDown(nums *[]int, n, i int) {
    for true {
        // 判断节点 i, l, r 中值最大的节点，记为 ma
        l := 2*i + 1
        r := 2*i + 2
        ma := i
        if l < n && (*nums)[l] > (*nums)[ma] {
            ma = l
        }
        if r < n && (*nums)[r] > (*nums)[ma] {
            ma = r
        }
        // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
        if ma == i {
            break
        }
        // 交换两节点
        (*nums)[i], (*nums)[ma] = (*nums)[ma], (*nums)[i]
        // 循环向下堆化
        i = ma
    }
}

/* 堆排序 */
func heapSort(nums *[]int) {
    // 建堆操作：堆化除叶节点以外的其他所有节点
    for i := len(*nums)/2 - 1; i >= 0; i-- {
        siftDown(nums, len(*nums), i)
    }
    // 从堆中提取最大元素，循环 n-1 轮
    for i := len(*nums) - 1; i > 0; i-- {
        // 交换根节点与最右叶节点（即交换首元素与尾元素）
        (*nums)[0], (*nums)[i] = (*nums)[i], (*nums)[0]
        // 以根节点为起点，从顶至底进行堆化
        siftDown(nums, i, 0)
    }
}
  • 时间复杂度 O(nlog⁡n)、非自适应排序：建堆操作使用 O(n) 时间。从堆中提取最大元素的时间复杂度为 O(log⁡n) ，共循环 n−1 轮。
  • 空间复杂度 O(1)、原地排序：几个指针变量使用 O(1) 空间。元素交换和堆化操作都是在原数组上进行的。
  • 非稳定排序：在交换堆顶元素和堆底元素时，相等元素的相对位置可能发生变化。

桶排序

桶排序是分治策略的一个典型应用。它通过设置一些具有大小顺序的桶，每个桶对应一个数据范围，将数据平均分配到各个桶中；然后，在每个桶内部分别执行排序；最终按照桶的顺序将所有数据合并。考虑一个长度为 n 的数组，元素是范围 [0,1) 的浮点数。桶排序的流程如下图所示。

  1. 初始化 k 个桶，将 n 个元素分配到 k 个桶中。
  2. 对每个桶分别执行排序。
  3. 按照桶的从小到大的顺序，合并结果。

image-20230917164217813

Python：

def bucket_sort(nums: list[float]):
    """桶排序"""
    # 初始化 k = n/2 个桶，预期向每个桶分配 2 个元素
    k = len(nums) // 2
    buckets = [[] for _ in range(k)]
    # 1. 将数组元素分配到各个桶中
    for num in nums:
        # 输入数据范围 [0, 1)，使用 num * k 映射到索引范围 [0, k-1]
        i = int(num * k)
        # 将 num 添加进桶 i
        buckets[i].append(num)
    # 2. 对各个桶执行排序
    for bucket in buckets:
        # 使用内置排序函数，也可以替换成其他排序算法
        bucket.sort()
    # 3. 遍历桶合并结果
    i = 0
    for bucket in buckets:
        for num in bucket:
            nums[i] = num
            i += 1

Go：

/* 桶排序 */
func bucketSort(nums []float64) {
    // 初始化 k = n/2 个桶，预期向每个桶分配 2 个元素
    k := len(nums) / 2
    buckets := make([][]float64, k)
    for i := 0; i < k; i++ {
        buckets[i] = make([]float64, 0)
    }
    // 1. 将数组元素分配到各个桶中
    for _, num := range nums {
        // 输入数据范围 [0, 1)，使用 num * k 映射到索引范围 [0, k-1]
        i := int(num * float64(k))
        // 将 num 添加进桶 i
        buckets[i] = append(buckets[i], num)
    }
    // 2. 对各个桶执行排序
    for i := 0; i < k; i++ {
        // 使用内置切片排序函数，也可以替换成其他排序算法
        sort.Float64s(buckets[i])
    }
    // 3. 遍历桶合并结果
    i := 0
    for _, bucket := range buckets {
        for _, num := range bucket {
            nums[i] = num
            i++
        }
    }
}

桶排序适用于处理体量很大的数据。例如，输入数据包含 100 万个元素，由于空间限制，系统内存无法一次性加载所有数据。此时，可以将数据分成 1000 个桶，然后分别对每个桶进行排序，最后将结果合并。

  • 时间复杂度 O(n+k) ：假设元素在各个桶内平均分布，那么每个桶内的元素数量为 n/k 。假设排序单个桶使用 O(n/k log⁡n/k) 时间，则排序所有桶使用 O(n log⁡n/k) 时间。当桶数量 k 比较大时，时间复杂度则趋向于 O(n) 。合并结果时需要遍历所有桶和元素，花费 O(n+k) 时间。
  • 自适应排序：在最坏情况下，所有数据被分配到一个桶中，且排序该桶使用 O(n^2) 时间。
  • 空间复杂度 O(n+k)、非原地排序：需要借助 k 个桶和总共 n 个元素的额外空间。
  • 桶排序是否稳定取决于排序桶内元素的算法是否稳定。

桶排序的时间复杂度理论上可以达到 O(n) ，关键在于将元素均匀分配到各个桶中，因为实际数据往往不是均匀分布的。例如想要将淘宝上的所有商品按价格范围平均分配到 10 个桶中，但商品价格分布不均，低于 100 元的非常多，高于 1000 元的非常少。若将价格区间平均划分为 10 份，各个桶中的商品数量差距会非常大。为实现平均分配，可以先设定一个大致的分界线，将数据粗略地分到 3 个桶中。分配完毕后，再将商品较多的桶继续划分为 3 个桶，直至所有桶中的元素数量大致相等。如下图所示，这种方法本质上是创建一个递归树，目标是让叶节点的值尽可能平均。当然，不一定要每轮将数据划分为 3 个桶，具体划分方式可根据数据特点灵活选择。

image-20230917192242744

如果提前知道商品价格的概率分布，则可以根据数据概率分布设置每个桶的价格分界线。值得注意的是，数据分布并不一定需要特意统计，也可以根据数据特点采用某种概率模型进行近似。假设商品价格服从正态分布，这样就可以合理地设定价格区间，从而将商品平均分配到各个桶中。

image-20230917192324653

计数排序

计数排序通过统计元素数量来实现排序，通常应用于整数数组。给定一个长度为 n 的数组 nums ，其中的元素都是“非负整数”。

  1. 遍历数组，找出数组中的最大数字，记为 m ，然后创建一个长度为 m+1 的辅助数组 counter 。
  2. 借助 counter 统计 nums 中各数字的出现次数，其中 counter[num] 对应数字 num 的出现次数。统计方法很简单，只需遍历 nums（设当前数字为 num），每轮将 counter[num] 增加 1 即可。
  3. 由于 counter 的各个索引天然有序，因此相当于所有数字已经被排序好了。接下来，我们遍历 counter ，根据各数字的出现次数，将它们按从小到大的顺序填入 nums 即可。

image-20230917194041419

Python：

def counting_sort_naive(nums: list[int]):
    """计数排序"""
    # 简单实现，无法用于排序对象
    # 1. 统计数组最大元素 m
    m = 0
    for num in nums:
        m = max(m, num)
    # 2. 统计各数字的出现次数
    # counter[num] 代表 num 的出现次数
    counter = [0] * (m + 1)
    for num in nums:
        counter[num] += 1
    # 3. 遍历 counter ，将各元素填入原数组 nums
    i = 0
    for num in range(m + 1):
        for _ in range(counter[num]):
            nums[i] = num
            i += 1

Go：

/* 计数排序 */
// 简单实现，无法用于排序对象
func countingSortNaive(nums []int) {
    // 1. 统计数组最大元素 m
    m := 0
    for _, num := range nums {
        if num > m {
            m = num
        }
    }
    // 2. 统计各数字的出现次数
    // counter[num] 代表 num 的出现次数
    counter := make([]int, m+1)
    for _, num := range nums {
        counter[num]++
    }
    // 3. 遍历 counter ，将各元素填入原数组 nums
    for i, num := 0, 0; num < m+1; num++ {
        for j := 0; j < counter[num]; j++ {
            nums[i] = num
            i++
        }
    }
}

从桶排序的角度看，我们可以将计数排序中的计数数组 counter 的每个索引视为一个桶，将统计数量的过程看作是将各个元素分配到对应的桶中。本质上，计数排序是桶排序在整型数据下的一个特例。

  • 时间复杂度 O(n+m) ：涉及遍历 nums 和遍历 counter ，都使用线性时间。一般情况下 n≫m ，时间复杂度趋于 O(n) 。
  • 空间复杂度 O(n+m)、非原地排序：借助了长度分别为 n 和 m 的数组 res 和 counter 。

使用计数排序的前置条件相对较为严格。

  • 计数排序只适用于非负整数。若想要将其用于其他类型的数据，需要确保这些数据可以被转换为非负整数，并且在转换过程中不能改变各个元素之间的相对大小关系。例如，对于包含负数的整数数组，可以先给所有数字加上一个常数，将全部数字转化为正数，排序完成后再转换回去即可。

  • 计数排序适用于数据量大但数据范围较小的情况。比如，在上述示例中 m 不能太大，否则会占用过多空间。而当 n≪m 时，计数排序使用 O(m) 时间，可能比 O(nlog⁡n) 的排序算法还要慢。

基数排序

基数排序的核心思想与计数排序一致，也通过统计个数来实现排序。在此基础上，基数排序利用数字各位之间的递进关系，依次对每一位进行排序，从而得到最终的排序结果。

以学号数据为例，假设数字的最低位是第 1 位，最高位是第 8 位，基数排序的流程如下图所示。

  1. 初始化位数 k=1 。
  2. 对学号的第 k 位执行“计数排序”。完成后，数据会根据第 k 位从小到大排序。
  3. 将 k 增加 1 ，然后返回步骤 2. 继续迭代，直到所有位都排序完成后结束。

由于数字的高位优先级高于低位，我们应该先排序低位再排序高位。

image-20230917195610805

对于一个 d 进制的数字 x ，要获取其第 k 位 xₖ，可以使用以下计算公式：

image-20230917195758236

其中 ⌊a⌋ 表示对浮点数 a 向下取整，而 mod d 表示对 d 取余。对于学号数据，d=10 且 k∈[1,8] 。

此外需要小幅改动计数排序代码，使之可以根据数字的第 k 位进行排序。

Python：

def digit(num: int, exp: int) -> int:
    """获取元素 num 的第 k 位，其中 exp = 10^(k-1)"""
    # 传入 exp 而非 k 可以避免在此重复执行昂贵的次方计算
    return (num // exp) % 10

def counting_sort_digit(nums: list[int], exp: int):
    """计数排序（根据 nums 第 k 位排序）"""
    # 十进制的位范围为 0~9 ，因此需要长度为 10 的桶
    counter = [0] * 10
    n = len(nums)
    # 统计 0~9 各数字的出现次数
    for i in range(n):
        d = digit(nums[i], exp)  # 获取 nums[i] 第 k 位，记为 d
        counter[d] += 1  # 统计数字 d 的出现次数
    # 求前缀和，将“出现个数”转换为“数组索引”
    for i in range(1, 10):
        counter[i] += counter[i - 1]
    # 倒序遍历，根据桶内统计结果，将各元素填入 res
    res = [0] * n
    for i in range(n - 1, -1, -1):
        d = digit(nums[i], exp)
        j = counter[d] - 1  # 获取 d 在数组中的索引 j
        res[j] = nums[i]  # 将当前元素填入索引 j
        counter[d] -= 1  # 将 d 的数量减 1
    # 使用结果覆盖原数组 nums
    for i in range(n):
        nums[i] = res[i]

def radix_sort(nums: list[int]):
    """基数排序"""
    # 获取数组的最大元素，用于判断最大位数
    m = max(nums)
    # 按照从低位到高位的顺序遍历
    exp = 1
    while exp <= m:
        # 对数组元素的第 k 位执行计数排序
        # k = 1 -> exp = 1
        # k = 2 -> exp = 10
        # 即 exp = 10^(k-1)
        counting_sort_digit(nums, exp)
        exp *= 10

Go：

/* 获取元素 num 的第 k 位，其中 exp = 10^(k-1) */
func digit(num, exp int) int {
    // 传入 exp 而非 k 可以避免在此重复执行昂贵的次方计算
    return (num / exp) % 10
}

/* 计数排序（根据 nums 第 k 位排序） */
func countingSortDigit(nums []int, exp int) {
    // 十进制的位范围为 0~9 ，因此需要长度为 10 的桶
    counter := make([]int, 10)
    n := len(nums)
    // 统计 0~9 各数字的出现次数
    for i := 0; i < n; i++ {
        d := digit(nums[i], exp) // 获取 nums[i] 第 k 位，记为 d
        counter[d]++             // 统计数字 d 的出现次数
    }
    // 求前缀和，将“出现个数”转换为“数组索引”
    for i := 1; i < 10; i++ {
        counter[i] += counter[i-1]
    }
    // 倒序遍历，根据桶内统计结果，将各元素填入 res
    res := make([]int, n)
    for i := n - 1; i >= 0; i-- {
        d := digit(nums[i], exp)
        j := counter[d] - 1 // 获取 d 在数组中的索引 j
        res[j] = nums[i]    // 将当前元素填入索引 j
        counter[d]--        // 将 d 的数量减 1
    }
    // 使用结果覆盖原数组 nums
    for i := 0; i < n; i++ {
        nums[i] = res[i]
    }
}

/* 基数排序 */
func radixSort(nums []int) {
    // 获取数组的最大元素，用于判断最大位数
    max := math.MinInt
    for _, num := range nums {
        if num > max {
            max = num
        }
    }
    // 按照从低位到高位的顺序遍历
    for exp := 1; max >= exp; exp *= 10 {
        // 对数组元素的第 k 位执行计数排序
        // k = 1 -> exp = 1
        // k = 2 -> exp = 10
        // 即 exp = 10^(k-1)
        countingSortDigit(nums, exp)
    }
}

相较于计数排序，基数排序适用于数值范围较大的情况，但前提是数据必须可以表示为固定位数的格式，且位数不能过大。例如，浮点数不适合使用基数排序，因为其位数 k 过大，可能导致时间复杂度 O(nk)≫O(n^2) 。

  • 时间复杂度 O(nk)：设数据量为 n、数据为 d 进制、最大位数为 k ，则对某一位执行计数排序使用 O(n+d) 时间，排序所有 k 位使用 O((n+d)k) 时间。通常情况下，d 和 k 都相对较小，时间复杂度趋向 O(n) 。
  • 空间复杂度 O(n+d)、非原地排序：与计数排序相同，基数排序需要借助长度为 n 和 d 的数组 res 和 counter 。
  • 稳定排序：与计数排序相同。

排序算法对比

image-20230917200832280

References：https://www.hello-algo.com/chapter_sorting/

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

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

相关文章

基于Yolov8的交通标志牌（TT100K）识别检测系统

基于Yolov8的交通标志牌（TT100K）识别检测系统

1.Yolov8介绍 Ultralytics YOLOv8是Ultralytics公司开发的YOLO目标检测和图像分割模型的最新版本。YOLOv8是一种尖端的、最先进的&#xff08;SOTA&#xff09;模型&#xff0c;它建立在先前YOLO成功基础上&#xff0c;并引入了新功能和改进&#xff0c;以进一步提升性能和灵活…
阅读更多...
在gazebo仿真环境中加载多个机器人

在gazebo仿真环境中加载多个机器人

文章目录 前言一、基本概念1、xacro2、Gazebo 加载单个机器人模型 二、原先launch文件代码三、 修改launch文件加载多个机器人总结 前言 单个机器人的各项仿真实验都基本完成&#xff0c;也实现了远程控制&#xff0c;接下来主要对多机器人编队进行仿真实验&#xff0c;在进行…
阅读更多...
Git 命令图形化在线练习

Git 命令图形化在线练习

git 命令在线练习网址如下: http://onlywei.github.io/explain-git-with-d3/ 在master上先提交2个commit,创建3个分支,分支1打5个commit,分支2打6commit ,分支3commit,master分支打9commit. git commit -m "master c 1" git commit -m "master c 1"git …
阅读更多...
程序员必备神器：He3万能工具箱全解析

程序员必备神器：He3万能工具箱全解析

He3是一个为前端、后端开发者打造的终极工具箱软件&#xff0c;提供了近400的功能&#xff0c;将开发效率提升到一个新的水平。。本文将介绍 He3 开发者工具箱的主要功能和特点。 He3包含Web版和客户端&#xff0c;客户端支持windows和mac。下载后即可使用非常方便。 先睹为快…
阅读更多...
FL Studio v21.1.1.3750 Producer Edition inc crack官方中文免费激活版功能介绍及百度网盘下载

FL Studio v21.1.1.3750 Producer Edition inc crack官方中文免费激活版功能介绍及百度网盘下载

FL Studio v21.1.1.3750 Producer Edition inc crack官方中文免费激活版是一款功能强大的软件音乐制作环境或数字音频工作站&#xff08;DAW&#xff09;。它代表了25多年的创新发展&#xff0c;在一个软件包中拥有您所需的一切&#xff0c;以创作、编排、录制、编辑、混音和掌…
阅读更多...
C++之vector元素访问函数operator[]、at、front、back、data总结(二百零三)

C++之vector元素访问函数operator[]、at、front、back、data总结(二百零三)

简介&#xff1a; CSDN博客专家&#xff0c;专注Android/Linux系统&#xff0c;分享多mic语音方案、音视频、编解码等技术&#xff0c;与大家一起成长&#xff01; 优质专栏&#xff1a;Audio工程师进阶系列【原创干货持续更新中……】&#x1f680; 人生格言&#xff1a; 人生…
阅读更多...
如何在 Excel 中计算日期之间的天数

如何在 Excel 中计算日期之间的天数

计算两个日期之间的天数是 Excel中的常见操作。无论您是规划项目时间表、跟踪时间还是分析一段时间内的趋势&#xff0c;了解如何在 Excel 中查找日期之间的天数都可以提供强大的日期计算功能。 幸运的是&#xff0c;Excel 提供了多种简单的方法来获取两个日期之间的天数。继续…
阅读更多...
Javascript EventListener 事件监听 （mouseover、mouseout）

Javascript EventListener 事件监听 （mouseover、mouseout）

事件指的是在html元素上发生的事情&#xff0c;例如图片元素被点击事件触发时&#xff0c;可设置执行一段js代码。对事件作出反应&#xff0c;通过元素的事件属性&#xff0c;启用事件监听器。 事件监听器是指 addEventListener (给DOM对象添加事件处理程序) 和 removeEventLis…
阅读更多...
441分2023级东南大学920专业基础综合信号和数字电路考研上岸经验分享信息科学与工程学院

441分2023级东南大学920专业基础综合信号和数字电路考研上岸经验分享信息科学与工程学院

写在前面的话 本人是23年考生&#xff0c;本科就读于西电电子信息工程&#xff0c;以441分总分&#xff08;数学一149&#xff0c;英语83&#xff0c;专业课137&#xff0c;政治73&#xff09;考上东南信院电路与系统专业。以下所言皆是考研历程中的重要感悟&#xff0c;因为一…
阅读更多...
c语言练习61：malloc和free

c语言练习61：malloc和free

malloc和free malloc C语⾔提供了⼀个动态内存开辟的函数&#xff1a; 1 void* malloc (size_t size); 这个函数向内存申请⼀块连续可⽤的空间&#xff0c;并返回指向这块空间的指针。 • 如果开辟成功&#xff0c;则返回⼀个指向开辟好空间的指针。 • 如果开辟失败&…
阅读更多...
mysql的变量

mysql的变量

在 MySQL 中变量分为三种类型 : 系统变量、用户定义变量、局部变量。 系统变量 系统变量 是 MySQL 服务器提供&#xff0c;不是用户定义的&#xff0c;属于服务器层面。分为全局变量&#xff08; GLOBAL &#xff09;、会话变量&#xff08;SESSION &#xff09;。 查看系统变…
阅读更多...
选择适合您网站的SSL证书，保障安全与信任

选择适合您网站的SSL证书，保障安全与信任

在如今数字化的时代&#xff0c;拥有一个安全可靠的网站是至关重要的。而SSL证书作为保护网站和用户数据安全的关键工具&#xff0c;选择适合自己网站的SSL证书成为了每个网站管理员必须面对的重要任务。下面将为您分享几个关键因素&#xff0c;帮助您做出明智的选择。 1. 网站…
阅读更多...
Linux的调试工具 - gdb(超详细)

Linux的调试工具 - gdb(超详细)

Linux的调试工具 - gdb 1. 背景2. 开始使用指令的使用都用下面这个C语言简单小代码来进行演示&#xff1a;1. list或l 行号&#xff1a;显示文件源代码&#xff0c;接着上次的位置往下列&#xff0c;每次列10行。2. list或l 函数名:列出某个函数的源代码。3. r或run: 运行程序。…
阅读更多...
链队列的基本操作（带头结点，不带头结点）

链队列的基本操作（带头结点，不带头结点）

结构体 typedef struct linknode{int data;struct linknode* next;后继指针 }linknode; typedef struct {linknode* front, * rear;//队头队尾指针 }linkquene; 初始化队列&#xff08;带头结点&#xff09; int initquene(linkquene* q)//初始化队列 {q->front q->r…
阅读更多...
geant4创建自己的physicslist（以电磁物理为例）

geant4创建自己的physicslist（以电磁物理为例）

1 基本概念 1.1 需要创建一个类继承 G4ModularPhysicist 每个physics都是继承 G4PhysicsConstruct Physicslist 由很多 physics组成&#xff0c;physics里面包含很多的process,也就是物理过程,光电效应就是一个process 1.2 model的概念:实现proces,一个process可以对应多个…
阅读更多...
阿里云无影云电脑有什么用？常用使用场景说明

阿里云无影云电脑有什么用？常用使用场景说明

阿里云无影云电脑是一种易用、安全、高效的云上桌面服务&#xff0c;阿里云无影云电脑可用于高数据安全管控、高性能计算等要求的金融、设计、视频、教育等领域&#xff0c;适用于多种办公场景&#xff0c;如远程办公、多分支机构、安全OA、短期使用、专业制图等。阿里云百科来…
阅读更多...
ES6（二）

ES6（二）

文章目录 对象的扩展对象的展开运算符Object.is()Object.assign() 字符串的扩展includes(), startsWith(), endsWith()repeat()padStart()&#xff0c;padEnd()trimStart()&#xff0c;trimEnd() 运算符扩展指数运算符 Set方法应用 Map方法 对象的扩展 ES6 允许在大括号里面&a…
阅读更多...
DC系列靶机5通关教程

DC系列靶机5通关教程

信息收集 主机扫描 sudo arp-scan -l端口扫描 nmap -p- -A 192.168.16.172漏洞发现 浏览器访问靶机IP 在Contact找到类似提交数据的地方 点击submit&#xff0c;数字发生变化。不断刷新的话&#xff0c;数字依然会发生变化 使用bp抓包发送重发器查看数据包 再次点击发送查看…
阅读更多...
修改了Android Studio 中的这两个面板配置后，代码写的更舒服了~

修改了Android Studio 中的这两个面板配置后，代码写的更舒服了~

本文已同步发表于我的微信公众号&#xff0c;微信搜索 代码说 即可关注&#xff0c;欢迎与我沟通交流。 一、 增加打开文件的数量及展示方式 如图&#xff0c;默认AS中打开的文件个数是10个&#xff0c;当超过10个时&#xff0c;超过的部分会直接隐藏&#xff0c;甚至会直接把之…
阅读更多...
TCP详解之重传机制

TCP详解之重传机制

TCP详解之重传机制 TCP 实现可靠传输的方式之一&#xff0c;是通过序列号与确认应答。 在 TCP 中&#xff0c;当发送端的数据到达接收主机时&#xff0c;接收端主机会返回一个确认应答消息&#xff0c;表示已收到消息。 但在错综复杂的网络&#xff0c;并不一定能如上图那么顺…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023