二叉树与字符串的转换艺术

2023-12-02 02:21:27

递归法

递归是处理树形结构的经典方法。在二叉树与字符串的转换中，我们也可以利用递归的思想。

将二叉树转换为字符串

假设我们有一个二叉树，如下图所示：

我们可以使用以下递归算法将该二叉树转换为字符串：

def tree_to_str(root):
    if not root:
        return ""

    # 将根节点的值添加到字符串中
    s = str(root.val)

    # 如果左子树存在，则将其转换为字符串并添加到 s 中
    if root.left:
        s += "(" + tree_to_str(root.left) + ")"

    # 如果右子树存在，则将其转换为字符串并添加到 s 中
    if root.right:
        if root.left:
            s += "(" + tree_to_str(root.right) + ")"
        else:
            s += tree_to_str(root.right)

    # 返回字符串
    return s

使用该算法，我们可以将上述二叉树转换为字符串 "1(2(4,5),3)"。

将字符串转换为二叉树

我们也可以使用递归算法将字符串转换为二叉树。假设我们有一个字符串 "1(2(4,5),3)"，我们可以使用以下递归算法将其转换为二叉树：

def str_to_tree(s):
    # 去除字符串中的括号
    s = s[1:-1]

    # 将字符串拆分为根节点的值和子树的字符串
    i = 0
    while s[i] != '(':
        i += 1

    root = TreeNode(int(s[:i]))

    # 如果字符串中没有子树，则返回根节点
    if i == len(s):
        return root

    # 将字符串拆分为左子树和右子树的字符串
    j = i + 1
    depth = 0
    while j < len(s):
        if s[j] == '(':
            depth += 1
        elif s[j] == ')':
            depth -= 1

        if depth == 0:
            break

        j += 1

    left_subtree = s[i+1:j]
    right_subtree = s[j+1:-1]

    # 将左子树和右子树的字符串转换为二叉树
    root.left = str_to_tree(left_subtree)
    root.right = str_to_tree(right_subtree)

    # 返回根节点
    return root

使用该算法，我们可以将字符串 "1(2(4,5),3)" 转换为如下图所示的二叉树：

非递归法

除了递归法之外，我们还可以使用非递归的方式将二叉树转换为字符串或将字符串转换为二叉树。

将二叉树转换为字符串

我们可以使用栈来实现二叉树到字符串的非递归转换。算法如下：

def tree_to_str(root):
    if not root:
        return ""

    # 将根节点压入栈中
    stack = [root]

    # 循环，直到栈为空
    s = ""
    while stack:
        # 弹出栈顶节点
        node = stack.pop()

        # 将根节点的值添加到字符串中
        s += str(node.val)

        # 如果右子树存在，则将其压入栈中
        if node.right:
            stack.append(node.right)

        # 如果左子树存在，则将其压入栈中
        if node.left:
            stack.append(node.left)

    # 返回字符串
    return s

使用该算法，我们可以将上述二叉树转换为字符串 "12453"。

将字符串转换为二叉树

我们也可以使用栈来实现字符串到二叉树的非递归转换。算法如下：

def str_to_tree(s):
    # 去除字符串中的括号
    s = s[1:-1]

    # 将字符串拆分为根节点的值和子树的字符串
    i = 0
    while s[i] != '(':
        i += 1

    root = TreeNode(int(s[:i]))

    # 如果字符串中没有子树，则返回根节点
    if i == len(s):
        return root

    # 将字符串拆分为左子树和右子树的字符串
    j = i + 1
    depth = 0
    while j < len(s):
        if s[j] == '(':
            depth += 1
        elif s[j] == ')':
            depth -= 1

        if depth == 0:
            break

        j += 1

    left_subtree = s[i+1:j]
    right_subtree = s[j+1:-1]

    # 将左子树和右子树的字符串转换为二叉树
    root.left = str_to_tree(left_subtree)
    root.right = str_to_tree(right_subtree)

    # 返回根节点
    return root

使用该算法，我们可以将字符串 "12453" 转换为如下图所示的二叉树：

通用非递归法

我们还可以使用一种通用的非递归算法来实现二叉树和字符串之间的转换。该算法的核心思想是使用一个栈来存储当前正在处理的节点。

将二叉树转换为字符串

def tree_to_str(root):
    if not root:
        return ""

    # 将根节点压入栈中
    stack = [root]

    # 循环，直到栈为空
    s = ""
    while stack:
        # 弹出栈顶节点
        node = stack.pop()

        # 将根节点的值添加到字符串中
        s += str(node.val)

        # 如果右子树存在，则将其压入栈中
        if node.right:
            stack.append(node.right)

        # 如果左子树存在，则将其压入栈中
        if node.left:
            stack.append(node.left)

    # 返回字符串
    return s

将字符串转换为二叉树

def str_to_tree(s):
    # 去除字符串中的括号
    s = s[1:-1]

    # 将字符串拆分为根节点的值和子树的字符串
    i = 0
    while s[i] != '(':
        i += 1

    root = TreeNode(int(s[:i]))

    # 如果字符串中没有子树，则返回根节点
    if i == len(s):
        return root

    # 将字符串拆分为左子树和右子树的字符串
    j = i + 1
    depth = 0
    while j < len(s):
        if s[j] == '(':
            depth += 1
        elif s[j] == ')':
            depth -= 1

        if depth == 0:
            break

        j += 1

    left_subtree = s[i+1:j]
    right_subtree = s[j+1:-1]

    # 将左子树和右子树的字符串转换为二叉树
    root.left = str_to_tree(left_subtree)
    root.right = str_to_tree(right_subtree)

    # 返回根节点
    return root