Java--二叉树代码实现

最新推荐文章于 2024-06-10 09:15:00 发布

小白不想秃头

最新推荐文章于 2024-06-10 09:15:00 发布

阅读量1.6k

点赞数 1

文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_73000974/article/details/131802992

版权

本文详细介绍了二叉树的几种主要操作，包括前序、中序和后序遍历，计算节点个数，叶子节点个数，第K层节点个数，树的高度，查找特定值的节点，判断是否为完全二叉树以及层序遍历。所有操作均使用递归思想实现。

摘要由CSDN通过智能技术生成

二叉树

ps:这里只讲解二叉树的主要方法的实现过程，内容比较进阶，不讲解二叉树的基本知识！！！！

基础代码–构建一个二叉树

    static class TreeNode
    {
        public char value;
        public TreeNode left;
        public TreeNode right;
        public TreeNode(char value)
        {
            this.value=value;
        }
    }
    public TreeNode newTree()
    {
        TreeNode A = new TreeNode('A');
        TreeNode B = new TreeNode('B');
        TreeNode C = new TreeNode('C');
        TreeNode D = new TreeNode('D');
        TreeNode E = new TreeNode('E');
        TreeNode F = new TreeNode('F');
        TreeNode G = new TreeNode('G');
        TreeNode H = new TreeNode('H');
        A.left = B;
        A.right = C;
        B.left = D;
        B.right = E;
        C.left = F;
        C.right = G;
        E.right = H;
        return A;
    }

由代码可知，我们创建的二叉树的结构如下图
在这里插入图片描述
以下代码基本都用到了递归思想

1.二叉树的前序遍历

1.1 思想

前序遍历的核心思想就是根左右
先打印根，再打印左，再打印右
如果我们的树是一颗很庞大的树，可以把大问题小化，比如上面那个树有8个结点，我们可以只看前三个，也就是
在这里插入图片描述
打印出来A之后，递归打印左树B，然后再打印右树C
现在结合代码来看
看不清的可以放大来看

这个是三个结点的思想画法，多个结点也这样画，可以自己动手画一下

1.2 代码

	public void prevOrder(TreeNode root)
    {
        if(root==null)
        {
            return;
        }
        System.out.print(root.value+" ");
        prevOrder(root.left);
        prevOrder(root.right);
    }

2.二叉树的中序遍历

2.1 思想

画法同前序遍历

2.2 代码

    public void inOrder(TreeNode root)
    {
        if(root==null)
        {
            return;
        }
        inOrder(root.left);
        System.out.print(root.value+" ");
        inOrder(root.right);
    }

3.二叉树的后续遍历

3.1 思想

画法同前序遍历和中序遍历

3.2 代码

    public void postOrder(TreeNode root)
    {
        if(root==null)
        {
            return;
        }
        postOrder(root.left);
        postOrder(root.right);
        System.out.print(root.value+" ");
    }

4.二叉树的结点个数

4.1 思想

还是拿三个结点举例，你可以换成两个结点，递归的思想就是把大的换成一个个小的，比如那个从A到H的树，往大了说就是包括根节点A，以及A的左树和A的右树，这个三个结点的也是根节点A和A的左树B和A的右树C
计算二叉树的节点个数可以想成根结点+左树的结点个数+右树的结点个数
下面结合代码来看一下
在这里插入图片描述

4.2 代码

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

5.二叉树的叶子结点个数

5.1 思想

核心思想：
1.左树的叶子结点+右树的叶子结点
2.一个结点的左右结点都为空的时候，返回1
下面结合代码图来看
在这里插入图片描述

5.2 代码

    public int levelSize(TreeNode root)
    {
        if(root==null)
        {
            return 0;
        }

        if(root.left==null&&root.right==null)
        {
            return 1;
        }
        return levelSize(root.left)+levelSize(root.right);
    }

6.二叉树的第K层结点个数

6.1 思想

核心思想
1.左树第K层结点个数+右树第K层结点个数
2.k=1时返回1
下面结合代码
在这里插入图片描述

6.2 代码

    public int getKLevelNodeCount(TreeNode root,int k)
    {
        if(root==null)
        {
            return 0;
        }
        if(k==1)
        {
            return 1;
        }
        return getKLevelNodeCount(root.left,k-1)+getKLevelNodeCount(root.right,k-1);
    }

7.二叉树的高度

7.1 思想

核心思想
1.根结点的左树和右树哪个高，就返回哪个树的高度Height
2.返回的Height+1，这个1是把根节点的高度算上了
结合代码图看
在这里插入图片描述

7.2 代码

    public int getHeight(TreeNode root)
    {
        if(root==null)
        {
            return 0;
        }
        int leftH=getHeight(root.left);
        int rightH=getHeight(root.right);

        return (leftH>=rightH?leftH:rightH)+1;
    }

8.寻找值为val的结点

8.1 思想

1.如果根节点的val跟要找的val相等，返回根节点
2.如果根节点的val跟要找的val不相等，从左树找，左树有就返回左树对应的结点
3.左树没有，从右树找，右树右返回右树对应的结点
4.右树也没有，就返回null
下面结合代码图看
在这里插入图片描述

8.2 代码

    TreeNode find(TreeNode root, char val)
    {
        if(root==null)
        {
            return null;
        }
        if(root.value==val)
        {
            return root;
        }
        TreeNode leftNode=find(root.left,val);
        if(leftNode!=null)
        {
            return leftNode;
        }
        TreeNode rightNode=find(root.right,val);
        if(rightNode!=null)
        {
            return rightNode;
        }
        return null;
    }

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

9.1思想

核心思想
1.用队列实现
2.如果头结点不是空，入队
3.出队，用cur代替这个出队的，出队的结点如果不是空，将这个结点的左右结点都入
4.当cur为null时候，停下
5.这时候判断队列是否都是空，挨个出队，如果有一个不是空就不是完全二叉树
下面看代码图
在这里插入图片描述

在这里插入图片描述

9.2 代码

	boolean isCompleteTree(TreeNode root)
    {
        Queue<TreeNode> queue = new LinkedList<>();
        if(root != null) {
            queue.offer(root);
        }
        while (!queue.isEmpty()) {
            TreeNode cur = queue.poll();
            if(cur != null) {
                queue.offer(cur.left);
                queue.offer(cur.right);
            }else {
                break;
            }
        }
        while (!queue.isEmpty()) {
            TreeNode cur = queue.poll();
            if(cur != null) {
                return false;
            }
        }
        return true;
    }

10.二叉树的层序遍历

10.1 思想

核心思想
1.跟判断是不是完全二叉树差不多，也是用队列的思想
2.如果头结点不是空，入队
3.出队，用cur代替这个出队的，先打印cur的value，然后判断出队的结点的左结点是不是空，如果不是空，入左结点
4.再判断出队的结点的右节点是不是空，不是空的话就入队
层序遍历的思想比上面的判断是否是完全二叉树要简单，掌握了判断是否是完全二叉树就很容易掌握层序遍历，因为思想差不多，就不画代码图了

10.2 代码

 	public void levelOrder(TreeNode root)
    {
        Queue<TreeNode> queue=new LinkedList<>();
        if(root!=null)
        {
            queue.offer(root);
        }
        while(!queue.isEmpty())
        {
            TreeNode cur=queue.poll();
            System.out.print(cur.value+" ");
            if(cur.left!=null)
            {
                queue.offer(cur.left);
            }
            if(cur.right!=null)
            {
                queue.offer(cur.right);
            }
        }
    }

全部代码

public class BinaryTree
{
    static class TreeNode
    {
        public char value;
        public TreeNode left;
        public TreeNode right;
        public TreeNode(char value)
        {
            this.value=value;
        }
    }
    public TreeNode newTree()
    {
        TreeNode A = new TreeNode('A');
        TreeNode B = new TreeNode('B');
        TreeNode C = new TreeNode('C');
        TreeNode D = new TreeNode('D');
        TreeNode E = new TreeNode('E');
        TreeNode F = new TreeNode('F');
        TreeNode G = new TreeNode('G');
        TreeNode H = new TreeNode('H');
        A.left = B;
        A.right = C;
        B.left = D;
        B.right = E;
        C.left = F;
        C.right = G;
        E.right = H;
        return A;
    }
    public void prevOrder(TreeNode root)
    {
        if(root==null)
        {
            return;
        }
        System.out.print(root.value+" ");
        prevOrder(root.left);
        prevOrder(root.right);
    }
    public void inOrder(TreeNode root)
    {
        if(root==null)
        {
            return;
        }
        inOrder(root.left);
        System.out.print(root.value+" ");
        inOrder(root.right);
    }
    public void postOrder(TreeNode root)
    {
        if(root==null)
        {
            return;
        }
        postOrder(root.left);
        postOrder(root.right);
        System.out.print(root.value+" ");
    }
    public int size(TreeNode root)
    {
        if(root==null)
        {
            return 0;
        }
        return 1+size(root.left)+size(root.right);
    }
    public int levelSize(TreeNode root)
    {
        if(root==null)
        {
            return 0;
        }

        if(root.left==null&&root.right==null)
        {
            return 1;
        }
        return levelSize(root.left)+levelSize(root.right);
    }
    // 获取第K层节点的个数
    public int getKLevelNodeCount(TreeNode root,int k)
    {
        if(root==null)
        {
            return 0;
        }
        if(k==1)
        {
            return 1;
        }
        return getKLevelNodeCount(root.left,k-1)+getKLevelNodeCount(root.right,k-1);
    }
    // 获取二叉树的高度
    public int getHeight(TreeNode root)
    {
        if(root==null)
        {
            return 0;
        }
        int leftH=getHeight(root.left);
        int rightH=getHeight(root.right);

        return (leftH>=rightH?leftH:rightH)+1;
    }
    // 检测值为value的元素是否存在
    TreeNode find(TreeNode root, char val)
    {
        if(root==null)
        {
            return null;
        }
        if(root.value==val)
        {
            return root;
        }
        TreeNode leftNode=find(root.left,val);
        if(leftNode!=null)
        {
            return leftNode;
        }
        TreeNode rightNode=find(root.right,val);
        if(rightNode!=null)
        {
            return rightNode;
        }
        return null;
    }
    //层序遍历
    public void levelOrder(TreeNode root)
    {
        Queue<TreeNode> queue=new LinkedList<>();
        if(root!=null)
        {
            queue.offer(root);
        }
        while(!queue.isEmpty())
        {
            TreeNode cur=queue.poll();
            System.out.print(cur.value+" ");
            if(cur.left!=null)
            {
                queue.offer(cur.left);
            }
            if(cur.right!=null)
            {
                queue.offer(cur.right);
            }
        }
    }
}