99、使用递归的二分查找

于 2025-07-04 08:24:10 发布
阅读量79 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： Python数据结构与算法精髓 文章标签： 递归 二分查找 Python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/agile9scrum/article/details/149109097

使用递归的二分查找

1. 简介

递归是一种强大的编程技术，允许函数调用自身。递归方法通过将复杂问题分解为更小的子问题，逐步解决这些子问题，最终得到整个问题的解答。在许多算法中，递归都发挥了重要作用，特别是在搜索和排序算法中。本篇文章将详细介绍如何使用递归实现二分查找算法，帮助你在实际编程中更好地理解和应用这一技术。

2. 二分查找原理

二分查找是一种高效的搜索算法，适用于已排序的数组或列表。它的基本原理是通过反复将搜索区间缩小一半，从而快速定位目标元素。相比于线性搜索，二分查找的时间复杂度为 O(log n)，大大提高了搜索效率，尤其是在处理大规模数据时。

2.1 工作流程

二分查找的工作流程如下：

  1. 初始化 ：确定搜索区间的上下界，分别为数组的起始索引和结束索引。
  2. 计算中间位置 ：根据上下界计算中间索引。
  3. 比较中间元素 ：将中间元素与目标元素进行比较。
  4. 缩小搜索区间 ：如果目标元素小于中间元素，则在左半部分继续查找；如果目标元素大于中间元素，则在右半部分继续查找。
  5. 终止条件 ：如果找到目标元素，返回其索引；如果搜索区间为空，返回未找到的标志。

3. 递归实现二分查找

递归实现二分查找的核心思想是将问题分解为更小的子问题，直到找到目标元素或确定元素不存在。以下是使用Python实现递归二分查找的具体代码示例： 

def binary_search(arr, low, high, x):
    # Check base case
    if high >= low:
        mid = (high + low) // 2

        # If element is present at the middle itself
        if arr[mid] == x:
            return mid

        # If element is smaller than mid, then it can only be present in left subarray
        elif arr[mid] > x:
            return binary_search(arr, low, mid - 1, x)

        # Else the element can only be present in right subarray
        else:
            return binary_search(arr, mid + 1, high, x)

    else:
        # Element is not present in array
        return -1

# Test array
arr = [2, 3, 4, 10, 40]
x = 10

# Function call
result = binary_search(arr, 0, len(arr)-1, x)

if result != -1:
    print("Element is present at index", str(result))
else:
    print("Element is not present in array")

3.1 代码解析

  • binary_search 函数接收四个参数：已排序的数组 arr ，搜索范围的下界 low ，上界 high ，以及要查找的目标元素 x 。
  • base case ：如果 high 小于 low ，表示子数组为空，返回 -1 表示未找到元素。
  • mid ：计算中间索引。
  • 匹配 ：如果中间元素等于 x ，返回中间索引。
  • 左子数组 ：如果中间元素大于 x ，递归调用函数在左子数组中查找。
  • 右子数组 ：如果中间元素小于 x ，递归调用函数在右子数组中查找。

4. 递归的优势与局限

递归实现二分查找的优势在于代码简洁、易于理解，但也有一定的局限性：

4.1 优势

  • 代码简洁 ：递归实现通常比迭代实现更简洁，易于理解和维护。
  • 逻辑清晰 ：递归方法将问题分解为更小的子问题，逻辑更加直观。
  • 易于扩展 ：递归方法便于处理更复杂的情况，如多维数组或嵌套数据结构。

4.2 局限

  • 栈溢出风险 ：递归调用会占用栈空间，过多的递归可能导致栈溢出。
  • 性能开销 ：递归调用会带来额外的性能开销，特别是在函数调用频繁的情况下。
  • 调试困难 ：递归代码在调试时可能较为复杂，尤其是当递归深度较大时。

5. 实际应用场景

递归二分查找在实际编程中有广泛的应用，特别是在需要高效搜索的场景中。以下是几个典型的应用场景：

5.1 数据库查询优化

在数据库中，二分查找可以用于优化索引查询。通过递归二分查找，可以在已排序的索引中快速定位目标记录，提高查询效率。

5.2 文件系统搜索

文件系统中的目录和文件通常按层次结构组织，递归二分查找可以帮助快速定位特定文件或目录，尤其是在大型文件系统中。

5.3 排序算法中的应用

递归二分查找常用于排序算法中，如归并排序和快速排序。通过递归二分查找，可以快速确定插入位置或分割点，提高排序效率。

6. 示例与测试

为了更好地理解递归二分查找的工作原理，我们可以通过一些具体的示例来进行测试。以下是一个详细的测试过程：

6.1 测试用例

测试用例 输入数组 查找元素 输出结果
测试1 [2, 3, 4, 10, 40] 10 Element is present at index 3
测试2 [1, 2, 3, 4, 5, 6, 7, 8, 9] 7 Element is present at index 6
测试3 [1, 2, 3, 4, 5, 6, 7, 8, 9] 11 Element is not present in array

6.2 mermaid流程图 

graph TD;
    A[开始] --> B{high >= low};
    B -->|是| C[计算 mid];
    C --> D{arr[mid] == x};
    D -->|是| E[返回 mid];
    D -->|否| F{arr[mid] > x};
    F -->|是| G[递归查找左子数组];
    F -->|否| H[递归查找右子数组];
    B -->|否| I[返回 -1];

7. 代码调试技巧

在实际编程中，递归代码的调试可能会遇到一些挑战。以下是几个调试技巧，帮助你更有效地调试递归二分查找代码：

7.1 打印中间状态

通过在递归函数中添加打印语句，可以跟踪每次递归调用的状态，帮助你理解代码的执行流程。例如： 

def binary_search(arr, low, high, x):
    print(f"Searching from index {low} to {high}")
    if high >= low:
        mid = (high + low) // 2
        print(f"Middle index: {mid}, Value: {arr[mid]}")

        if arr[mid] == x:
            return mid

        elif arr[mid] > x:
            return binary_search(arr, low, mid - 1, x)

        else:
            return binary_search(arr, mid + 1, high, x)

    else:
        return -1

7.2 设置断点

使用调试工具（如Python的 pdb 模块）设置断点，逐步执行代码，观察变量的变化。例如： 

import pdb

def binary_search(arr, low, high, x):
    pdb.set_trace()
    if high >= low:
        mid = (high + low) // 2

        if arr[mid] == x:
            return mid

        elif arr[mid] > x:
            return binary_search(arr, low, mid - 1, x)

        else:
            return binary_search(arr, mid + 1, high, x)

    else:
        return -1

8. 优化建议

尽管递归二分查找在大多数情况下表现良好，但在某些特定场景下仍需进行优化。以下是几种常见的优化方法：

8.1 避免栈溢出

为了避免栈溢出的风险，可以使用尾递归优化（Tail Recursion Optimization, TRO）。尾递归优化通过将递归调用作为函数的最后一个操作，减少栈空间的占用。

8.2 提高缓存命中率

在处理大规模数据时，可以通过调整搜索区间的初始值，提高缓存命中率，从而加快查找速度。例如： 

def binary_search(arr, low, high, x):
    if high >= low:
        mid = (high + low) // 2

        if arr[mid] == x:
            return mid

        elif arr[mid] > x:
            return binary_search(arr, low, mid - 1, x)

        else:
            return binary_search(arr, mid + 1, high, x)

    else:
        return -1

# 使用缓存优化
from functools import lru_cache

@lru_cache(maxsize=None)
def binary_search_cached(arr, low, high, x):
    return binary_search(arr, low, high, x)

8.3 使用迭代代替递归

在某些情况下，使用迭代代替递归可以避免栈溢出的风险，并且提高性能。以下是迭代实现的代码示例： 

def binary_search_iterative(arr, x):
    low = 0
    high = len(arr) - 1

    while low <= high:
        mid = (high + low) // 2

        if arr[mid] == x:
            return mid

        elif arr[mid] < x:
            low = mid + 1

        else:
            high = mid - 1

    return -1

# 测试迭代实现
arr = [2, 3, 4, 10, 40]
x = 10

result = binary_search_iterative(arr, x)
if result != -1:
    print("Element is present at index", str(result))
else:
    print("Element is not present in array")

9. 适用场景与注意事项

递归二分查找适用于已排序的数组或列表，能够高效地查找目标元素。但在使用时，需要注意以下几点：

9.1 数据必须已排序

递归二分查找的前提是数据必须是已排序的。如果数据未排序，二分查找将无法正确工作。

9.2 递归深度控制

在处理非常大的数据集时，递归深度可能过大，导致栈溢出。此时可以考虑使用尾递归优化或迭代实现。

9.3 边界条件处理

确保递归函数中的边界条件处理正确，特别是当搜索区间为空时，返回未找到的标志。

10. 二分查找的时间复杂度

二分查找的时间复杂度为 O(log n)，其中 n 是数组的长度。这意味着每次递归调用将搜索区间缩小一半，直到找到目标元素或确定元素不存在。

10.1 时间复杂度分析

输入数组长度 比较次数
10 4
100 7
1000 10
10000 14

通过上述表格可以看出，随着输入数组长度的增加，二分查找的比较次数增长缓慢，体现了其高效的查找能力。

11. 总结与应用

递归二分查找是一种高效的搜索算法，特别适用于已排序的数据集。通过递归方法，可以将复杂问题分解为更小的子问题，逐步解决，最终得到答案。在实际编程中，递归二分查找不仅简化了代码逻辑，还能显著提高查找效率。然而，在使用时需要注意栈溢出风险和数据的排序状态，以确保算法的正确性和高效性。

请继续阅读下半部分内容，了解更多关于递归二分查找的深入解析和技术细节。

使用递归的二分查找

12. 递归二分查找的深入解析

递归二分查找不仅在理论上具有重要意义，而且在实际应用中也非常广泛。为了更深入地理解这一算法，我们将探讨其背后的数学原理和具体实现中的细节。

12.1 数学原理

二分查找的核心在于对数时间复杂度 O(log n) 的实现。每次递归调用都将搜索区间缩小一半，直到找到目标元素或确定元素不存在。这种对数增长的时间复杂度使得二分查找在处理大规模数据时非常高效。

12.2 递归深度分析

递归深度是指递归调用的层数。对于二分查找而言，递归深度大约为 log₂(n)，其中 n 是数组的长度。例如，对于长度为 1000 的数组，递归深度约为 log₂(1000) ≈ 10。递归深度越深，占用的栈空间越大，因此在处理非常大的数据集时需要注意栈溢出的风险。

12.3 代码优化技巧

在实际编程中，除了前面提到的优化方法外，还有一些其他的技巧可以提高递归二分查找的性能。

12.3.1 使用二进制运算替代除法

在计算中间索引时，可以使用位运算替代除法，以提高计算效率。例如： 

def binary_search(arr, low, high, x):
    if high >= low:
        mid = low + ((high - low) >> 1)  # 使用位运算替代除法

        if arr[mid] == x:
            return mid

        elif arr[mid] > x:
            return binary_search(arr, low, mid - 1, x)

        else:
            return binary_search(arr, mid + 1, high, x)

    else:
        return -1
12.3.2 避免不必要的递归调用

在某些情况下，可以通过提前终止递归来避免不必要的调用。例如，当目标元素明显不在当前搜索区间时，可以直接返回未找到的结果。 

def binary_search(arr, low, high, x):
    if high >= low:
        mid = (high + low) // 2

        if arr[mid] == x:
            return mid

        elif arr[mid] > x:
            if mid == low and arr[low] != x:
                return -1
            return binary_search(arr, low, mid - 1, x)

        else:
            if mid == high and arr[high] != x:
                return -1
            return binary_search(arr, mid + 1, high, x)

    else:
        return -1

13. 实际应用案例分析

为了更好地理解递归二分查找的应用，我们来看几个实际案例。

13.1 案例1：查找学生名单中的名字

假设有一个已排序的学生名单，我们需要快速查找某个学生的名字是否在名单中。使用递归二分查找可以大大提高查找效率。 

students = ["Alice", "Bob", "Charlie", "David", "Eve", "Frank", "Grace"]

def binary_search_names(arr, low, high, name):
    if high >= low:
        mid = (high + low) // 2

        if arr[mid] == name:
            return mid

        elif arr[mid] > name:
            return binary_search_names(arr, low, mid - 1, name)

        else:
            return binary_search_names(arr, mid + 1, high, name)

    else:
        return -1

name_to_find = "Eve"
result = binary_search_names(students, 0, len(students) - 1, name_to_find)

if result != -1:
    print(f"Name '{name_to_find}' is present at index {result}")
else:
    print(f"Name '{name_to_find}' is not present in the list")

13.2 案例2：查找有序数组中的缺失数字

给定一个有序数组，其中缺少一个数字，我们需要快速找到缺失的数字。递归二分查找可以帮助我们高效地解决这个问题。 

def find_missing_number(arr, low, high):
    if high <= low:
        return low + 1

    mid = (high + low) // 2

    if arr[mid] == mid + 1:
        return find_missing_number(arr, mid + 1, high)
    else:
        return find_missing_number(arr, low, mid - 1)

# Test array
arr = [1, 2, 4, 5, 6]

# Function call
missing_number = find_missing_number(arr, 0, len(arr) - 1)
print(f"The missing number is {missing_number}")

13.3 mermaid流程图 

graph TD;
    A[开始] --> B{high >= low};
    B -->|是| C[计算 mid];
    C --> D{arr[mid] == x};
    D -->|是| E[返回 mid];
    D -->|否| F{arr[mid] > x};
    F -->|是| G[递归查找左子数组];
    F -->|否| H[递归查找右子数组];
    B -->|否| I[返回 -1];

14. 与其他搜索算法的对比

递归二分查找与其他搜索算法相比，具有明显的优点和缺点。以下是几种常见搜索算法的对比：

14.1 线性搜索 vs 二分查找

特征 线性搜索 二分查找
时间复杂度 O(n) O(log n)
数据结构 无序数组 已排序数组
代码复杂度 简单 较复杂
适用场景 小规模数据集 大规模数据集

线性搜索适用于无序数组，且代码实现简单，但对于大规模数据集，其效率较低。二分查找适用于已排序数组，虽然代码实现稍复杂，但其对数时间复杂度使其在大规模数据集中表现优异。

14.2 二分查找 vs 插值查找

插值查找是另一种基于键值分布的搜索算法，适用于键值分布较为均匀的已排序数组。与二分查找相比，插值查找在某些情况下可以更快地定位目标元素。

特征 二分查找 插值查找
时间复杂度 O(log n) O(log log n)
数据分布 任意 均匀分布
适用场景 已排序数组 已排序且均匀分布的数组

二分查找适用于任意已排序数组，而插值查找在键值分布均匀的情况下可以提供更快的查找速度。

15. 二分查找的局限性

尽管递归二分查找在很多场景中表现出色，但它也有一些局限性，需要在实际应用中加以注意。

15.1 数据必须已排序

递归二分查找的前提是数据必须是已排序的。如果数据未排序，二分查找将无法正确工作。因此，在使用二分查找之前，确保数据已经排序是非常重要的。

15.2 不适用于非均匀分布的数据

二分查找在键值分布不均匀的情况下，效率可能不如插值查找。因此，在处理非均匀分布的数据时，需要考虑其他更合适的搜索算法。

15.3 递归深度控制

递归深度是指递归调用的层数。对于非常大的数据集，递归深度可能过大，导致栈溢出。此时可以考虑使用尾递归优化或迭代实现。

16. 实际应用中的注意事项

在实际编程中，使用递归二分查找时还需要注意以下几个方面：

16.1 边界条件处理

确保递归函数中的边界条件处理正确，特别是当搜索区间为空时，返回未找到的标志。例如： 

def binary_search(arr, low, high, x):
    if high >= low:
        mid = (high + low) // 2

        if arr[mid] == x:
            return mid

        elif arr[mid] > x:
            return binary_search(arr, low, mid - 1, x)

        else:
            return binary_search(arr, mid + 1, high, x)

    else:
        return -1

16.2 确保数据已排序

在使用递归二分查找之前，确保数据已经排序。如果不满足这一条件，二分查找将无法正确工作。例如： 

def binary_search(arr, low, high, x):
    # 确保数据已排序
    if arr != sorted(arr):
        raise ValueError("Array must be sorted before performing binary search")

    if high >= low:
        mid = (high + low) // 2

        if arr[mid] == x:
            return mid

        elif arr[mid] > x:
            return binary_search(arr, low, mid - 1, x)

        else:
            return binary_search(arr, mid + 1, high, x)

    else:
        return -1

16.3 使用缓存优化

在处理大规模数据时，可以通过缓存优化来提高查找速度。例如： 

from functools import lru_cache

@lru_cache(maxsize=None)
def binary_search_cached(arr, low, high, x):
    if high >= low:
        mid = (high + low) // 2

        if arr[mid] == x:
            return mid

        elif arr[mid] > x:
            return binary_search_cached(arr, low, mid - 1, x)

        else:
            return binary_search_cached(arr, mid + 1, high, x)

    else:
        return -1

17. 二分查找的优化与改进

为了进一步提升递归二分查找的性能，可以考虑以下几种优化和改进方法：

17.1 使用尾递归优化

尾递归优化（Tail Recursion Optimization, TRO）通过将递归调用作为函数的最后一个操作，减少栈空间的占用。例如： 

def binary_search_tail_recursive(arr, low, high, x):
    while high >= low:
        mid = (high + low) // 2

        if arr[mid] == x:
            return mid

        elif arr[mid] > x:
            high = mid - 1

        else:
            low = mid + 1

    return -1

17.2 使用迭代代替递归

在某些情况下，使用迭代代替递归可以避免栈溢出的风险，并且提高性能。以下是迭代实现的代码示例： 

def binary_search_iterative(arr, x):
    low = 0
    high = len(arr) - 1

    while low <= high:
        mid = (high + low) // 2

        if arr[mid] == x:
            return mid

        elif arr[mid] < x:
            low = mid + 1

        else:
            high = mid - 1

    return -1

# 测试迭代实现
arr = [2, 3, 4, 10, 40]
x = 10

result = binary_search_iterative(arr, x)
if result != -1:
    print("Element is present at index", str(result))
else:
    print("Element is not present in array")

17.3 使用缓存优化

在处理大规模数据时，可以通过缓存优化来提高查找速度。例如： 

from functools import lru_cache

@lru_cache(maxsize=None)
def binary_search_cached(arr, low, high, x):
    return binary_search(arr, low, high, x)

18. 总结

递归二分查找是一种高效的搜索算法，特别适用于已排序的数据集。通过递归方法，可以将复杂问题分解为更小的子问题，逐步解决，最终得到答案。在实际编程中，递归二分查找不仅简化了代码逻辑，还能显著提高查找效率。然而，在使用时需要注意栈溢出风险和数据的排序状态，以确保算法的正确性和高效性。

通过递归二分查找，我们可以在对数时间内高效地查找元素，尤其适合大规模数据集的查找操作。递归方法将问题分解为更小的子问题，直到找到答案或确定元素不存在。在实际编程中，递归二分查找不仅简化了代码逻辑，还能显著提高查找效率。然而，在使用时需要注意栈溢出风险和数据的排序状态，以确保算法的正确性和高效性。

18.1 mermaid流程图 

graph TD;
    A[开始] --> B{high >= low};
    B -->|是| C[计算 mid];
    C --> D{arr[mid] == x};
    D -->|是| E[返回 mid];
    D -->|否| F{arr[mid] > x};
    F -->|是| G[递归查找左子数组];
    F -->|否| H[递归查找右子数组];
    B -->|否| I[返回 -1];

18.2 适用场景与注意事项

递归二分查找适用于已排序的数组或列表，能够高效地查找目标元素。但在使用时，需要注意以下几点：

  • 数据必须已排序 ：递归二分查找的前提是数据必须是已排序的。如果数据未排序，二分查找将无法正确工作。
  • 递归深度控制 ：在处理非常大的数据集时，递归深度可能过大，导致栈溢出。此时可以考虑使用尾递归优化或迭代实现。
  • 边界条件处理 ：确保递归函数中的边界条件处理正确，特别是当搜索区间为空时，返回未找到的标志。

通过这些优化和注意事项，递归二分查找可以在各种编程场景中发挥其高效、简洁的优势。希望这篇文章能帮助你更好地理解和应用递归二分查找算法。如果你有任何疑问或需要进一步的帮助，请随时留言！

递归和非递归的方式写二分查找有什么区别
yuanchangliang的博客
08-03 1314
递归和非递归的方式写二分查找有什么区别 前言：结论就是非递归比递归好用，既节省电脑的资源，写起来也方便 递归： 递归的二分查找方法，会调用一系列函数，并且会涉及到返回中的参数传递和返回值的额外开销，在一些嵌套层数深的算法中，递归会力不从心，空间上会以内存崩溃而告终。 但是递归也是有优势的，递归的代码的可读性强，程序员也容易进行编程。 非递归 非递归的二分查找一般就需要使用循环了，循环一般情况下会难以理解，而且要编写出循环实现功能也更加困难，不利于代码的可读性和代码的编写。但是循环的效率高，执行次数只会根
python递归实现二分查找算法_二分查找算法(递归）
weixin_39760857的博客
12-06 1011
二分查找算法l = [2,3,5,10,15,16,18,22,26,30,32,35,41,42,43,55,56,66,67,69,72,76,82,83,88]你观察这个列表，这是不是一个从小到大排序的有序列表呀？如果这样，假如我要找的数比列表中间的数还大，是不是我直接在列表的后半边找就行了？这就是二分查找算法！那么落实到代码上我们应该怎么实现呢？简单版二分法l = [2,3,5,10,15...
二分查找（非递归实现）
LeeBlog
08-26 433
【简介】 1)二分查找法只适用于从有序的数列中进行查找(比如数字和字母等)，将数列排序后再进行查找 2)二分查找法的运行时间为对数时间O(㏒₂n) ，即查找到需要的目标位置最多只需要㏒₂n步，假设从[0,99]的队列(100个数，即n=100)中寻到目标数30，则需要查找步数为㏒₂100 , 即最多需要查找7次( 2^6 < 100 < 2^7) 【说明】 运用非递归方式，...
【算法】递归实现二分查找（优化）以及非递归实现二分查找
2302_78914800的博客
07-31 511
1.首先确定该数组中间的下标 mid = (left + right) / 2;2.递归完整个数组，依然没有找到，即 left > right 就阶结束递归。2.然后让需要查找的数 findVal 和 arr[mid] 比较。
十大算法之二分查找非递归
qq_44300280的博客
05-18 191
二分查找算法(非递归)介绍
二分查找算法(非递归)
舒克日记的博客
05-25 1221
1、二分查找算法(非递归)介绍 前面我们讲过了二分查找算法，是使用递归的方式，下面我们讲解二分查找算法的非递归方式 二分查找法只适用于从有序的数列中进行查找(比如数字和字母等)，将数列排序后再进行查找 二分查找法的运行时间为对数时间O(㏒₂n) ，即查找到需要的目标位置最多只需要㏒₂n步，假设从[0,99]的队列(100个数，即n=100)中寻到目标数30，则需要查找步数为㏒₂100 , 即最多需要查找7次( 2^6 < 100 < 2^7) 2、二分查找算法(非递归)代码实现 数组 {1,
Java实现二分查找算法(非递归)
当一个合格的软件工程师
10-12 2712
14.1 二分查找算法(非递归) 14.1.1 二分查找算法(非递归)介绍 之前发过二分查找算法，是使用递归的方式，下面我们用二分查找算法的非递归方式 二分查找法只适用于从有序的数列中进行查找(比如数字和字母等)，将数列排序后再进行查找 二分查找法的运行时间为对数时间 O(㏒₂n) ，即查找到需要的目标位置最多只需要㏒₂n 步，假设从[0,99]的队列(100 个数，即 n=100)中寻到目标数 30，则需要查找步数为㏒₂100 , 即最多需要查找 7 次( 2^6 < 100 < 2^7)
用递归实现二分查找（c++）
w12563489的博客
09-12 564
#include <iostream> using namespace std; int EFCZ_age(int* age, int min, int max, int value) { if (min > max) { return -1; } //找不到元素 int mid = (max + min) / 2; if (age[mid] == value) { return mid; }//找到 else if (value > age[mid]) { return.
二分查找非递归算法
实践求真知
03-29 2365
一算法说明 1 二分查找可以使用递归的方式，也可以使用非递归的方式。 2 二分查找法只适用于从有序的数列中进行查找(比如数字和字母等)，将数列排序后再进行查找。 3 二分查找法的运行时间为对数时间O(㏒₂n) ，即查找到需要的目标位置最多只需要㏒₂n步，假设从[0,99]的队列(100个数，即n=100)中寻到目标数30，则需要查找步数为㏒₂100 , 即最多需要查找7次( 2^6 < 100 < 2^7)。 二 实战 1要求 数组{1,3, 8, 10, 11, 67, 100..
二分查找、快速排序、递归调用的分析
coder150806的博客
10-13 757
常见的基础算法，相信大家见过很多。接下来我来分析下二分查找、和快速排序算法。 二分查找： 前提是在已经排好序的数组中，通过查找的元素与中间元素索引值对应的元素进行比较，若大于中间索引值的元素，则向数组右半部分查找元素。依次类推，直到找到为止；找不到就返回一个负数； 二分查找的时间复杂度为O(log n) 下面是二分查找的代码： /** * 二分查找法（折半查找）：前提是在已经排好序的...
二分查找（非递归）
lxk116688的博客
02-18 324
基本介绍 前面我们学过了二分查找算法，是使用递归的方式，下面我们讲解二分查找算法的非递归方式 二分查找法只适用于从有序的数列中进行查找（比如数字和字母等），将数列排序后再进行查找 二分查找法的运行时间为对数时间，即查找到需要的目标位置最多只需要步。假设从【0，99】的队列（100个数，即n=100）中寻找目标数30，则需要查找步数为，即最多需要查找7次 package com.xxxx.tenmath; public class BinarySearchNoRecur { public stati
C语言快速排序与二分查找算法示例
08-28
以下是一个完整的示例代码，演示了如何使用快速排序算法和二分查找算法： ```c int main() { int arry[100]; int i, j; srand((unsigned) time(NULL)); // 产生不同的随机数 for (i = 0; i ; i++) { j = rand...
Pythonic版二分查找实现过程原理解析
09-16
首先，让我们从传统递归版本的二分查找开始。在Python中，一个简单的递归实现如下： ```python def binary_search(index, a, value): mid = len(a) // 2 if a[mid] == value: return index + mid elif a[mid] ...
ISO 10605-2023.pdf
12-03
ISO 10605-2023.pdf
（42页PPT）PP某省市大脑数据中台一网统管可视化平台建设方案.pptx
12-03
（42页PPT）PP某省市大脑数据中台一网统管可视化平台建设方案.pptx
六自由度机械臂ANN人工神经网络设计：正向逆向运动学求解、正向动力学控制、拉格朗日-欧拉法推导逆向动力学方程(Matlab代码实现)
最新发布
12-03
内容概要：本文围绕六自由度机械臂的人工神经网络（ANN）设计展开，重点研究了正向与逆向运动学求解、正向动力学控制以及基于拉格朗日-欧拉法推导逆向动力学方程，并通过Matlab代码实现相关算法。文章结合理论推导与仿真实践，利用人工神经网络对复杂的非线性关系进行建模与逼近，提升机械臂运动控制的精度与效率。同时涵盖了路径规划中的RRT算法与B样条优化方法，形成从运动学到动力学再到轨迹优化的完整技术链条。; 适合人群：具备一定机器人学、自动控制理论基础，熟悉Matlab编程，从事智能控制、机器人控制、运动学六自由度机械臂ANN人工神经网络设计：正向逆向运动学求解、正向动力学控制、拉格朗日-欧拉法推导逆向动力学方程(Matlab代码实现)建模等相关方向的研究生、科研人员及工程技术人员。; 使用场景及目标：①掌握机械臂正/逆运动学的数学建模与ANN求解方法；②理解拉格朗日-欧拉法在动力学建模中的应用；③实现基于神经网络的动力学补偿与高精度轨迹跟踪控制；④结合RRT与B样条完成平滑路径规划与优化。; 阅读建议：建议读者结合Matlab代码动手实践，先从运动学建模入手，逐步深入动力学分析与神经网络训练，注重理论推导与仿真实验的结合，以充分理解机械臂控制系统的设计流程与优化策略。
mall-swarm是一个基于SpringCloudHoxton与Alibaba生态构建的微服务分布式电商平台系统_它包含了完整的商品管理订单处理会员中心营销活动库存管.zip
12-03
mall-swarm是一个基于SpringCloudHoxton与Alibaba生态构建的微服务分布式电商平台系统_它包含了完整的商品管理订单处理会员中心营销活动库存管.zip
eBestMall_B2B2C商城系统_是一个基于Yii20框架构建的面向传统企业与创业者的综合性电子商务解决方案平台_它整合了零售网店网上商城多级分销B2B2C多商户商.zip
12-03
eBestMall_B2B2C商城系统_是一个基于Yii20框架构建的面向传统企业与创业者的综合性电子商务解决方案平台_它整合了零售网店网上商城多级分销B2B2C多商户商.zip
基于Python的Flask轻量级Web框架构建的现代化全栈应用开发项目_包含用户认证系统RESTfulAPI设计数据库模型与迁移前端模板渲染静态文件服务表单处理与验证.zip
12-03
基于Python的Flask轻量级Web框架构建的现代化全栈应用开发项目_包含用户认证系统RESTfulAPI设计数据库模型与迁移前端模板渲染静态文件服务表单处理与验证.zip
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值