二叉树基础问题

ZJHFOREVERZJ

已于 2022-08-05 16:08:35 修改

阅读量702

点赞数 2

分类专栏： java 数据结构文章标签： leetcode java 数据结构

于 2021-12-04 16:02:33 首次发布

本文链接：https://blog.csdn.net/weixin_51970219/article/details/121715099

版权

java 同时被 2 个专栏收录

16 篇文章 1 订阅

订阅专栏

数据结构

8 篇文章 0 订阅

订阅专栏

二叉树基础问题

1.相同的树
2.对称二叉树
3.二叉树的层序遍历
4.平衡二叉树
5.另一颗树的子树
6.二叉树前序遍历
7.二叉树中序遍历
8.二叉树后序遍历
9.求二叉树高度
10.判断是否是完全二叉树

1.相同的树

1.相同的树
在这里插入图片描述

(1)代码实现：
TreeNode.java:

package bin_tree.leetcode;
public class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(){
    }
    TreeNode(int val){
        this.val=val;
    }
    TreeNode(int val, TreeNode left, TreeNode right) {
        this.val = val;
        this.left = left;
        this.right = right;
    }
}

package bin_tree.leetcode;

public class Num100 {
    //传入两颗树的根节点p和q,就能判断他两是否相同(结构一样，值也一样)
    public boolean isSameTree(TreeNode p,TreeNode q){
        //都是空树
        if(p==null && q==null){
            return true;
        }
        //p和q有一个为空，另一个不为空
//        if(p!= null && q==null){
//            return false;
//        }
//        if(p==null && q!=null){
//            return false;
//        }

        if(p==null || q==null){
            return false;
        }
        //p和q都不为空
        if(p.val != q.val){
            return false;
        }
        return isSameTree(p.left,q.left) && isSameTree(p.right,q.right);
    }
}

(2)运行截图：
在这里插入图片描述

2.对称二叉树

2.对称二叉树
在这里插入图片描述
解法一：
(1)代码实现：

package bin_tree.leetcode;

//对称二叉树
public class Num101 {
    public boolean isSymmetric(TreeNode root){
        if(root==null){
            return true;
        }
        //root.left和root.right是否互为镜像
        return isMirror(root.left,root.right);
    }

    //判断传入的两颗树是否互为镜像关系
    private boolean isMirror(TreeNode left,TreeNode right){
        if(left==null && right==null){
            return true;
        }
        if(left==null || right==null){
            return false;
        }
        if(left.val !=right.val){
            return false;
        }
        //判断left.left和right.right是否相同
        //判断left.right和right.left是否相同
        return isMirror(left.left,right.right) && isMirror(left.right,right.left);
    }
}

(2)运行截图：
在这里插入图片描述
解法二：
(1)代码实现：

import java.util.Queue;
import java.util.LinkedList;

public class Num101{
    private boolean isMirror(TreeNode left,TreeNode right){
        if(left == null && right ==null ){
            return true;
        }
        if(left==null || right ==null){
            return false;
        }
        if(left.val != right.val){
            return false;
        }
        //判断left.left和right.right是否相同
//        //判断left.right和right.left是否相同
         return isMirror(left.left,right.right) && isMirror(left.right,right.left);
    }
    //队列实现
    public boolean isSymmetric(TreeNode root){
        if(root==null ||(root.left==null && root.right==null)){
            return true;
        }
        //使用队列存储，每一层需要判断对称对节点
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root.left);
        queue.offer(root.right);
        while(! queue.isEmpty()){
            //每次取出一组元素(左树和右树的根)
            TreeNode left=queue.poll();
            TreeNode right=queue.poll();
            //判空
            if(left==null && right==null){
                continue;
            }
            if(left==null || right==null){
                return false;
            }
            if(left.val!=right.val){
                return false;
            }
            // 当前左右树的根节点判断完毕，将left.left和right.right入队
            // 将left.right和right.left入队
            queue.offer(left.left);
            queue.offer(right.right);

            queue.offer(left.right);
            queue.offer(right.left);
        }
        return true;
    }
}

(2)运行截图：
在这里插入图片描述

3.二叉树的层序遍历

3.二叉树的层序遍历
在这里插入图片描述

(1)代码实现：

package bin_tree.leetcode;

import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

//层序遍历
public class Num102 {
    public List<List<Integer>> levelOrder(TreeNode root){
        List<List<Integer>> ret=new LinkedList<>();
        if(root==null){
            return ret;
        }
        //队列
        Queue<TreeNode> queue=new LinkedList<>();
        queue.offer(root);
        //当前队列还有元素-还没访问完
        while(! queue.isEmpty()){
            //队列中保存了每一层的节点
            List<Integer> level=new LinkedList<>();
            //保存了每一层的元素个数
            int size=queue.size();
            for (int i = 0; i <size ; i++) {
                TreeNode cur=queue.poll();
                level.add(cur.val);
                //入队左孩子和右孩子
                if(cur.left !=null){
                    queue.offer(cur.left);
                }
                if(cur.right !=null){
                    queue.offer(cur.right);
                }
            }
            ret.add(level);
        }
        return ret;
    }
}

(2)运行截图：
在这里插入图片描述

4.平衡二叉树

4.平衡二叉树
在这里插入图片描述

(1)代码实现：

package bin_tree.leetcode;

import java.util.HashMap;
import java.util.Map;

//判断平衡树
public class Num110 {
//使用Map存储每个出现节点的高度
  Map<TreeNode,Integer> map=new HashMap<>();
    public boolean isBalanced(TreeNode root){
        //1.空树
        if(root==null){
            return true;
        }
        //2.求当前的左右子树高度
        int leftHeight=0;
        int rightHeight=0;
        if(map.containsKey(root.left)){
            //root.left节点的高度已经算过了
            leftHeight=map.get(root.left);
        }else{
            //通过递归函数计算该节点的高度并存入map中
            leftHeight=height(root.left);
            map.put(root.left,leftHeight);
        }
        if (map.containsKey(root.right)){
            //root.right节点的高度已经算过了
            rightHeight=map.get(root.right);
        }else{
            //通过递归函数计算节点的高度并存入map中
            rightHeight=height(root.right);
            map.put(root.right,rightHeight);
        }
        int heightAbs=Math.abs(leftHeight-rightHeight);
        if(heightAbs>1){
            return false;
        }
        //递归去看左树和右树是否是平衡树
        return isBalanced(root.right) && isBalanced(root.right);
    }
    //求树的高度问题
    public int height(TreeNode root){
        if(root==null){
            return 0;
        }
        return 1+Math.max(height(root.left),height(root.right));
    }
}

(2)运行截图：
在这里插入图片描述

5.另一颗树的子树

5.另一颗树的子树
在这里插入图片描述

(1)代码实现：

package bin_tree.leetcode;

//另一颗树的子树
public class Num572 {
    public boolean isSubtree(TreeNode root,TreeNode subRoot){
        //1.边界
        if(root==null && subRoot==null){
            return true;
        }
        if(root==null || subRoot==null){
            return false;
        }
        //r和s相同
        if(issameTree(root,subRoot)){
            return true;
        }
        //r.left是否包含s || r.right是否包含s
        return isSubtree(root.left,subRoot) || isSubtree(root.right,subRoot);

    }
    public boolean issameTree(TreeNode p,TreeNode q){
        //都是空树
        if(p==null && q==null){
            return true;
        }
        //p和q一个为空，另一个不为空
        if(p==null || q==null){
            return false;
        }
        //p和q都不为空
        if(p.val != q.val){
            return false;
        }
        return issameTree(p.left,q.left) && issameTree(p.right,q.right);
    }
}

(2)运行截图：
在这里插入图片描述

6.二叉树前序遍历

在这里插入图片描述
二叉树的前中后序遍历借助栈结构
根节点啥时候能真正遍历输出？
前序遍历：第一次访问根节点就可以输出
中序遍历：第二次访问根节点(走完左树)
后序遍历：第三次访问根节点(走完左右子树)
节点入栈和出栈：入栈当第一次走到这个节点入栈
出栈：当真正访问这个节点。
(1)解法一递归法：

package bin_tree.leetcode;

import java.util.LinkedList;
import java.util.List;

public class Num144 {
    List<Integer> ret=new LinkedList<>();
    //递归解法
    public List<Integer> preorderTraversal(TreeNode root){
        if(root==null){
            return ret;
        }
        //根左右
        ret.add(root.val);
        preorderTraversal(root.left);
        preorderTraversal(root.right);
        return ret;
    }
}

在这里插入图片描述
(2)解法二：迭代法：

public class Num144{
    List<Integer> ret=new LinkedList<>();
    public List<Integer> preorderTraversal(TreeNode root){
        if(root==null){
            return ret;
        }
        Stack<TreeNode> stack=new Stack<>();
        stack.push(root);
        while(!stack.isEmpty()){
            TreeNode node=stack.pop();
            ret.add(node.val);
            //先入右孩子
            if(node.right != null){
                stack.push(node.right);
            }
            if (node.left != null){
                stack.push(node.left);
            }
        }
        return ret;
    }
}

在这里插入图片描述

7.二叉树中序遍历

7.二叉树中序遍历
在这里插入图片描述

(1)代码实现：

package bin_tree.leetcode;

import java.util.LinkedList;
import java.util.List;
import java.util.Stack;

//二叉树中序遍历
public class Num94 {
    //基于栈的迭代
    public List<Integer> inorderTraversal(TreeNode root){
        List<Integer> ret=new LinkedList<>();
        if(root==null){
            return ret;
        }
        Stack<TreeNode> stack=new Stack<>() ;
        TreeNode cur=root;
        while(cur != null ||(!stack.isEmpty())){
            //一路向左走一直走到最左侧的最后一个节点
            while(cur!=null){
                stack.push(cur);
                cur=cur.left;
            }
            //当前左树已经全部入栈
            cur=stack.pop();
            //此时访问根节点
            ret.add(cur.val);
            //继续访问右子树
            cur=cur.right;
        }
        return ret;
    }
}

(2)运行截图：
在这里插入图片描述

8.二叉树后序遍历

8.二叉树后序遍历
在这里插入图片描述

(1)代码实现：

package bin_tree.leetcode;

import java.util.LinkedList;
import java.util.List;
import java.util.Stack;

//二叉树后续遍历
public class Num145 {
    public List<Integer> postorderTraversal(TreeNode root){
        List<Integer> ret=new LinkedList<>();
        if(root==null){
            return ret;
        }
        Stack<TreeNode> stack=new Stack<>();
        //cur表示当前需要判断的节点
        TreeNode cur=root;
        //prev表示最近一次完全结束遍历的节点
         TreeNode prev=null;
        while(cur !=null || !(stack.isEmpty())){
            //一路向左做到头
            while(cur != null){
                stack.push(cur);
                cur=cur.left;
            }
            //左树已经全部结束
            cur=stack.pop();
            //此时cur是第二次访问，不能直接遍历，需要判断右树是否为空或者是否遍历结束
            if(cur.right == null ||prev==cur.right){
                //右树已经结束遍历，第三次访问cur
                ret.add(cur.val);
                //此时cur已经全部访问完毕，prev更新为当前cur节点
                prev=cur;
                cur=null;
            }else{
                stack.push(cur);
                cur=cur.right;
            }
        }
        return ret;
    }
}

(2)运行截图：

在这里插入图片描述

9.求二叉树高度

在这里插入图片描述

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

在这里插入图片描述

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

1.完全二叉树就是满二叉树右下角缺了一块，完全二叉树的节点编号必须和满二叉树一一对应。
2.对于完全二叉树一共有三种节点：
(1)度为2的节点有N个。
(2)度为1的节点最多有一个(恰好就是只有左树时的那个节点)。
(3)度为0的节点有N个。
在这里插入图片描述

package bin_tree.leetcode;

import java.util.LinkedList;
import java.util.Queue;

/**
 * 判断一颗树是否是完全二叉树
 */
public class IsCompleteTree {
    public boolean isCompleteTree(TreeNode root){
        if(root == null){
            return true;
        }
        //层序遍历判断二叉树
        Queue<TreeNode> queue=new LinkedList<>();
        queue.offer(root);
        //引入标志位来区分当前遍历过程处在第一还是第二阶段
        boolean isSecondeStep=false;
        while(!queue.isEmpty()){
            TreeNode cur=queue.poll();
            if(!isSecondeStep){
                //此时处在第一阶段
                if(cur.left !=null && cur.right !=null){
                    //当前左右子树全部存在
                    queue.offer(cur.left);
                    queue.offer(cur.right);
                }else if(cur.left==null && cur.right != null){
                    return false;
                }else if(cur.left!=null ){
                    //只有左树没有右树，此时cur是碰到的第一个只有左树的节点
                    //切换状态
                    isSecondeStep=true;
                    queue.offer(cur.left);
                }else{
                    //此时左树和右树全部为空，cur是第一个碰到的叶子节点
                    isSecondeStep=true;
                }
            }else{
                //此时处在第二阶段,第二个阶段中的所有节点不可能有子树
                if(cur.left != null || cur.right != null){
                    return false;
                }
            }
        }
        return true;
    }
}

ZJHFOREVERZJ

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
二叉树基础问题

二叉树练习1.相同的树2.对称二叉树3.二叉树的层序遍历4.平衡二叉树5.另一颗树的子树1.相同的树1.相同的树(1)代码实现：TreeNode.java:package bin_tree.leetcode;public class TreeNode { int val; TreeNode left; TreeNode right; TreeNode(){ } TreeNode(int val){ this.val=val;
复制链接

扫一扫