二叉树问题

已于 2022-04-27 20:38:08 修改
阅读量1.2k 收藏 1
点赞数
分类专栏： 算法 文章标签： java
于 2022-03-22 21:25:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nice___amusin/article/details/123670684
版权
本文详细介绍了二叉树的各种遍历方法，包括前序、中序、后序遍历的递归与迭代实现，以及层序遍历（广度优先搜索）。此外，还涵盖了二叉树的最大深度计算、对称性检查、翻转、路径总和判断、二叉搜索树验证及构造二叉树等算法。这些内容对于理解二叉树操作至关重要。
摘要由CSDN通过智能技术生成

目录：

1、二叉树的前序遍历

在这里插入图片描述
前序遍历的输入顺序为：A-B-D-F-G-H-I-E-C

递归法
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<Integer>();
        pre(root,list);
        return list;
    }
    //前序遍历
    void pre(TreeNode root,List<Integer> list){
    	//当节点为空时，返回
        if(root == null){
            return;
        }
        list.add(root.val);		//先用list记录当前节点值
        pre(root.left,list);	//递归遍历节点的左子树
        pre(root.right,list);	//递归遍历节点的右子树
    }
}
迭代法
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        if (root == null) {
            return res;
        }
		
		//Deque是双端队列，可以在两端插入删除元素
        Deque<TreeNode> stack = new LinkedList<TreeNode>();
        TreeNode node = root;
        while (!stack.isEmpty() || node != null) {
            while (node != null) {
                res.add(node.val);	//添加该节点值
                stack.push(node);	//将该节点压入队列中
                node = node.left;	//如果node.left存在，则重复第二个while循环
            }
            node = stack.pop();	//最近压入队列中的节点出队列
            node = node.right;
        }
        return res;
    }
}

2、二叉树的中序遍历

在这里插入图片描述
中序遍历的输入顺序为：F-D-H-G-I-B-E-A-C

递归法
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<Integer>();
        mid(root,list);
        return list;
    }
    void mid(TreeNode root,List<Integer> list){
        if(root == null){
            return;
        }
        mid(root.left,list);	//直接递归到最左节点
        list.add(root.val);		//添加该节点的值
        mid(root.right,list);	//再递归右子树
    }
}
迭代法
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        Deque<TreeNode> stk = new LinkedList<TreeNode>();
        while (root != null || !stk.isEmpty()) {
            while (root != null) {	//当压入到最左节点时停止
                stk.push(root);		//不断压入
                root = root.left;
            }
            root = stk.pop();	//通过出队列，节点不断往上走
            res.add(root.val);
            root = root.right;
        }
        return res;
    }
}

3、二叉树的后序遍历

在这里插入图片描述
后序遍历的输入顺序为：F-H-I-G-D-E-B-C-A

递归法
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<Integer>();
        mid(root,list);
        return list;
    }
    void mid(TreeNode root,List<Integer> list){
        if(root == null){
            return;
        }
        mid(root.left,list);	//直接递归到最左节点
        mid(root.right,list);	//再看右子树
        list.add(root.val);		//最后添加该节点的值
    }
}

4、二叉树的层序遍历

在这里插入图片描述

层序遍历
输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]

广度优先搜索BFS
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> list1= new ArrayList<List<Integer>>();
        if(root == null){
            return list1;
        }
        //BFS
        Queue<TreeNode> queue = new LinkedList<TreeNode>();	//单端队列，先进先出
        queue.add(root);
        while(!queue.isEmpty()){
            List<Integer> list2= new ArrayList<Integer>();
            int size = queue.size();	//size为当前队列的长度
            for(int i=1;i<=size;i++){
                TreeNode node = queue.poll(); //将一个节点出队列
                list2.add(node.val);	//添加该节点的值
                if(node.left != null){	//如果有左子树，左子树进队列
                    queue.add(node.left);
                }
                if(node.right != null){	//如果有右子树，右子树进队列
                    queue.add(node.right);
                }
            }
            //在一个for循环后，这同一层的节点值都在lsit2中了
            list1.add(list2);
        }
        return list1;
    }
}

5、二叉树的最大深度问题

在这里插入图片描述

最大深度为：3

递归法：深度优先搜索DFS

在这里插入图片描述

class Solution {
    public int maxDepth(TreeNode root) {
        if(root == null){ //节点为空，返回0
            return 0;
        }
        else{
            int leftmax = maxDepth(root.left);	//遍历左子树
            int rightmax = maxDepth(root.right);
            return Math.max(leftmax,rightmax)+1;
        }

    }  
}
广度优先搜索
class Solution {
    public int maxDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offer(root);
        int ans = 0;	//记录高度的计数器
        while (!queue.isEmpty()) {
            int size = queue.size();
            while (size > 0) {
                TreeNode node = queue.poll();
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
                size--;
            }
            ans++;	//每完成一次while循环，高度就加一
        }
        return ans;
    }
}

6、对称二叉树

在这里插入图片描述

递归法
class Solution {
    public boolean isSymmetric(TreeNode root) {
        return compare(root.left,root.right);
    }
    boolean compare(TreeNode left,TreeNode right){
    	//当左右节点不为空，且值相等时，比较判断左节点的左子树和右节点的右子树，左节点的右子树和右节点的左子树是否相等。
        if((left!=null&&right!=null)&&left.val==right.val){
            return compare(left.left,right.right) && compare(left.right,right.left);
        }
        //直至都为空时，判断完成，返回true
        else if(left==null && right==null){
            return true;
        }
        else{
            return false;
        }
    }
}

7、翻转二叉树

在这里插入图片描述

递归法
class Solution {
    public TreeNode invertTree(TreeNode root) {
        if(root == null){
            return null;
        }
        TreeNode left1 = invertTree(root.right);
        TreeNode right1 = invertTree(root.left);
        root.left = left1;
        root.right = right1;
        return root;
    }
}

8、二叉树的路径总和

在这里插入图片描述
判断二叉树根节点到叶子节点的路径总和是否为targetSum。如果是，返回true，否则返回false。

递归法
class Solution {
    public boolean hasPathSum(TreeNode root, int targetSum) {
        if(root == null){
            return false;
        }
        if(root.left == null && root.right ==null){
            return targetSum == root.val;
        }
        return hasPathSum(root.left,targetSum-root.val) || hasPathSum(root.right,targetSum-root.val);

    }
}

9、验证二叉搜索树

在这里插入图片描述

中序遍历法
class Solution {
    public boolean isValidBST(TreeNode root) {
        Deque<TreeNode> stack = new LinkedList<TreeNode>();
        double inorder = -Double.MAX_VALUE;

        while (!stack.isEmpty() || root != null) {
            while (root != null) {
                stack.push(root);
                root = root.left;
            }
            root = stack.pop();
              // 如果中序遍历得到的节点的值小于等于前一个 inorder，说明不是二叉搜索树
            if (root.val <= inorder) {
                return false;
            }
            inorder = root.val;
            root = root.right;
        }
        return true;
    }
}
递归法
class Solution {
    public boolean isValidBST(TreeNode root) {
        return isValidBST(root, Long.MIN_VALUE, Long.MAX_VALUE);
    }

    public boolean isValidBST(TreeNode node, long lower, long upper) {
        if (node == null) {
            return true;
        }
        if (node.val <= lower || node.val >= upper) {
            return false;
        }
        return isValidBST(node.left, lower, node.val) && isValidBST(node.right, node.val, upper);
    }
}

10、根据前序与中序遍历序列构造二叉树

在这里插入图片描述

class Solution {
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        if(preorder.length==0 || inorder.length==0){
            return null;
        }
        TreeNode root = new TreeNode(preorder[0]);
        for(int i=0;i<preorder.length;i++){
            if(preorder[0] == inorder[i]){
                // 前序遍历：根左右
                // 中序遍历：左根右
                root.left = buildTree(Arrays.copyOfRange(preorder,1,i+1),
                            Arrays.copyOfRange(inorder,0,i));
                root.right = buildTree(Arrays.copyOfRange(preorder,i+1,preorder.length),
                            Arrays.copyOfRange(inorder,i+1,inorder.length));
                break;
            }
        }
        return root;
    }
}
A snicker
关注
专栏目录
[JLOI2009]二叉树问题
guo_dong_yu的博客
06-12 229
洛谷题面 如下图所示的一棵二叉树的深度、宽度及结点间距离分别为： 深度：4 宽度：4（同一层最多结点个数） 结点间距离： ⑧→⑥为8 (3×2+2=8) ⑥→⑦为3 （1×2+1=3） 注：结点间距离的定义：由结点向根方向（上行方向）时的边数×2， 与由根向叶结点方向（下行方向）时的边数之和。 题目大意： 给定一棵二叉树，求其的深度和结点最多的一层的结点数。 输入u、v，求这两个结点之间的距离（距离的计算方法如上）。 深度和宽度都很好求，只需要在读入数据的同时进行处理即可，唯一的一点应该是求距离。 一
二叉树
热门推荐
Richard_Cai
09-19 5万+
二叉树的优势       在实际使用时会根据链表和有序数组等数据结构的不同优势进行选择。有序数组的优势在于二分查找，链表的优势在于数据项的插入和数据项的删除。但是在有序数组中插入数据就会很慢，同样在链表中查找数据项效率就很低。综合以上情况，二叉树可以利用链表和有序数组的优势，同时可以合并有序数组和链表的优势，二叉树也是一种常用的数据结构。二叉树的构成      二叉树由节点（node）和边组成。节点
二叉树常见问题
qq_43578870的博客
05-24 743
前言 最近在复习数据结构，将一些习题以代码的形式记录，作为笔记。 不使用STL，算法题中假设栈、队列的maxSize足够大。 会持续更新。 求非空二叉树的宽度（最多节点那层的节点数） 利用队列进行层次遍历，同时统计每一层的节点数 int solve(Node *node){ int ans_cnt = 0, cnt = 0; Node *last = node; // 定义last指向当前层的最右边那个节点 Node* q[maxSize]; in
python先序遍历二叉树问题
12-25
问题 如何遍历一个二叉树 遍历二叉树就是访问二叉树的每一个节点 二叉树父结点下先左访问，先序遍历（根左右） 例如：遍历以下的二叉树 遍历结果：ABDECF Python代码示例 # !/usr/bin/env python # -*-encoding: ...
算法设计与分析：二叉树问题的解决思路
GentleCP的博客
05-12 2491
讲解一般二叉树问题的解决思想、思路
leetcode二叉树问题本地调试 java——Eclipse版
Reoz的博客
06-18 1273
最近一直在leetcode上刷题，每次在做比较复杂的二叉树问题时，都想先调试再提交，但是在线编辑器并不支持这个功能，于是就想到了在eclipse上自己弄一套二叉树的代码方便调试，这里把我的代码分享给大家，有需要的同学可以按照我的这套方法在自己的编辑器上还原出来。 首先看下项目的结构 这里我把构建二叉树的代码放在了Tree目录下，solutions用于存放我的题解，在题解中调用Tree中的二叉树就可以用来调试了。 OK，下面废话不多说，直接放上Tree中每个文件的代码： 首先是TreeNode：这里是用.
数据结构二叉树问题
02-03
很好的数据结构编程代码，二叉树实验报告。是C++编程的源代码
关于二叉树的一些问题
weixin_30548917的博客
07-27 106
1，写一个算法，要求给定一个二叉树，算法能够返回其高度？解答：可以递归地去求子树的高度，这个问题的子问题就是，以当前节点为根的树德高度，为其左右子树高度的最大者再+1。定义空节点的高度为-1，叶子节点的高度为0，伪代码如下：int Tree-Height(Node* root) //root为当前所访问节点{ if (root == NULL) retur...
【洛谷 3884】二叉树问题
weixin_30273501的博客
07-22 235
题目描述 如下图所示的一棵二叉树的深度、宽度及结点间距离分别为： 深度：4 宽度：4（同一层最多结点个数） 结点间距离： ⑧→⑥为8 (3×2+2=8) ⑥→⑦为3 （1×2+1=3） 注：结点间距离的定义：由结点向根方向（上行方向）时的边数×2， 与由根向叶结点方向（下行方向）时的边数之和。 输入输出格式 输入格式： 输入文件第一行为一个整数n(1≤n≤10...
二叉树的常见问题
luanqibaazao的博客
06-26 495
一用两个栈实现队列 入队：直接入栈A 出队：判断栈B是否为空 如果B为空，A中元素先出栈，再入栈B 2. 二叉树的常见问题1 二叉树的常见问题及其解决程序 http://blog.csdn.net/randyjiawenjie/article/details/6772145 （1.二叉树三种周游（traversal）方式： （2.怎样从顶部开始逐层打印二叉树结点数据 （3.如何判断一棵二叉
常见关于二叉树的问题（1）
houxiaoliwang的博客
12-12 557
问题1：计算一共有多少个节点。运用递归思想，迭代计算出结点个数。 问题2：计算二叉树的深度。循环求解的思想，层层计算，每次向下一层，直至到底。 问题3：三种遍历二叉树，先序遍历，中序遍历，后序遍历。都是运用的递归思想，经典的算法。
Go语言实战：面试常见二叉树问题及代码实现
总结来说，面试中关于二叉树的问题通常考察对数据结构的理解、节点操作的实现以及递归算法的应用。熟练掌握这些基础操作和算法能够帮助你在面试中表现出对数据结构和算法的扎实功底。同时，理解如何在实际场景中使用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值