算法模式中的二叉树数据结构详解-优快云博客

本文链接：https://blog.youkuaiyun.com/gitblog_00058/article/details/148377432

算法模式中的二叉树数据结构详解

algorithm-pattern 算法模板，最科学的刷题方式，最快速的刷题路径，你值得拥有~ 项目地址: https://gitcode.com/gh_mirrors/al/algorithm-pattern

前言

二叉树是计算机科学中最基础也是最重要的数据结构之一，在算法模式中占据着核心地位。本文将系统性地介绍二叉树的相关知识，包括遍历方法、分治法应用、BFS层次遍历以及二叉搜索树的操作等核心内容。

二叉树基础概念

二叉树是每个节点最多有两个子节点的树结构，通常称为左子节点和右子节点。二叉树具有以下特点：

每个节点最多有两个子节点
左子节点和右子节点有顺序之分
空树也是二叉树的一种形式

二叉树遍历方法

1. 递归遍历

二叉树有三种基本的递归遍历方式，区别在于访问根节点的时机不同：

前序遍历：根节点 → 左子树 → 右子树
中序遍历：左子树 → 根节点 → 右子树
后序遍历：左子树 → 右子树 → 根节点

// 前序遍历递归实现
func preorderTraversal(root *TreeNode) {
    if root == nil {
        return
    }
    fmt.Println(root.Val)  // 先访问根节点
    preorderTraversal(root.Left)
    preorderTraversal(root.Right)
}

2. 非递归遍历（迭代法）

递归方法虽然简洁，但在处理大型树时可能导致栈溢出。非递归实现使用栈来模拟递归过程：

前序非递归实现

func preorderTraversal(root *TreeNode) []int {
    if root == nil {
        return nil
    }
    result := make([]int, 0)
    stack := make([]*TreeNode, 0)
    
    for root != nil || len(stack) != 0 {
        for root != nil {
            result = append(result, root.Val) // 访问节点
            stack = append(stack, root)
            root = root.Left
        }
        node := stack[len(stack)-1]
        stack = stack[:len(stack)-1]
        root = node.Right
    }
    return result
}

中序非递归实现

func inorderTraversal(root *TreeNode) []int {
    result := make([]int, 0)
    stack := make([]*TreeNode, 0)
    
    for len(stack) > 0 || root != nil {
        for root != nil {
            stack = append(stack, root)
            root = root.Left
        }
        node := stack[len(stack)-1]
        stack = stack[:len(stack)-1]
        result = append(result, node.Val) // 访问节点
        root = node.Right
    }
    return result
}

后序非递归实现

后序遍历较为复杂，需要记录最后访问的节点：

func postorderTraversal(root *TreeNode) []int {
    if root == nil {
        return nil
    }
    result := make([]int, 0)
    stack := make([]*TreeNode, 0)
    var lastVisit *TreeNode
    
    for root != nil || len(stack) != 0 {
        for root != nil {
            stack = append(stack, root)
            root = root.Left
        }
        node := stack[len(stack)-1]
        if node.Right == nil || node.Right == lastVisit {
            stack = stack[:len(stack)-1]
            result = append(result, node.Val)
            lastVisit = node
        } else {
            root = node.Right
        }
    }
    return result
}

深度优先搜索(DFS)的两种实现方式

1. 自上而下的DFS

func preorderTraversal(root *TreeNode) []int {
    result := make([]int, 0)
    dfs(root, &result)
    return result
}

func dfs(root *TreeNode, result *[]int) {
    if root == nil {
        return
    }
    *result = append(*result, root.Val)
    dfs(root.Left, result)
    dfs(root.Right, result)
}

2. 自下而上的分治法

func preorderTraversal(root *TreeNode) []int {
    return divideAndConquer(root)
}

func divideAndConquer(root *TreeNode) []int {
    result := make([]int, 0)
    if root == nil {
        return result
    }
    // 分治
    left := divideAndConquer(root.Left)
    right := divideAndConquer(root.Right)
    // 合并结果
    result = append(result, root.Val)
    result = append(result, left...)
    result = append(result, right...)
    return result
}

两种方式的区别：

自上而下：通过指针参数传递结果
分治法：递归返回结果最后合并

广度优先搜索(BFS)层次遍历

层次遍历使用队列实现，可以很好地解决按层处理二叉树的问题：

func levelOrder(root *TreeNode) [][]int {
    result := make([][]int, 0)
    if root == nil {
        return result
    }
    queue := make([]*TreeNode, 0)
    queue = append(queue, root)
    
    for len(queue) > 0 {
        levelSize := len(queue)
        level := make([]int, 0)
        for i := 0; i < levelSize; i++ {
            node := queue[0]
            queue = queue[1:]
            level = append(level, node.Val)
            if node.Left != nil {
                queue = append(queue, node.Left)
            }
            if node.Right != nil {
                queue = append(queue, node.Right)
            }
        }
        result = append(result, level)
    }
    return result
}

变种：

自底向上层次遍历：反转结果即可
Z字形遍历：根据层级决定是否反转当前层结果

分治法应用

分治法在二叉树问题中应用广泛，基本模板如下：

func traversal(root *TreeNode) ResultType {
    // 递归返回条件
    if root == nil {
        // 返回空结果或特定值
    }
    
    // 分治(Divide)
    left := traversal(root.Left)
    right := traversal(root.Right)
    
    // 合并结果(Conquer)
    result := merge(left, right)
    return result
}

典型应用示例

二叉树的最大深度

func maxDepth(root *TreeNode) int {
    if root == nil {
        return 0
    }
    left := maxDepth(root.Left)
    right := maxDepth(root.Right)
    if left > right {
        return left + 1
    }
    return right + 1
}

验证二叉搜索树

func isValidBST(root *TreeNode) bool {
    return helper(root, nil, nil)
}

func helper(node, lower, upper *TreeNode) bool {
    if node == nil {
        return true
    }
    val := node.Val
    if lower != nil && val <= lower.Val {
        return false
    }
    if upper != nil && val >= upper.Val {
        return false
    }
    return helper(node.Left, lower, node) && 
           helper(node.Right, node, upper)
}

二叉搜索树(BST)操作

二叉搜索树是一种特殊的二叉树，对于每个节点：

左子树所有节点的值 < 当前节点的值
右子树所有节点的值 > 当前节点的值

BST插入操作

func insertIntoBST(root *TreeNode, val int) *TreeNode {
    if root == nil {
        return &TreeNode{Val: val}
    }
    if val < root.Val {
        root.Left = insertIntoBST(root.Left, val)
    } else {
        root.Right = insertIntoBST(root.Right, val)
    }
    return root
}