秒懂剑指offer 树专题--易

最新推荐文章于 2024-10-12 22:35:37 发布

心安成长

最新推荐文章于 2024-10-12 22:35:37 发布

阅读量162

点赞数

分类专栏：算法文章标签：二叉树 dfs bfs java

本文链接：https://blog.csdn.net/u014739136/article/details/108289851

版权

算法专栏收录该内容

7 篇文章 0 订阅

订阅专栏

题目1：二叉树的镜像

树问题的解决办法

树的遍历方式可以分为两类：深度优先搜索（Depth-First-Search）、广度优先搜索（Broad-First-Search）；

常见的 DFS ：先序遍历、中序遍历、后序遍历；
常见的 BFS ：层序遍历（即按层遍历）。
求树的深度需要遍历树的所有节点，本文将介绍基于后序遍历（DFS）和层序遍历（BFS）的两种解法。

题目描述
操作给定的二叉树，将其变换为源二叉树的镜像。

例子

二叉树的镜像定义：源二叉树
8
/ \
6 10
/ \ / \
5 7 9 11
镜像二叉树
8
/ \
10 6
/ \ / \
11 9 7 5

实现代码

方法一（递归）

/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;
 
    public TreeNode(int val) {
        this.val = val;
 
    }
 
}
*/
public class Solution {
    public void Mirror(TreeNode root) {
    	//边界判断
        if(root == null || (root.left == null && root.right == null)){
            return;
        }
        //创建左右子树交换的中间变量
        TreeNode curNode = null;
        //左右子树互换
        curNode = root.right;
        root.right = root.left;
        root.left = curNode;
        //如果左右子树（为之前的右子树），进入左子树
        if(root.left != null){
            Mirror(root.left);
        }
        if(root.right != null){
            Mirror(root.right);
        }
    }
}

方法二（非递归）

/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;
 
    public TreeNode(int val) {
        this.val = val;
 
    }
 
}
*/
import java.util.*;
public class Solution {
    public void Mirror(TreeNode root) {
    	//边界判断
        if(root == null)
            return;
        //用linkedlist实现队列
        Queue<TreeNode> q = new LinkedList<>();
        //当前出队的节点
        TreeNode p = null;
        TreeNode cur = null;
        // 层次遍历，交换左右子树
        // 跟节点入队，入队 q.offer()
        q.offer(root);
         
        while(!q.isEmpty()){
            // 出队， q.poll() 返回第一个元素，并删除，入队其左右子树
            p = q.poll();
             
            // 交换左右结点
            cur = p.left;
            p.left = p.right;
            p.right = cur;
             
            //左右不空的入队
            if(p.left != null)
                q.offer(p.left);
            if(p.right != null)
                q.offer(p.right);
        }
    }
}

题目2：二叉树的深度

题目描述
输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。

实现代码

方法一：后序遍历（DFS）

树的后序遍历/深度优先搜索一般使用的是递归或栈实现，这里使用递归。
这个树的深度和左右子树深度之间的关系。显而易见，此树的深度等于左子树的深度与右子树的深度中的最大值+1。

算法解析：

终止条件：当root为空，说明已经超越了叶子节点，因此返回深度0.
递推工作：本质上是对树做后续遍历。
2.1 计算节点root的左子树深度，调用的是maxDepth(root.left)；
2.2 计算节点root的右子树深度，调用的是maxDepth(root.right)；
返回值：返回此树的深度，即max(maxDepth(root.left), maxDepth(root.right)) + 1

时间复杂度：O(N), N为树的节点数量，计算树的深度需要遍历所有节点
空间复杂度：O(N), 最差情况，当树退化为链表，递归深度达到N。

class Solution{
	public int maxDepth(TreeNode root){
		if(root == null) return 0;
		return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;
	}
}

方法二：层序遍历（BFS）

树的层序遍历 / 广度优先搜索往往利用队列实现。
关键点：每遍历一层，则计数器 +1 ，直到遍历完成，则可得到树的深度。

算法解析：

特例处理：当 root 为空，直接返回深度 00 。
初始化：队列 queue （加入根节点 root ），计数器 res = 0。
循环遍历：当 queue 为空时跳出。
3.1 初始化一个空列表 tmp ，用于临时存储下一层节点；
3.2 遍历队列：遍历 queue 中的各节点 node ，并将其左子节点和右子节点加入 tmp；
3.3 更新队列：执行 queue = tmp ，将下一层节点赋值给 queue；
3.4 统计层数：执行 res += 1 ，代表层数加 11；
返回值：返回 res 即可。

复杂度分析：
时间复杂度 O(N) ： NN 为树的节点数量，计算树的深度需要遍历所有节点。
空间复杂度 O(N) ：最差情况下（当树平衡时），队列 queue 同时存储 N/2 个节点。

class Solution {
    public int maxDepth(TreeNode root) {
        if(root == null) return 0;
        List<TreeNode> queue = new LinkedList<>() {{ add(root); }}, tmp;
        int res = 0;
        while(!queue.isEmpty()) {
            tmp = new LinkedList<>();
            for(TreeNode node : queue) {
                if(node.left != null) tmp.add(node.left);
                if(node.right != null) tmp.add(node.right);
            }
            queue = tmp;
            res++;
        }
        return res;
    }
}