【数据结构与算法】【小白也能学的数据结构与算法】迭代算法专题

news2024/11/15 20:32:07

🎉🎉欢迎光临🎉🎉

🏅我是苏泽，一位对技术充满热情的探索者和分享者。🚀🚀

🌟特别推荐给大家我的最新专栏《数据结构与算法：初学者入门指南》📘📘

本专栏纯属为爱发电永久免费！！！

这是苏泽的个人主页可以看到我其他的内容哦👇👇

努力的苏泽http://suzee.blog.csdn.net

迭代算法，这是一种解决问题的强大工具。通过迭代，我们可以重复应用一组规则或操作来解决复杂的问题。本文将从基础的迭代概念开始，逐步介绍迭代算法的不同应用和技巧

1. 迭代的基础概念

2. 迭代的高级技巧

3. 迭代算法的应用

迭代算法，这是一种解决问题的强大工具。通过迭代，我们可以重复应用一组规则或操作来解决复杂的问题。本文将从基础的迭代概念开始，逐步介绍迭代算法的不同应用和技巧

1. 迭代的基础概念

在计算机科学中，迭代是指通过多次重复应用一组规则或操作来解决问题的方法。它通常与循环结构紧密相关，通过迭代可以逐步改变问题的状态，直到达到所需的结果。

例如，考虑计算一个数组中所有元素的和。使用迭代的方法，我们可以通过循环遍历数组中的每个元素，并将其累加到一个变量中，最终得到总和。

下面是一个使用迭代计算数组元素和的示例代码：

def compute_sum(array):
    total = 0
    for num in array:
        total += num
    return total

# 测试代码
my_array = [1, 2, 3, 4, 5]
result = compute_sum(my_array)
print("The sum of the array is:", result)

在上述示例中，我们定义了一个compute_sum函数，接受一个数组作为输入，并使用迭代的方法计算数组元素的总和。通过循环遍历数组中的每个元素，并将其累加到变量total中，我们最终得到了数组的总和。

2. 迭代的高级技巧

除了基本的迭代概念外，还有一些高级的迭代技巧可以帮助我们解决更复杂的问题。以下是其中几种常见的技巧：

双指针迭代：在某些情况下，我们可以使用两个指针分别指向序列中的不同位置，并根据特定的规则移动这些指针来解决问题。例如，在查找排序数组中的两个数之和等于目标值的问题中，我们可以使用两个指针从序列的两端向中间移动。

def two_sum(nums, target):
    left = 0
    right = len(nums) - 1

    while left < right:
        sum = nums[left] + nums[right]
        if sum == target:
            return [nums[left], nums[right]]
        elif sum < target:
            left += 1
        else:
            right -= 1

    return []

# 测试代码
nums = [2, 7, 11, 15]
target = 9
result = two_sum(nums, target)
print("The two numbers with sum equal to", target, "are:", result)

在上述示例中，我们定义了一个two_sum函数，接受一个排序数组nums和目标值target作为输入。我们使用两个指针left和right分别指向数组的开头和末尾，并根据特定的规则移动这些指针。

如果指针所指的两个数之和等于目标值target，则返回这两个数。如果和小于目标值，则将left指针向右移动一位；如果和大于目标值，则将right指针向左移动一位。通过这种方式，我们逐步缩小搜索范围，直到找到满足条件的两个数或搜索范围为空。

迭代与递归的结合：有时候，我们可以将迭代与递归结合使用，以便更好地解决问题。例如，在树的遍历问题中，我们可以使用迭代的方式来模拟递归的过程，从而避免使用递归函数的系统调用开销。

class TreeNode:
    def __init__(self, value):
        self.val = value
        self.left = None
        self.right = None

def preorder_traversal(root):
    if root is None:
        return []

    stack = []
    result = []
    node = root

    while node or stack:
        while node:
            result.append(node.val)
            stack.append(node)
            node = node.left

        node = stack.pop()
        node = node.right

    return result

# 测试代码
root = TreeNode(1)
root.right = TreeNode(2)
root.right.left = TreeNode(3)

result = preorder_traversal(root)
print("The preorder traversal of the tree is:", result)

在上述示例中，我们定义了一个TreeNode类来表示树的节点，其中包含值val、左子节点left和右子节点right。

我们使用迭代的方式来实现树的前序遍历。首先，我们定义一个栈stack用于保存待访问的节点。我们从根节点开始，将根节点入栈。然后，不断迭代执行以下步骤：

弹出栈顶节点，并将其值添加到结果列表中。
将栈顶节点的右子节点入栈（如果存在）。
将栈顶节点的左子节点入栈（如果存在）。

通过这种方式，我们模拟了递归的过程，同时避免了使用递归函数的系统调用开销。

迭代与动态规划：迭代与动态规划经常结合使用，以解决一些具有最优子结构性质的问题。通过迭代计算和存储子问题的解，我们可以避免重复计算，提高算法效率。

def fibonacci(n):
    if n == 0:
        return 0
    if n == 1:
        return 1

    dp = [0] * (n + 1)
    dp[0] = 0
    dp[1] = 1

    for i in range(2, n + 1):
        dp[i] = dp[i - 1] + dp[i - 2]

    return dp[n]

# 测试代码
n = 6
result = fibonacci(n)
print("The", n, "th Fibonacci number is:", result)

我们使用迭代的方式，通过动态规划来避免重复计算。

我们使用一个数组dp来存储计算过的斐波那契数。首先，我们初始化dp[0]和dp[1]分别为0和1。然后，我们从dp[2]开始，通过迭代计算dp[i] = dp[i - 1] + dp[i - 2]，直到计算到第n个斐波那契数dp[n]。

通过这种方式，我们避免了重复计算，提高了算法效率。