算法：复杂度分析

1 算法效率评估

算法效率评估通常涉及对算法执行时间的测量。

import time

def example_algorithm(n):
    start_time = time.time()
    
    # 算法实现
    
    end_time = time.time()
    execution_time = end_time - start_time
    
    print(f"Algorithm executed in {execution_time} seconds for input size {n}")

# 调用示例算法
example_algorithm(1000)

复杂度分析:

• 时间复杂度：在这个例子中，算法的执行时间与输入规模 n 无关，所以时间复杂度为 O(1)（常数时间）。
• 空间复杂度：算法并没有使用额外的内存空间与输入规模相关，所以空间复杂度也为 O(1)。

2 迭代与递归

在算法中，重复执行某个任务是很常见的，它与复杂度分析息息相关。

迭代版本:

def fibonacci_iterative(n):
    a, b = 0, 1
    for _ in range(n - 1):
        a, b = b, a + b
    return a

result = fibonacci_iterative(5)
print(result)

递归版本:

def fibonacci_recursive(n):
    if n <= 1:
        return n
    return fibonacci_recursive(n - 1) + fibonacci_recursive(n - 2)

result = fibonacci_recursive(5)
print(result)

复杂度分析:

• 时间复杂度（迭代版本）：循环执行了 n-1 次，所以时间复杂度为 O(n)。
• 时间复杂度（递归版本）：指数级递归，时间复杂度为 O(2^n)，在实际中效率较低。
• 空间复杂度（迭代版本和递归版本）：仅使用常数级的额外空间，空间复杂度为 O(1)。

3 时间复杂度

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("Sorted array:", arr)

复杂度分析:

• 时间复杂度：双重循环，最坏情况下需要执行 n * (n-1)/2 次，时间复杂度为 O(n^2)。
• 空间复杂度：仅使用了常数级的额外空间，空间复杂度为 O(1)。

4 空间复杂度

def fibonacci_recursive_with_memory(n, memo={}):
    if n <= 1:
        return n
    if n not in memo:
        memo[n] = fibonacci_recursive_with_memory(n - 1, memo) + fibonacci_recursive_with_memory(n - 2, memo)
    return memo[n]

result = fibonacci_recursive_with_memory(5)
print(result)

复杂度分析:

• 时间复杂度：虽然使用了递归，但通过记忆化搜索（memoization）避免了重复计算，时间复杂度为 O(n)。
• 空间复杂度：使用了额外的字典存储中间结果，空间复杂度为 O(n)。

5 小结

以上示例通过具体代码演示了复杂度的计算过程，包括时间复杂度和空间复杂度的分析。这有助于理解不同算法在处理不同规模输入时的性能表现。