关于二叉树的22个常见问题

最新推荐文章于 2024-08-30 23:53:07 发布
最新推荐文章于 2024-08-30 23:53:07 发布
阅读量972 收藏 9
点赞数 1
分类专栏： 算法 JAVA 基础 文章标签： java 二叉树

先上二叉树的数据结构：

class TreeNode{
    int val;
    //左孩子
    TreeNode left;
    //右孩子
    TreeNode right;
}

二叉树的题目普遍可以用递归和迭代的方式来解

1. 求二叉树的最大深度

int maxDeath(TreeNode node){
    if(node==null){
        return 0;
    }
    int left = maxDeath(node.left);
    int right = maxDeath(node.right);
    return Math.max(left,right) + 1;
}

2. 求二叉树的最小深度

    int getMinDepth(TreeNode root){
        if(root == null){
            return 0;
        }
        return getMin(root);
    }
    int getMin(TreeNode root){
        if(root == null){
            return Integer.MAX_VALUE;
        }
        if(root.left == null&&root.right == null){
            return 1;
        }
        return Math.min(getMin(root.left),getMin(root.right)) + 1;
    }

3. 求二叉树中节点的个数

    int numOfTreeNode(TreeNode root){
        if(root == null){
            return 0;
        }
        int left = numOfTreeNode(root.left);
        int right = numOfTreeNode(root.right);
        return left + right + 1;
    }

4. 求二叉树中叶子节点的个数

    int numsOfNoChildNode(TreeNode root){
        if(root == null){
            return 0;
        }
        if(root.left==null&&root.right==null){
            return 1;
        }
        return numsOfNodeTreeNode(root.left)+numsOfNodeTreeNode(root.right);
    }

5. 求二叉树中第k层节点的个数

        int numsOfkLevelTreeNode(TreeNode root,int k){
            if(root == null||k<1){
                return 0;
            }
            if(k==1){
                return 1;
            }
            int numsLeft = numsOfkLevelTreeNode(root.left,k-1);
            int numsRight = numsOfkLevelTreeNode(root.right,k-1);
            return numsLeft + numsRight;
        }

6. 判断二叉树是否是平衡二叉树

    boolean isBalanced(TreeNode node){
        return maxDeath2(node)!=-1;
    }
    int maxDeath2(TreeNode node){
        if(node == null){
            return 0;
        }
        int left = maxDeath2(node.left);
        int right = maxDeath2(node.right);
        if(left==-1||right==-1||Math.abs(left-right)>1){
            return -1;
        }
        return Math.max(left, right) + 1;
    }

7.判断二叉树是否是完全二叉树

什么是完全二叉树呢？参见

    boolean isCompleteTreeNode(TreeNode root){
        if(root == null){
            return false;
        }
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.add(root);
        boolean result = true;
        boolean hasNoChild = false;
        while(!queue.isEmpty()){
            TreeNode current = queue.remove();
            if(hasNoChild){
                if(current.left!=null||current.right!=null){
                    result = false;
                    break;
                }
            }else{
                if(current.left!=null&&current.right!=null){
                    queue.add(current.left);
                    queue.add(current.right);
                }else if(current.left!=null&&current.right==null){
                    queue.add(current.left);
                    hasNoChild = true;
                }else if(current.left==null&&current.right!=null){
                    result = false;
                    break;
                }else{
                    hasNoChild = true;
                }
            }
        }
        return result;
    }

8. 两个二叉树是否完全相同

    boolean isSameTreeNode(TreeNode t1,TreeNode t2){
        if(t1==null&&t2==null){
            return true;
        }
        else if(t1==null||t2==null){
            return false;
        }
        if(t1.val != t2.val){
            return false;
        }
        boolean left = isSameTreeNode(t1.left,t2.left);
        boolean right = isSameTreeNode(t1.right,t2.right);
        return left&&right;
    }

9. 两个二叉树是否互为镜像

    boolean isMirror(TreeNode t1,TreeNode t2){
        if(t1==null&&t2==null){
            return true;
        }
        if(t1==null||t2==null){
            return false;
        }
        if(t1.val != t2.val){
            return false;
        }
        return isMirror(t1.left,t2.right)&&isMirror(t1.right,t2.left);
    }

10. 翻转二叉树or镜像二叉树

    TreeNode mirrorTreeNode(TreeNode root){
        if(root == null){
            return null;
        }
        TreeNode left = mirrorTreeNode(root.left);
        TreeNode right = mirrorTreeNode(root.right);
        root.left = right;
        root.right = left;
        return root;
    }

11. 求两个二叉树的最低公共祖先节点

    TreeNode getLastCommonParent(TreeNode root,TreeNode t1,TreeNode t2){
        if(findNode(root.left,t1)){
            if(findNode(root.right,t2)){
                return root;
            }else{
                return getLastCommonParent(root.left,t1,t2);
            }
        }else{
            if(findNode(root.left,t2)){
                return root;
            }else{
                return getLastCommonParent(root.right,t1,t2)
            }
        }
    }
    // 查找节点node是否在当前 二叉树中
    boolean findNode(TreeNode root,TreeNode node){
        if(root == null || node == null){
            return false;
        }
        if(root == node){
            return true;
        }
        boolean found = findNode(root.left,node);
        if(!found){
            found = findNode(root.right,node);
        }
        return found;
    }

12. 二叉树的前序遍历

迭代解法

    ArrayList<Integer> preOrder(TreeNode root){
        Stack<TreeNode> stack = new Stack<TreeNode>();
        ArrayList<Integer> list = new ArrayList<Integer>();
        if(root == null){
            return list;
        }
        stack.push(root);
        while(!stack.empty()){
            TreeNode node = stack.pop();
            list.add(node.val);
            if(node.right!=null){
                stack.push(node.right);
            }
            if(node.left != null){
                stack.push(node.left);
            }
        }
        return list;
    }

递归解法

    ArrayList<Integer> preOrderReverse(TreeNode root){
        ArrayList<Integer> result = new ArrayList<Integer>();
        preOrder2(root,result);
        return result;
    }
    void preOrder2(TreeNode root,ArrayList<Integer> result){
        if(root == null){
            return;
        }
        result.add(root.val);
        preOrder2(root.left,result);
        preOrder2(root.right,result);
    }

13. 二叉树的中序遍历

    ArrayList<Integer> inOrder(TreeNode root){
        ArrayList<Integer> list = new ArrayList<<Integer>();
        Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode current = root;
        while(current != null|| !stack.empty()){
            while(current != null){
                stack.add(current);
                current = current.left;
            }
            current = stack.peek();
            stack.pop();
            list.add(current.val);
            current = current.right;
        }
        return list;
    }

14.二叉树的后序遍历

    ArrayList<Integer> postOrder(TreeNode root){
        ArrayList<Integer> list = new ArrayList<Integer>();
        if(root == null){
            return list;
        }
        list.addAll(postOrder(root.left));
        list.addAll(postOrder(root.right));
        list.add(root.val);
        return list;
    }

15.前序遍历和后序遍历构造二叉树

    TreeNode buildTreeNode(int[] preorder,int[] inorder){
        if(preorder.length!=inorder.length){
            return null;
        }
        return myBuildTree(inorder,0,inorder.length-1,preorder,0,preorder.length-1);
    }
    TreeNode myBuildTree(int[] inorder,int instart,int inend,int[] preorder,int prestart,int preend){
        if(instart>inend){
            return null;
        }
        TreeNode root = new TreeNode(preorder[prestart]);
        int position = findPosition(inorder,instart,inend,preorder[start]);
        root.left = myBuildTree(inorder,instart,position-1,preorder,prestart+1,prestart+position-instart);
        root.right = myBuildTree(inorder,position+1,inend,preorder,position-inend+preend+1,preend);
        return root;
    }
    int findPosition(int[] arr,int start,int end,int key){
        int i;
        for(i = start;i<=end;i++){
            if(arr[i] == key){
                return i;
            }
        }
        return -1;
    }

16.在二叉树中插入节点

    TreeNode insertNode(TreeNode root,TreeNode node){
        if(root == node){
            return node;
        }
        TreeNode tmp = new TreeNode();
        tmp = root;
        TreeNode last = null;
        while(tmp!=null){
            last = tmp;
            if(tmp.val>node.val){
                tmp = tmp.left;
            }else{
                tmp = tmp.right;
            }
        }
        if(last!=null){
            if(last.val>node.val){
                last.left = node;
            }else{
                last.right = node;
            }
        }
        return root;
    }

17.输入一个二叉树和一个整数，打印出二叉树中节点值的和等于输入整数所有的路径

    void findPath(TreeNode r,int i){
        if(root == null){
            return;
        }
        Stack<Integer> stack = new Stack<Integer>();
        int currentSum = 0;
        findPath(r, i, stack, currentSum);
    }
    void findPath(TreeNode r,int i,Stack<Integer> stack,int currentSum){
        currentSum+=r.val;
        stack.push(r.val);
        if(r.left==null&&r.right==null){
            if(currentSum==i){
                for(int path:stack){
                    System.out.println(path);
                }
            }
        }
        if(r.left!=null){
            findPath(r.left, i, stack, currentSum);
        }
        if(r.right!=null){
            findPath(r.right, i, stack, currentSum);
        }
        stack.pop();
    }

18.二叉树的搜索区间

给定两个值 k1 和 k2（k1 < k2）和一个二叉查找树的根节点。找到树中所有值在 k1 到 k2 范围内的节点。即打印所有x (k1 <= x <= k2) 其中 x 是二叉查找树的中的节点值。返回所有升序的节点值。

    ArrayList<Integer> result;
    ArrayList<Integer> searchRange(TreeNode root,int k1,int k2){
        result = new ArrayList<Integer>();
        searchHelper(root,k1,k2);
        return result;
    }
    void searchHelper(TreeNode root,int k1,int k2){
        if(root == null){
            return;
        }
        if(root.val>k1){
            searchHelper(root.left,k1,k2);
        }
        if(root.val>=k1&&root.val<=k2){
            result.add(root.val);
        }
        if(root.val<k2){
            searchHelper(root.right,k1,k2);
        }
    }

19.二叉树的层次遍历

    ArrayList<ArrayList<Integer>> levelOrder(TreeNode root){
        ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>();
        if(root == null){
            return result;
        }
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offer(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            ArrayList<<Integer> level = new ArrayList<Integer>():
            for(int i = 0;i < size ;i++){
                TreeNode node = queue.poll();
                level.add(node.val);
                if(node.left != null){
                    queue.offer(node.left);
                }
                if(node.right != null){
                    queue.offer(node.right);
                }
            } 
            result.add(Level);
        }
        return result;
    }

20.二叉树内两个节点的最长距离

二叉树中两个节点的最长距离可能有三种情况：
1.左子树的最大深度+右子树的最大深度为二叉树的最长距离
2.左子树中的最长距离即为二叉树的最长距离
3.右子树种的最长距离即为二叉树的最长距离
因此，递归求解即可

private static class Result{  
    int maxDistance;  
    int maxDepth;  
    public Result() {  
    }  
    public Result(int maxDistance, int maxDepth) {  
        this.maxDistance = maxDistance;  
        this.maxDepth = maxDepth;  
    }  
}  
    int getMaxDistance(TreeNode root){
      return getMaxDistanceResult(root).maxDistance;
    }
    Result getMaxDistanceResult(TreeNode root){
        if(root == null){
            Result empty = new Result(0,-1);
            return empty;
        }
        Result lmd = getMaxDistanceResult(root.left);
        Result rmd = getMaxDistanceResult(root.right);
        Result result = new Result();
        result.maxDepth = Math.max(lmd.maxDepth,rmd.maxDepth) + 1;
        result.maxDistance = Math.max(lmd.maxDepth + rmd.maxDepth,Math.max(lmd.maxDistance,rmd.maxDistance));
        return result;
    }

21.不同的二叉树

给出 n，问由 1…n 为节点组成的不同的二叉查找树有多少种？

    int numTrees(int n ){
        int[] counts = new int[n+2];
        counts[0] = 1;
        counts[1] = 1;
        for(int i = 2;i<=n;i++){
            for(int j = 0;j<i;j++){
                counts[i] += counts[j] * counts[i-j-1];
            }
        }
        return counts[n];
    }

22.判断二叉树是否是合法的二叉查找树(BST)

一棵BST定义为：
节点的左子树中的值要严格小于该节点的值。
节点的右子树中的值要严格大于该节点的值。
左右子树也必须是二叉查找树。
一个节点的树也是二叉查找树

    public int lastVal = Integer.MAX_VALUE;
    public boolean firstNode = true;
    public boolean isValidBST(TreeNode root) {
        // write your code here
        if(root==null){
            return true;
        }
        if(!isValidBST(root.left)){
            return false;
        }
        if(!firstNode&&lastVal >= root.val){
            return false;
        }
        firstNode = false;
        lastVal = root.val;
        if (!isValidBST(root.right)) {
            return false;
        }
        return true;
    }

本文转自：https://mp.weixin.qq.com/s?__biz=MzI3ODcxMzQzMw==&mid=2247487539&idx=2&sn=cffd04890bab190dfc90bc3d64b777e7&chksm=eb539505dc241c1300508c94799f49722b5745315f351765f32b98fbfb3bb9c15f1bc3285a04&mpshare=1&scene=1&srcid=#rd

 

chao09_01
关注
专栏目录
面试大总结之二：Java搞定面试中的二叉树题目
11-20 2万+
这是本系列的第二篇，与前一篇 面试大总结之一：Java搞定面试中的链表题目 相比，二叉树的题目可以变化的就更多了。本文还是参考整合重写了《轻松搞定面试中的二叉树题目》和《算法大全（3） 二叉树》两篇大作。本文一个小亮点就是几乎每一道题都用了递归和迭代两种方法写过一遍，因为面试时往往可能会被要求写不擅长的那一种。这一千多行的记录也是我在面试摸索过程中的一个小笔记，备份与此。请大神们轻拍指正。今后
二叉树的常见问题
子夜写字的地方
04-23 1757
据结构中的重要性就不言而喻了，这儿简单记录一下自己碰到的一些关于二叉树的常见操作。当然要明确解决这些问题的“根节点思路”了————递归递归recursion。 二叉树的最大深度与最小深度 最大深度是指二叉树根节点到该树叶子节点的最大路径长度。而最小深度自然就是其到叶子节点的最小路径长度了。 **主要思路：**采用二叉树递归的思想，自底向上，当到达叶子节点时，自然达到了“递归边界”，而叶子节点的子...
二叉树面试题总结（Java）
qq_15720911的博客
08-08 683
本文参考博客：http://www.jianshu.com/p/0190985635eb 先上二叉树的数据结构： class TreeNode{ int val; //左孩子 TreeNode left; //右孩子 TreeNode right; } 二叉树的题目普遍可以用递归和迭代的方式来解 1.求二叉树的最大深度 int maxDea
二叉树算法题
最新发布
mljy.博客
08-30 2052
后，我们了解了二叉树的相关概念和性质，并且实现了顺序结构二叉树——堆和链式结构二叉树，那么在本篇中我们就来试着解决一些二叉树相关的算法题，相信通过这些练习之后你会对二叉树有更深的理解。在之前二叉树的相关章节（
二叉树的常见问题及其解决程序
randyjiawenjie的专栏
09-13 3万+
二叉树的常见问题有如下几个，如果解决好了，就跟链表一样轻松：唯一不一样的是，二叉树是非线性结构。常见的问题如下： 二叉树的问题 1.二叉树三种周游（traversal）方式： 二叉树的问题 1.二叉树三种周游（traversal）方式： 2.怎样从顶部开始逐层打印二叉树结点数据 3.如何判断一棵二叉树是否是平衡二叉树 4.设计一个算法，找出二叉树上任意两个节点的最近共同父结点，复杂度如果
常见的二叉树问题
weixin_48424501的博客
01-03 716
1.判定二叉树是否是完全二叉树 public boolean isCBT(TreeNode root){ if(root==null){ return true; } Queue<TreeNode> queue=new LinkedList<>(); queue.offer(root); boolean flag=false; while(!queue.isEmpty()){ int size=queue.size(); for(int i=0;i<size
二叉树的考研常见问题代码
03-09
根据给定的信息，本文将对二叉树在考研中的常见问题进行详细解析，重点包括递归与非递归两种实现方式，并对特定知识点如节点数量统计、二叉树高度计算等进行深入探讨。 ### 一、二叉树的定义及基本操作 二叉树是一...
关于二叉树遍历求解问题
03-04
二叉树遍历是计算机科学中一种常见的数据结构问题，主要应用于树形数据结构的处理。二叉树是由节点和边构成的树形结构，每个节点最多有两个子节点，分别称为左子节点和右子节点。遍历二叉树是指按照特定顺序访问...
二叉树遍历问题二叉树遍历问题
10-20
二叉树遍历有四种常见的方法：先序遍历、中序遍历、后序遍历和层次遍历。 1. **先序遍历（Preorder Traversal）**： - 访问顺序：根节点 -> 左子树 -> 右子树。 - 在给定的例子中，对于二叉树{0, 1, 2, 3, 4, 5, ...
算法分析之二叉树常见问题
小朱小朱绝不认输的博客
12-15 2495
二叉树的基础知识参考：算法分析之二叉树，二叉树的递归和迭代遍历方法参考：算法分析之二叉树遍历。 文章目录一、二叉树的解题方法1. 递归法2. 迭代法二、leetcode例题讲解二叉树问题1. 二叉树的属性问题101. 对称二叉树104. 二叉树的最大深度111. 二叉树的最小深度222. 完全二叉树的节点个数110. 平衡二叉树257. 二叉树的所有路径100. 相同的树404. 左叶子之和513. 找树左下角的值112. 路径总和2. 二叉树的修改和改造问题226. 翻转二叉树106. 从中序与后序遍历序
二叉树常见问题
qq_43578870的博客
05-24 768
前言 最近在复习数据结构，将一些习题以代码的形式记录，作为笔记。 不使用STL，算法题中假设栈、队列的maxSize足够大。 会持续更新。 求非空二叉树的宽度（最多节点那层的节点数） 利用队列进行层次遍历，同时统计每一层的节点数 int solve(Node *node){ int ans_cnt = 0, cnt = 0; Node *last = node; // 定义last指向当前层的最右边那个节点 Node* q[maxSize]; in
【洛谷 3884】二叉树问题
weixin_30273501的博客
07-22 250
题目描述 如下图所示的一棵二叉树的深度、宽度及结点间距离分别为： 深度：4 宽度：4（同一层最多结点个数） 结点间距离： ⑧→⑥为8 (3×2+2=8) ⑥→⑦为3 （1×2+1=3） 注：结点间距离的定义：由结点向根方向（上行方向）时的边数×2， 与由根向叶结点方向（下行方向）时的边数之和。 输入输出格式 输入格式： 输入文件第一行为一个整数n(1≤n≤10...
二叉树
热门推荐
Richard_Cai
09-19 5万+
二叉树的优势       在实际使用时会根据链表和有序数组等数据结构的不同优势进行选择。有序数组的优势在于二分查找，链表的优势在于数据项的插入和数据项的删除。但是在有序数组中插入数据就会很慢，同样在链表中查找数据项效率就很低。综合以上情况，二叉树可以利用链表和有序数组的优势，同时可以合并有序数组和链表的优势，二叉树也是一种常用的数据结构。二叉树的构成      二叉树由节点（node）和边组成。节点
二叉树问题
Uletay
07-22 263
1.构建二叉树 #include<iostream> #include<cmath> #include<string> #include<cstring> using namespace std; struct BTNode{ char data;//结点值 BTNode *lchild,*rchild;//左右孩子结点 }; //构造二...
Go语言实战：面试常见二叉树问题及代码实现
在IT面试中，二叉树是一个常见的数据结构话题，因为其在算法设计、数据存储和搜索等方面具有广泛应用。本文档主要关注如何用Go语言实现二叉树的基础概念和关键操作。首先，我们来看一下二叉树的定义。 **树的定义**...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值