算法分析|作业5(练习题)

本篇作业主要涉及到递归算法、分治算法以及基本数据结构的应用。通过解决这些练习题，能够提高程序员对算法和数据结构的理解和应用能力。

题目列表

1. 斐波那契数列求解，根据给定的参数求出对应的斐波那契数列的值。
2. 汉诺塔问题，将给定的n个盘子从起始塔移动到目标塔，通过中间塔作为辅助塔。
3. 归并排序算法，对给定的数组进行排序。
4. 二叉树的遍历，包括前序遍历、中序遍历和后序遍历。
5. 二叉树的查找，查找给定值在二叉树中的位置。

程序实现

斐波那契数列求解

def fibonacci(n: int) -> int:
    if n == 0 or n == 1:
        return n
    else:
        return fibonacci(n-1) + fibonacci(n-2)

这是一个简单的递归算法，通过调用函数本身来计算斐波那契数列的值。由于计算量的增长较快，当n较大时，算法的效率会大大降低。

汉诺塔问题

def hanoi(n: int, start: str, end: str, assist: str):
    if n == 1:
        print(start, "->", end)
    else:
        # 将n-1个盘子移动到辅助塔
        hanoi(n-1, start, assist, end)
        # 将第n个盘子移动到目标塔
        print(start, "->", end)
        # 将n-1个盘子从辅助塔移动到目标塔
        hanoi(n-1, assist, end, start)

这是一个经典的递归问题，通过调用函数本身来移动盘子。当n较大时，算法的效率会较低。

归并排序算法

def merge_sort(arr):
    if len(arr) <= 1:
        return arr
    
    # 分割数组为两部分
    mid = len(arr) // 2
    left = arr[:mid]
    right = arr[mid:]
    
    # 分别对左右部分进行排序
    left = merge_sort(left)
    right = merge_sort(right)
    
    # 合并左右两部分
    return merge(left, right)

def merge(left, right):
    result = []
    while len(left) > 0 and len(right) > 0:
        if left[0] <= right[0]:
            result.append(left.pop(0))
        else:
            result.append(right.pop(0))
    result += left
    result += right
    return result

这是一个应用了分治算法的排序算法，通过将数组不断分割为更小的部分，排序后将其合并，最终得到有序的结果。由于每个元素会被遍历多次，其时间复杂度为O(nlogn)。

二叉树的遍历

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

def preorder(root):
    if root:
        print(root.val, end=" ")
        preorder(root.left)
        preorder(root.right)

def inorder(root):
    if root:
        inorder(root.left)
        print(root.val, end=" ")
        inorder(root.right)

def postorder(root):
    if root:
        postorder(root.left)
        postorder(root.right)
        print(root.val, end=" ")

这里定义了一个二叉树节点的类，包括节点值val和左右子节点left、right。通过递归遍历左右子树，可以得到前序遍历、中序遍历和后序遍历的结果。

二叉树的查找

def search(root, val):
    if not root:
        return None
    elif root.val == val:
        return root
    elif root.val > val:
        return search(root.left, val)
    else:
        return search(root.right, val)

这个算法实现了二叉树的查找功能，通过递归查找左右子树的方式，可以在二叉树中查找到指定元素。其时间复杂度为O(logn)。