分治法实战:用Python手把手教你找出数组中的众数(附完整代码)

众数问题(分治方法解决) 给定含有n个元素的多重集合S,每个元素在S中出现的次数称为该元素的重数。多重集S中最大的元素称为众数。给定一个n个自然数组成的多重集合S,设计算法求其众数和重数。 阅读详情

分治法实战:用Python手把手教你找出数组中的众数

最近在刷算法题,或者处理一些数据分析任务时,经常会遇到一个经典问题:如何高效地找到一个数组中出现次数最多的元素,也就是所谓的“众数”?你可能第一时间会想到用哈希表(字典)来统计频率,这确实是最直观、最常用的方法,时间复杂度是O(n)。但今天,我想带你换个思路,用一种更“优雅”的算法思想来解决这个问题——分治法。

分治法听起来可能有点“学院派”,感觉是算法课上的理论,离实际开发有点远。但事实上,理解分治思想,不仅能帮你解决众数问题,更能让你在面对复杂问题时,拥有一种“化繁为简”的思维武器。对于初学者而言,从排序遍历到哈希表,再到分治法,一步步深入,是理解算法设计精髓的绝佳路径。而对于有一定经验的开发者,重温分治策略,或许能让你在优化某些特定场景(比如数据流、分布式计算)下的统计问题时,找到新的灵感。

这篇文章,我将抛开那些晦涩的伪代码和C语言实现,完全用Python来手把手拆解如何用分治法寻找众数。我们会从最基础的概念讲起,一步步推导出递归函数,处理各种边界情况,并用丰富的测试案例来验证我们的代码。你会发现,用Python实现分治算法,代码可以非常简洁和清晰。

1. 问题重述与基础概念:什么是众数与分治?

在开始写代码之前,我们必须把问题定义清楚。给定一个包含 n 个元素的多重集合(可以理解为允许重复元素的数组)S,我们的目标是找到其中的众数及其重数。

  • 众数:在集合 S 中出现次数最多的那个元素。
  • 重数:众数出现的次数。

这里有几个关键点需要注意:

  1. 可能存在多个众数。例如,数组 [1, 1, 2, 2, 3] 中,1 和 2 都出现了两次,那么它们都是众数,重数都是2。
  2. 可能没有众数。当所有元素出现次数都相同时(如 [1, 2, 3, 4]),按照严格定义,可以说没有众数,或者说每个元素都是众数(但重数只有1)。在实际应用中,我们通常约定返回其中一个元素及其计数,或者指明无众数。本文将实现返回其中一个出现次数最多的元素及其计数,如果存在多个,则返回最先被算法确认的那个。

那么,分治法又是什么呢?它的核心思想可以概括为“分而治之”:

  • 分:将原问题分解成若干个规模较小的子问题,这些子问题与原问题形式相同,只是规模更小。
  • 治:递归地求解这些子问题。如果子问题的规模已经足够小,就直接求解。
  • 合:将子问题的解合并起来,得到原问题的解。

对于寻找众数这个问题,一个朴素的分治思路是:把数组分成左右两半,分别找出左半部分的众数、右半部分的众数,以及跨越中点的“候选众数”,然后在这三者中选出重数最大的那个。这个“跨越中点”的候选者,通常需要扫描整个区间来统计某个特定值的出现次数。

2. 算法核心思路与递归设计

我们直接切入最核心的部分:如何为寻找众数设计一个分治递归函数。

假设我们有一个函数 find_mode(arr, left, right),它的目标是找到数组 arr 在索引 [left, right] 这个闭区间内的众数及其重数。函数将返回一个元组 (mode, count)。

递归的基石:终止条件 这是任何递归函数的第一步。什么时候问题简单到不需要再“分”了?

  1. 当区间内只有一个元素时(left == right),这个元素自己就是众数,重数为1。
  2. 当区间为空时(left > right),这是一个无效情况,在我们的设计中通常不会遇到,但为了健壮性,可以返回一个表示无效的值(如 (None, 0))。不过,更常见的做法是,我们的递归划分保证不会产生空区间。

分治的步骤:分解与合并

  1. 分解:找到区间的中点 mid = (left + right) // 2。这样,我们就把原问题 [left, right] 分解为两个子问题:
    • 左子问题:[left, mid]
    • 右子问题:[mid + 1, right]
  2. 递归求解:分别调用 find_mode(arr, left, mid) 和 find_mode(arr, mid+1, right),得到左半部分的众数 left_mode 及其重数 left_count,以及右半部分的 right_mode 和 right_count。
  3. 处理“跨越”候选者:别忘了,真正的众数可能横跨左右两个子区间。例如,数组 [1, 2, 2, 3, 3, 3],中点是 2(索引2),左子区间众数可能是 2(重数2),右子区间众数可能是 3(重数2),但整个区间的众数是 3(重数3)。这个 3 的分布跨越了中点。因此,我们必须统计中点元素 arr[mid] 在整个当前区间 [left, right] 内出现的次数,作为第三个候选者 mid_candidate 和 mid_count。
  4. 合并:比较 left_count, right_count, mid_count。返回重数最大的那个 (mode, count)。如果出现重数相同的情况,我们可以定义一个规则,比如优先返回左子区间的结果,或者优先返回 mid_candidate。在下面的实现中,我们会采用一种清晰的比较逻辑。

这个思路清晰,但有一个明显的效率问题:在第3步,为了统计 arr[mid] 在整个区间的出现次数,我们可能需要线性扫描整个区间,这会使每次合并操作的时间复杂度为 O(n)。如果递归树深度为 O(log n),那么总的时间复杂度将是 O(n log n)。这和我们先排序再线性扫描的经典方法时间复杂度相同。那么分治法的优势在哪里?

  • 理论价值:它展示了如何将分治思想应用于非排序类问题。
  • 潜在优势:在某些特定场景或并行计算框架下,分治策略更容易被并行化。左子问题和右子问题的求解可以同时进行。
  • 思维训练:这是理解递归和分治合并步骤的经典案例。

为了更直观地对比不同候选者的产生方式,我们用一个表格来梳理:

候选者来源如何获得关键操作时间复杂度 (单次合并)
左子区间众数递归调用 find_mode(left, mid)递归分解依赖于子问题规模
右子区间众数递归调用 find_mode(mid+1, right)递归分解依赖于子问题规模
中点候选者统计 arr[mid] 在 [left, right] 的出现次数线性扫描O(n)

提示:在实现统计 arr[mid] 出现次数的函数时,由于数组未排序,我们必须遍历整个区间。一个小的优化是,因为我们已经知道中点索引 mid,可以从 mid 开始向左右两边扩展计数,但最坏情况(该元素遍布整个区间)仍需 O(n)。

3. Python代码实现与逐行解析

理论说得再多,不如一行代码。我们现在就来实现这个分治法的众数查找。我会先给出完整的、可运行的函数,然后对关键部分进行详细解析。

def count_in_range(arr, target, left, right):
    """
    辅助函数:统计目标值 target 在数组 arr 的 [left, right] 区间内出现的次数。
    """
    count = 0
    for i in range(left, right + 1):
        if arr[i] == target:
            count += 1
    return count

def find_mode_divide_conquer(arr, left, right):
    """
    分治法寻找众数的主递归函数。
    返回一个元组 (众数, 重数)。
    """
    # 终止条件1:区间只有一个元素
    if left == right:
        return arr[left], 1

    # 分解:计算中点
    mid = (left + right) // 2

    # 治:递归求解左右子问题
    left_mode, left_count = find_mode_divide_conquer(arr, left, mid)
    right_mode, right_count = find_mode_divide_conquer(arr, mid + 1, right)

    # 合:处理中点候选者
    mid_candidate = arr[mid]
    mid_count = count_in_range(arr, mid_candidate, left, right)

    # 合并策略:选择重数最大的候选者
    # 先假设左子区间的结果是最终的
    best_mode, best_count = left_mode, left_count

    # 如果右子区间的重数更大,则更新为右子区间的结果
    if right_count > best_count:
        best_mode, best_count = right_mode, right_count

    # 如果中点候选者的重数更大,则更新为中点候选者
    if mid_count > best_count:
        best_mode, best_count = mid_candidate, mid_count

    return best_mode, best_count

def find_mode(arr):
    """
    对外的接口函数,处理空数组等边界情况,并调用递归函数。
    """
    if not arr:  # 处理空数组
        return None, 0
    return find_mode_divide_conquer(arr, 0, len(arr) - 1)

# 测试函数
def test_find_mode():
    test_cases = [
        ([1, 2, 2, 3, 4], (2, 2)),          # 简单情况,众数是2
        ([1, 1, 2, 2, 3], (1, 2)),          # 多个众数,返回第一个遇到的(左子区间优先)
        ([5], (5, 1)),                       # 单个元素
        ([], (None, 0)),                     # 空数组
        ([1, 2, 3, 4, 5], (1, 1)),          # 所有元素出现一次,返回第一个
        ([2, 2, 2, 1, 5, 3, 5, 7, 5, 5, 5], (5, 5)), # 复杂情况,众数是5
        ([3, 3, 3, 2, 2, 2], (3, 3)),       # 左右众数不同,需要比较中点候选者
    ]

    print("测试分治法求众数:")
    for i, (input_arr, expected) in enumerate(test_cases):
        result = find_mode(input_arr)
        status = "通过" if result == expected else "失败"
        print(f"测试用例 {i+1}: {input_arr} -> 期望 {expected}, 得到 {result} [{status}]")

if __name__ == "__main__":
    test_find_mode()

代码关键点解析:

  1. 辅助函数 count_in_range:这个函数是算法效率的关键瓶颈之一。它执行了一次线性扫描。在实际应用中,如果数组是已排序的,我们可以用二分查找找到 target 的左右边界,将统计次数的时间复杂度降到 O(log n),从而让整个分治算法在有序数组上的复杂度优于 O(n log n)。但作为通用算法,我们假设输入是未排序的。

  2. 递归终止条件 if left == right::这是递归的“叶子节点”。当区间缩小到只有一个元素时,它自己就是众数,重数为1。这是递归能够正确返回的基础。

  3. 递归调用 find_mode_divide_conquer(arr, left, mid) 和 find_mode_divide_conquer(arr, mid+1, right):这里体现了“分”的思想。函数不断地自我调用,将大问题分解成小问题。理解递归的关键是信任:我们相信这个函数能正确解决子问题。

  4. 合并策略:这是“治”和“合”的体现。我们得到了三个候选答案:

    • (left_mode, left_count)
    • (right_mode, right_count)
    • (mid_candidate, mid_count) 合并的逻辑非常简单:用一个“打擂台”的方式,比较它们的 count,保留重数最大的那个。这里的比较顺序(先左、再右、最后中)决定了当重数相同时返回哪个众数。你可以根据需要调整这个优先级。
  5. 对外接口 find_mode(arr):这是一个包装函数,提供了更干净的接口。它首先处理了空数组的边界情况,然后调用递归函数从整个数组范围 [0, len(arr)-1] 开始计算。

运行上面的测试代码,你会看到所有测试用例都应该通过。这验证了我们算法实现的正确性。

4. 复杂度分析、对比与优化思考

现在,我们来理性地分析一下这个分治算法的性能,并与其他方法进行对比。

时间复杂度分析

设数组长度为 n。

  • 递归的深度:每次都将区间大致分为两半,所以递归树的高度是 O(log n)。

  • 每层递归的工作量:关键在于合并步骤中的 count_in_range 函数,它需要线性扫描当前区间。但是请注意,在递归树的每一层,所有节点处理的子区间加起来,正好覆盖了整个原始数组,且没有重叠(在合并步骤的统计中,count_in_range 是针对每个递归调用自己的区间进行的扫描,这些区间在递归树的同一层是互不相交的)。然而,更精确的分析是,每个递归调用都会执行一次 count_in_range,而该函数的时间复杂度与当前处理的区间长度成正比。 我们可以通过递归式来近似分析:T(n) = 2T(n/2) + O(n)。根据主定理(Master Theorem),这个递归式的解是 O(n log n)。

    这与快速排序、归并排序等经典分治算法的时间复杂度相同。

空间复杂度分析

  • 递归调用需要栈空间。递归深度为 O(log n),因此空间复杂度是 O(log n)。这比需要额外 O(n) 空间的哈希表法(在最坏情况下)要节省。

与其他方法的对比

方法时间复杂度空间复杂度优点缺点
哈希表法O(n)O(n)时间复杂度最优,实现简单直观,适用于绝大多数场景。需要额外的哈希表空间,在数据量极大时可能受内存限制。
排序遍历法O(n log n)O(1) 或 O(n)空间效率高(如果可原地排序),逻辑简单。时间复杂度较高,且修改了原数组(如果非原地排序则需要空间)。
分治法O(n log n)O(log n)空间复杂度优于哈希表,是展示分治思想的经典案例,易于并行化。时间复杂度不如哈希表,实现相对复杂,常数因子可能较大。
Boyer-Moore 投票算法O(n)O(1)时间和空间都是最优,适用于存在绝对众数(出现次数 > n/2)的场景。仅适用于存在绝对众数的情况,是特化算法。

注意:Boyer-Moore 投票算法是一个特例,它能在 O(n) 时间和 O(1) 空间内找到绝对众数(出现次数超过一半的元素)。但它不适用于寻找普通的众数(可能不止一个,或者出现次数不超过一半)。我们的分治法和哈希表法则适用于通用情况。

优化思考

我们的基础实现中,count_in_range 是性能瓶颈。如果输入数组是已排序的,我们可以进行大幅优化:

def count_in_range_sorted(arr, target, left, right):
    """
    优化版:针对已排序数组,使用二分查找找到左右边界,从而 O(log n) 时间内统计次数。
    假设 arr 在 [left, right] 区间内是升序排列的。
    """
    # 找到第一个等于 target 的位置
    def find_first(target):
        l, r = left, right
        first = right + 1
        while l <= r:
            m = (l + r) // 2
            if arr[m] >= target:
                if arr[m] == target:
                    first = m
                r = m - 1
            else:
                l = m + 1
        return first

    # 找到最后一个等于 target 的位置
    def find_last(target):
        l, r = left, right
        last = left - 1
        while l <= r:
            m = (l + r) // 2
            if arr[m] <= target:
                if arr[m] == target:
                    last = m
                l = m + 1
            else:
                r = m - 1
        return last

    first_pos = find_first(target)
    last_pos = find_last(target)

    if first_pos <= last_pos:
        return last_pos - first_pos + 1
    else:
        return 0

如果我们在调用主函数前先对数组排序(代价是 O(n log n)),然后在递归中使用 count_in_range_sorted,那么每次合并操作的成本就从 O(n) 降到了 O(log n)。此时递归式变为 T(n) = 2T(n/2) + O(log n),根据主定理,整体时间复杂度仍然是 O(n)?这里需要仔细分析:排序花费 O(n log n),之后的分治过程花费 O(n)(因为每个元素在递归树中只被处理常数次,且每次合并的二分查找是 O(log n),但递归树有 O(n) 个节点?)。实际上,经过排序后,整个分治过程可以更高效,但排序本身已经是 O(n log n) 了,所以总复杂度不会低于 O(n log n)。然而,如果数组本来已排序,那么这个优化版的分治算法可以达到接近 O(n) 的性能,这在实际应用中很有价值。

5. 实战演练与边界案例深度剖析

理论分析和代码实现之后,我们需要用更复杂的例子来检验算法的健壮性,并深入理解其运行过程。让我们跟踪一个具体例子的执行流程。

案例:arr = [2, 2, 1, 3, 2, 3, 3, 3]

首先,为了清晰,我们给数组加上索引:[2(0), 2(1), 1(2), 3(3), 2(4), 3(5), 3(6), 3(7)]。长度 n=8。

调用 find_mode(arr, 0, 7)。

  1. 第一层递归:left=0, right=7, mid=3。中点元素是 arr[3]=3。

    • 递归左半部分 [0, 3]。
    • 递归右半部分 [4, 7]。
    • 统计中点候选者 3 在整个区间 [0,7] 的出现次数。遍历数组,发现 3 出现在索引 3,5,6,7,共4次。所以 mid_candidate=3, mid_count=4。
  2. 深入左半部分 [0,3]:left=0, right=3, mid=1。中点元素 arr[1]=2。

    • 递归左左 [0,1]。
    • 递归左右 [2,3]。
    • 统计 2 在 [0,3] 的出现次数:索引0,1,4(注意,4不在当前区间 [0,3] 内!错误!)。这里是一个关键点:count_in_range 只统计当前递归区间 [left, right] 内的次数。所以在 [0,3] 区间内,2 出现在索引0和1,共2次。所以 mid_candidate=2, mid_count=2。
  3. 处理左左部分 [0,1]:left=0, right=1, mid=0。

    • 递归 [0,0]:返回 (2, 1)。
    • 递归 [1,1]:返回 (2, 1)。
    • 统计中点 arr[0]=2 在 [0,1] 的出现次数:2次。
    • 合并:比较 (2,1), (2,1), (2,2)。胜出者是 (2,2)。所以 [0,1] 区间返回 (2,2)。
  4. 处理左右部分 [2,3]:left=2, right=3, mid=2。

    • 递归 [2,2]:返回 (1,1)。
    • 递归 [3,3]:返回 (3,1)。
    • 统计中点 arr[2]=1 在 [2,3] 的出现次数:1次。
    • 合并:比较 (1,1), (3,1), (1,1)。重数相同,根据我们的合并逻辑(先左后右最后中),返回左子区间的结果 (1,1)。所以 [2,3] 区间返回 (1,1)。
  5. 回到左半部分 [0,3] 的合并:现在我们有:

    • 左子结果(来自 [0,1]):(2, 2)
    • 右子结果(来自 [2,3]):(1, 1)
    • 中点候选者:(2, 2) (统计自区间 [0,3])
    • 合并比较:(2,2), (1,1), (2,2)。返回 (2,2)。所以左半部分最终认为众数是 2,重数为2。
  6. 同理分析右半部分 [4,7](过程略),最终会返回 (3, 3)(因为 3 在 [4,7] 区间出现了3次)。

  7. 回到最顶层 [0,7] 的合并:现在我们有:

    • 左子结果:(2, 2)
    • 右子结果:(3, 3)
    • 中点候选者:(3, 4) (我们第一步统计的)
    • 合并比较:(2,2), (3,3), (3,4)。重数最大的是 (3,4)。
    • 最终结果:返回 (3, 4)。正确!

通过这个跟踪过程,你可以清晰地看到:

  • 递归如何将大问题分解。
  • count_in_range 如何确保统计的准确性(只在当前递归区间内统计)。
  • 合并步骤如何从子解和中点候选者中选出全局最优解。

边界与特殊情况处理

我们的代码已经处理了空数组和单元素数组。还需要考虑:

  • 所有元素频率相同:如 [1,2,3,4]。算法会返回第一个元素 1 及其计数 1。这符合我们“返回其中一个”的约定。如果你需要特别指出“无众数”,可以在最终结果判断 best_count == 1 且数组长度大于1时进行处理。
  • 多个众数且重数相同:如 [1,1,2,2]。根据我们的合并优先级(左子区间优先),会返回 1。如果你需要返回所有众数,则需要修改返回结构(例如返回一个列表)和合并逻辑。

最后,我想说的是,分治法求众数更像是一次精彩的思维体操,它可能不是解决这个问题最高效的通用工具(哈希表通常是),但它深刻地揭示了递归、分治和合并策略的威力。当你下次遇到更复杂的问题,比如寻找“主元素”(出现超过一半)、统计流数据中的高频项,或者需要在分布式环境下进行统计时,这次手把手的实践所锻炼出来的分治思维,或许就能派上大用场。编程的魅力,往往就在于这种从多个角度审视和解决同一个问题的过程中。

分治法求众数.doc 算法设计与分析课内实验——分治法求众数。文档很齐全,包括算法分析过程和源代码(java语言eclipse环境) 立即下载

相关推荐

基于springboot生鲜食品订购系统的设计与实现

近年来互联网络的迅猛发展和电子终端设备的普及,赋予了各行业充足的发展空间。微信小程序的O2O生鲜食品订购相比于传统信息技术,时效性是它最大的特色,已经在电子娱乐、经济等中发挥着举足轻重的作用。短时间内迅速扩大了线上管理系统的规模。尽管O2O生鲜食品订购已经有了很大程度的发展,但在微信小程序的O2O生鲜食品订购领域上却少有建设。

1025

分治法——找众数

要利用分治法找众数,首先就先要使数组有序。这里,我们用C语言库中的。语句没有执行,那就说明。就是最大的,那就需要和。注:本题已通过牛客网。

Forward♞的博客 2143

NRF52832串口通信避坑指南:从SDK配置到硬件流控(RTS/CTS)实战

本文详细介绍了NRF52832串口通信的实战指南,从SDK配置到硬件流控(RTS/CTS)的完整实现。通过分析UARTE模块特性、解决SDK版本差异问题、正确配置硬件引脚以及实现稳定通信的代码示例,帮助开发者避开常见陷阱,确保高效可靠的串口通信。特别强调了硬件流控在高速通信中的重要性及其实践方法。

weixin_33739646的博客 283

分治算法求众数

一.题目描述: 给定含有n个元素的多重集合S,每个元素在S中出现的次数称为该元素的重数。多重集S中重数最大的元素称为众数。例如,S={1,2,2,2,3,5}。多重集S的众数是2,其重数为3。对于给定的n个自然数组成的多重集S,计算S的众数及其重数。 二.算法分析: 首先请求两个全局变量,用来存放不同数字的重数(a数组)和众数(b数组)。将一组数据先排序,再找出一组数据中的中位数,利...

CR7的博客 1万+

ROS2学习笔记(二)-- 多机通讯原理简介及配置方法

简单介绍ROS2多机通信原理以及配置注意事项

aibingjin的博客 1万+

Lisflood

文献:基于SWMM和LISFLOOD-FP模型的居住区低影响开发模拟评价。问题:多个节点溢流同时,不行,待解决。目录下,cmd命令行。

警警的博客 2666

分治法求众数

能够正确地应用分治算法解决众数问题,对边界值测试效果,能正确得分析算法时间复杂度。

lllssskkkkk的博客 928

华为防火墙双线路配置实战:5分钟搞定主备自动切换(含健康检查避坑指南)

本文详细介绍了华为防火墙双线路配置实战,包括主备自动切换和健康检查机制的优化技巧。通过智能健康检查机制,华为防火墙能实现毫秒级故障自动切换,确保网络高可用性。文章提供了从架构设计到实战配置的全流程指南,并分享了常见配置误区与解决方案,帮助中小企业快速搭建稳定可靠的网络架构。

weixin_30872337的博客 607

小朋友学经典算法(17):分治法求众数

一组数据中,出现次数最多的数就叫这组数据的众数。 如果有两个或两个以上个数出现次数都是最多的,那么这几个数都是这组数据的众数。 如果所有数据出现的次数都一样,那么这组数据没有众数。 例1:1,2,3,3,4的众数是3。 例2:1,2,2,3,3,4的众数是2和3。 例3:1,2,3,4,5没有众数。 解法一: #include <iostream> #include <algor...

小树学信奥 1390

AI 大模型接口太零散?自建私有模型管理平台统一整合,管理使用超方便!(支持飞牛nas、群晖nas等服务器快速部署)

面对多种 AI 大模型接口难统一、管理繁琐的问题🤯,本文分享一款超实用开源网关工具⚡,可聚合各大模型、自动转接口、支持可视化管理,Docker 一键部署,大幅降低开发与维护成本🚀

XiaoqiangClub的博客 266

嵌入式开发环境Vscode开发STM32单片机程序

STM32单片机非常强大,大多数教程都是使用 keil 编译器,keil 是收费的而 gcc 是开源免费的。这里介绍一些使用 gcc +开发单片机程序的经验。(这里不解释 gcc 是什么)。

嵌入式技术开发 1845

python如何求列表中的众数_<算法(LeetCode)>六种方法求数组中的绝对众数

原题来自:LEETCODE。感谢:http://t.cn/R61A67j定义:绝对众数就是一个数在一组数中个数超过1/2的数。比如给你一个长度为N的整形数组:[13,12,53,12,23,343,12,12]要求出他们之中出现次数超过N/2的元素(假定一个数组中必定会有这样的元素),你会怎么求?若你是暴力求解,时间复杂度为O(n^2),那就low啦!下面是LeetCode上某位题友给出的六种算法...

weixin_39525243的博客 2421

【YOLO26实战全攻略】08——YOLO26模型导出与部署全攻略:从训练权重到生产环境(含5种格式+INT8量化+实战案例)

本文聚焦YOLO26模型从训练权重到生产环境的全流程部署,针对“训练精度高、部署效果差”的行业痛点,详解其无NMS端到端推理、量化友好架构、全格式导出三大核心优势。内容涵盖ONNX、TensorRT、OpenVINO、TFLite、CoreML五种主流格式的导出原理与实操步骤,深入剖析INT8量化、混合量化等边缘优化技术,并通过智慧园区车辆检测虚拟案例,完整演示从模型准备、格式导出、引擎适配到性能验证的全流程。文中提供可直接复制运行的代码、详细执行结果及避坑指南,兼顾新手入门与进阶读者提升,更好的帮助读者。

专注于人工智能、软件开发、工控自动化、工厂数字化及智能化等领域,希望和大家共同进步! 503

【算法】分治法求众数

其本质就是一个二分查找的题目,将找整个数列的众数二分成差两个子数列的个数,只需要将这个数列二分为两个子数列,然后找到左右两边的众数,然后进行比较确认整个数列的众数是什么就可以了。需要注意的点是:与数学上的众数定义不同,这里要求这个众数还必须超过数列长度的一半,所以找到出现次数最多的元素后还需要比较它的出现次数有没有超过数组长度的一半;运用分治思想,我们可以二分查找整个序列,先查找左右两边出现次数最多的元素是什么,然后查找左右两边的众数的出现次数是多少,最后进行比较,返回两边众数出现次数较大的那个数是多少。

qq_59554113的博客 597

大中型超市收银系统(可直接运行)

光步前台收银系统系统功能:商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传,基本资料下载,开钱箱、小票打印、收款结算,支持多币种付款方式(现金、储值卡、礼券、微信等),支持多种促销。运行环境:.net 4.0登陆信息用户名:1001 密码:123456内置商品信息,商品编码可输入00001000 - 00010000,测试效果相关功能键F5 结算 F9挂单 F11商品查询 F8退货 Insert单品取消 Del整单取消 F12开钱箱F2 会员 Ctrl+Z退出系统 Home 锁屏 相关源码待公开

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

算法设计与分析实验报告python实现(串匹配问题、采用分治法求解最大连续子序列和问题、用分治策略求众数问题、最近点对问题)

1、串匹配问题 给定一段文本,在该文本中查找并定位任意给定字符串。 要求: (1)实现BF算法; (2) 实现BF算法的改进算法:KMP算法 2、采用分治法求解最大连续子序列和问题 给定一个有n(n≥1)个整数的序列,要求求出其中最大连续子序列的和。 例如: 序列(-2,11,-4,13,-5,-2)的最大子序列和为20序列(-6,2,4,-7,5,3,2,-1,6,-9,10,-2)的最大子序列和为16。 3、用分治策略求众数问题 问题描述:给定含有n个元素的多重集合S,每个元素在S中出现的次数称为该元

Obliviate的博客 1172

廖雪峰Python教程[完整版]

廖雪峰的python教程整理的,已经排好版了,而且还是完整的,适合小白

leetcode-169. 求众数

title: leetcode-169. 求众数 date: 2019-9-18 20:21:07 comments: true categories: “leetcode” tags: - leetcode 简单难度 - 分治法 169. 求众数 题目描述 给定一个大小为 n 的数组,找到其中的众数。众数是指在数组中出现次数大于⌊ n/2 ⌋ 的元素。 你可以假设数组是非空的,并且给定的数组总是...

梦否 378

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

leetcode169求众数python实现

169求众数 简单 分治算法 给定一个大小为 n 的数组,找到其中的众数。众数是指在数组中出现次数大于 ⌊ n/2 ⌋ 的元素。 你可以假设数组是非空的,并且给定的数组总是存在众数。 1.方法一遍历:首先想到的方法是将数组的所有元素遍历,计算每个元素出现的次数,最后返回出现次数最多的元素,即为众数。 class Solution: def majorityElemen...

max119xlx的博客 448

分治法求众数:从O(n²)到O(n log n)的3种实现与性能实测对比

本文详细介绍了分治法在求解众数问题中的应用,对比了暴力解法、哈希表优化和分治法三种实现的时间复杂度与性能表现。通过实测数据展示不同算法在10³到10⁶规模数据集上的效率差异,为工程实践中的算法选择提供参考建议,特别适合算法设计和性能优化场景。

weixin_30755393的博客 322

leetcode 169 求众数 python

给定一个大小为 n 的数组,找到其中的众数。众数是指在数组中出现次数大于 ⌊ n/2 ⌋ 的元素。 你可以假设数组是非空的,并且给定的数组总是存在众数。 示例 1: 输入: [3,2,3] 输出: 3 示例 2: 输入: [2,2,1,1,1,2,2] 输出: 2 方法: 1.Hash Table将每个数字仿佛哈希表中,记数,直到某个数的count&gt;n/2。时间复杂度为o(...

予非池物 953

LeetCode高频100题刷题记录之——找出众数

LeetCode高频100题刷题记录之——找出众数 使用了哈希查表法,随机化方法,摩尔投票法和递归的分治法求解。

weixin_44846680的博客 369

python众数问题给定含有n个元素的多重集合s_南邮算法众数问题

基础算法题:给定含有n个元素的多重集合S,每个元素在S中出现的次数称为该元素的重数,多重集合S中重数最大的元素称为众数。例如。多重集合S的众数是2,其重数为3。要求对于给定的由n个自然数组成的多重集合S,计算S的众数及其重数。网络上流传着很多版本的算法思路,大多是使用分治法迭代或者递归来完成。但是对于这道题,可以使用更简明的方法(虽然时间复杂度我没有去比较,但是就思路来说,更容易解释)可以这样理解...

weixin_29415429的博客 2428

169.多数元素(摩尔投票+分治法)

多数元素(python年度更新版) 给定一个大小为 n 的数组,找到其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。 你可以假设数组是非空的,并且给定的数组总是存在多数元素。 输入:[3,2,3] 输出:3 来源:力扣(LeetCode) 链接:多数元素 摩尔投票法(会中文就能理解) 本题的思路首先想到的是摩尔投票法,比如说多国混战,n人参战,存在一个国家有多于n/2的人参战时,这个国家必然获得最后的胜利。 那么我们模拟这个混战的过程,用夺旗来比喻。 时间复杂度为O(n),空间复

qq_54384621的博客 926

高级算法分析与设计-分治法

【代码】高级算法分析与设计-分治法。

qq_53682472的博客 479

python众数问题给定含有n个元素的多重集合s_分治法之众数问题 - osc_nd0lr8gs的个人空间 - OSCHINA - 中文开源技术交流社区...

实验总结刚开始我没有想到可以用分治法来做,用的是数组来做。做完以后发现算法太过复杂,而且处理较大的n时,时间复杂度和空间复杂度都比较大。于是我参考了算法答案那本书,学到了分治法来解决这道题。但是在完成了用分治法的代码以后,我发现了问题: 输出应该为:24分治法解决这道题有一个大前提:多重集中的元素是有序的(递增或者递减),所以很有必要给多重集加入一个排序的算法.附录:(要求代码里各行要有注释)自己...

weixin_39966909的博客 579

众数与重数 非分治实现

众数与重数 非分治实现 描述 给定含有n个元素的多重集合S,每个元素在S中出现的次数称为该元素的重数。多重集S中重数最大的元素称为众数。例如,S={1,2,2,2,3,5}。多重集S的众数是2,其重数为3。对于给定的n个自然数组成的多重集S,计算S的众数及其重数 。 输入 输入集合大小n及n个数 输出 输出两行 第一行为众数 第二行为重数 样例输入 6 1 2 2 2 3 5 样例输出 2 3 #...

Stitchesz的博客 325
上一篇: 5分钟搞定!用Cursor零代码开发Chrome插件去除豆包图片水印(附完整调试记录)
下一篇: Windows 10下用YOLOv3+Deep_Sort_Pytorch实现多目标跟踪的完整避坑指南
github5actions
博客等级 码龄1天 0粉丝 1824原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值