二叉树的Java实现

最新推荐文章于 2022-10-21 16:25:09 发布
原创 最新推荐文章于 2022-10-21 16:25:09 发布 · 322 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细介绍了如何用Java实现二叉树的基本功能，包括节点数量、空树判断、高度计算、递归与非递归遍历（先序、中序、后序），以及层序遍历。通过栈和队列的数据结构巧妙地实现了非递归遍历算法。

Java实现以下方法：

  1. 树的节点数量：size
  2. 判断是否为空：isEmpty
  3. 树的高度：getHeight
  4. 对树进行递归先序遍历：preTraversal
  5. 对树进行递归中序遍历：middleTraversal
  6. 对树进行递归后序遍历：postTraversal
  7. 借助队列实现层序遍历：orderByQueue
  8. 借助栈实现非递归先序遍历：preTraByStack
  9. 借助栈实现非递归中序遍历：inOrderByStack
  10. 借助栈实现非递归后序遍历：postTraByStack

ps：

  • 关于树：
  • 关于栈：
  • 关于队列基本知识和循环队列：
  • 关于双向队列：

 

树的interface：

package com.yao;

/**
 * 定义二叉树可以实现的基本功能
 *
 */
public interface Tree {
    public int size();
    public boolean isEmpty();
    public int getHeight();
    public void preTraversal();
    public void middleTraversal();
    public void postTraversal();
    public void orderByQueue(); //借助队列实现层次遍历
    public void preTraByStack(); //借助栈实现非递归遍历二叉树,使用先序进行遍历
    void inOrderByStack();  //借助栈实现非递归遍历二叉树,使用中序进行遍历
    void postTraByStack();  //借助栈实现非递归遍历二叉树,使用后序进行遍历
}

 

定义二叉树结点

数据+左子结点+右子结点+构造方法

package com.yao;

import lombok.AllArgsConstructor;
import lombok.Data;

//二叉树的基本结点
@Data
@AllArgsConstructor
public  class Node {
    Object data;
    Node leftChild;
    Node rightChild;
}

 

定义一颗二叉树

存储方式：链表

PS：顺序表（数组）存储树，对于不增删，接近完全二叉树的二叉树，也是可行的

树的节点数量：size

    @Override
    public int size() {
        return this.size(root);
    }

    private int size(Node node) {
        if(node==null){
            return 0;
        }else{
            int le = size(node.leftChild);
            int ri = size(node.rightChild);
            return ri+le+1;
        }
    }

判断是否为空：isEmpty

   @Override
    public boolean isEmpty() {
        return root == null;
    }

树的高度：getHeight

 @Override
    public int getHeight() {
        return this.getHeight(root);
    }

    private int getHeight(Node node) {
        if(node == null){
            return 0;
        }else{
            int ai = this.getHeight(node.leftChild);
            int bi = this.getHeight(node.rightChild);
            return ai>bi?ai+1:bi+1;
        }
    }

或者

 

 

对树进行递归先序遍历：preTraversal

  @Override
    public void preTraversal() {
        //进一步封装完善方法
        //首先必须考虑代码健壮性
        if(root !=null){
            System.out.println("先序递归遍历：");
            pre(root);
            System.out.println();
        }else{
            System.out.println("此二叉树为空");
        }
    }

    private void pre(Node node) {
        if(node!=null){
            //输出二叉树根节点
            System.out.print(node.data+"  ");
            //继续相应地遍历左子树和右子树
            this.pre(node.leftChild);
            this.pre(node.rightChild);
        }
    }

先、中、后序栈遍历的逻辑很关键，仔细分析这张图

规律：

  • 按照⊗走就是先序遍历
  • 按照☆走就是中序遍历 
  • 按照∆走就是后序遍历
  • 根节点A的左中右，分别是⊗☆∆
  • 所有节点逆时针都是⊗☆∆的顺序
  • 先序：第一次碰到结点就输出：⊗
  • 中序：必须是第二次碰到结点输出：☆之前必须要⊗
  • 后序：必须是第三次碰到结点才输出：∆之前必须要有⊗☆

栈的逻辑

  1. 沿着左子树深入
    1. 先序遍历：先push，然后马上pop
    2. 中序遍历：push
    3. 后序遍历：push
  2. 当左分支分不下去
    1. 先序遍历：左分支深入不下去，则返回
    2. 中序遍历：pop该结点，然后从该结点右子树深入
    3. 后序遍历：继续push，往右分支深入

借助栈实现非递归先序遍历：preTraByStack

    @Override
    public void preTraByStack() {
        System.out.println("先序栈遍历：");
        Deque<Node> de = new LinkedList<>();//新建栈

        Node node = root;
        de.push(node);
        while(node != null&&de.size()>0){
            node = de.pop();
            System.out.print(node.data+"  ");
            if(node.leftChild!=null && node.rightChild!=null){
                de.push(node.rightChild);
                de.push(node.leftChild);
            }else if(node.leftChild!=null &&node.rightChild == null){
                de.push(node.leftChild);
            }else if(node.leftChild ==null &&node.rightChild != null){
                de.push(node.rightChild);
            }
        }
        System.out.println();
    }

借助栈实现非递归中序遍历：inOrderByStack

    @Override
    public void inOrderByStack() {
        System.out.println("中序栈遍历:");
        // 创建栈,和先序遍历类似，直接入栈直到没有最左左子树可以入栈
        Deque<Node> stack = new LinkedList<Node>();
        Node node = root;
        //添加暂时完毕，开始pop元素
        while(node!=null || stack.size()>0 ){
            while(node!=null){
                stack.push(node);
                node = node.leftChild;
            }
            //一边pop并且一边进行判断，右结点不会null的，右子树，继续按照添加方法，将最左结点全部添加进去
            if(stack.size()>0){
                Node pop = stack.pop();
                System.out.print(pop.data+"  ");
                if(pop.rightChild!=null){
                    node = pop.rightChild;
                }
            }
        }
        System.out.println();
    }

借助栈实现非递归后序遍历：postTraByStack

 @Override
    public void postTraByStack() {
        System.out.println("后序非递归遍历，借助栈");
        //新建栈，先进后出,将根结点入栈,双端队列
        Deque<Node> stack = new LinkedList<>();
        //新建一个list，记录结点的状态是否已经被访问过
        ArrayList<Node> list = new ArrayList<>();
//		stack.push(root);
        Node proot;
        Node node = root;
        int flag;
        //首先检查完树的左子树，再右子树，最后将根节点输出
        while(node != null  || stack.size()>0){
            //将最左子树添加完毕
            while(node != null){
                stack.push(node);
                node = node.leftChild;
            }
            //和中序遍历相似，为先输出左结点，但是做结点输出完毕之后，不能直接将根结点弹出，而是必须先将右结点弹出，
            //最后再将根结点弹出来，就会牵扯到一个根结点的访问状态的问题，是否已经被遍历过了
            //利用一个list集合记录已将被遍历过的根结点，防止产生死循环
            if(stack.size()> 0 ){
                Node peek = stack.peek();
                if(peek.rightChild!=null){
                    boolean con = list.contains(peek);
                    if(con ==true){
                        Node pop = stack.pop();
                        System.out.print(pop.data+"  ");
                    }else{
                        list.add(peek);
                        node = peek.rightChild;
                    }
                }else{
                    Node pop = stack.pop();
                    System.out.print(pop.data+"  ");
                }
            }
        }
    }

借助队列实现层序遍历：orderByQueue

package com.yao;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.ArrayList;
import java.util.Deque;
import java.util.LinkedList;
import java.util.Queue;

/**
 * 采用双链表法实现二叉树
 */
@Data
@AllArgsConstructor
@NoArgsConstructor

public class LinkedBinaryTree  implements Tree{
    //为此棵数，创建根节点
    private Node root;

    @Override
    public int size() {
        return this.size(root);
    }

    private int size(Node node) {
        if(node==null){
            return 0;
        }else{
            int le = size(node.leftChild);
            int ri = size(node.rightChild);
            return ri+le+1;
        }
    }

    @Override
    public boolean isEmpty() {
        return root == null;
    }

    @Override
    public int getHeight() {
        return this.getHeight(root);
    }

    private int getHeight(Node node) {
        if(node == null){
            return 0;
        }else{
            int ai = this.getHeight(node.leftChild);
            int bi = this.getHeight(node.rightChild);
            return ai>bi?ai+1:bi+1;
        }
    }

    @Override
    public void preTraversal() {
        //进一步封装完善方法
        //首先必须考虑代码健壮性
        if(root !=null){
            System.out.println("先序递归遍历：");
            pre(root);
            System.out.println();
        }else{
            System.out.println("此二叉树为空");
        }
    }

    private void pre(Node node) {
        if(node!=null){
            //输出二叉树根节点
            System.out.print(node.data+"  ");
            //继续相应地遍历左子树和右子树
            this.pre(node.leftChild);
            this.pre(node.rightChild);
        }
    }

    @Override
    public void middleTraversal() {
        if(root !=null){
            System.out.println("中序递归遍历：");
            middle(root);
            System.out.println();
        }else{
            System.out.println("此二叉树为空");
        }
    }

    private void middle(Node node) {
        if(node!=null){
            //输出二叉树根节点
            this.middle(node.leftChild);
            System.out.print(node.data+"  ");
            this.middle(node.rightChild);
        }
    }

    @Override
    public void postTraversal() {
        if(root !=null){
            System.out.println("后序递归遍历：");
            pos(root);
            System.out.println();
        }else{
            System.out.println("此二叉树为空");
        }
    }

    private void pos(Node node) {
        if(node!=null){
            //输出二叉树根节点
            this.pos(node.leftChild);
            this.pos(node.rightChild);
            System.out.print(node.data+"  ");
        }
    }

    @Override
    public void orderByQueue() {
        //新建一个队列，存放二叉树结点
        Queue qu = new LinkedList();
        Node node = root;
        qu.add(node);
        //遍历输出每一层，同时将下一层的结点加入到对列中,队列现有的个数，就是每层节点的个数
        while(qu.size()!=0){
            for(int i = 0;i<qu.size();i++)
            {
                Node po = (Node) qu.poll();
                System.out.print(po.data+"  ");
                if(po.leftChild != null)
                    qu.add(po.leftChild);
                if(po.rightChild != null)
                    qu.add(po.rightChild);
            }
        }
        System.out.println();
    }

    @Override
    public void preTraByStack() {
        System.out.println("先序栈遍历：");
        Deque<Node> de = new LinkedList<>();//新建栈

        Node node = root;
        de.push(node);
        while(node != null&&de.size()>0){
            node = de.pop();
            System.out.print(node.data+"  ");
            if(node.leftChild!=null && node.rightChild!=null){
                de.push(node.rightChild);
                de.push(node.leftChild);
            }else if(node.leftChild!=null &&node.rightChild == null){
                de.push(node.leftChild);
            }else if(node.leftChild ==null &&node.rightChild != null){
                de.push(node.rightChild);
            }
        }
        System.out.println();
    }

    public void postTree(){
        System.out.println("借助外部方法实现后序遍历：");
        Deque<Node> stack =new LinkedList<Node>();
        Node node = root;
        Node proot;//标记栈顶元素前一个被访问的元素
        int flag;//root的左孩子未被访问；
        if(node!=null){
            do{
                while(node!=null){//将root所有左孩子全部入栈
                    stack.push(root);
                    node=node.leftChild;
                }

                //执行到此处，栈顶元素没有左孩子或者左子树已经被访问过；
                proot=null;//标记栈顶元素前一个被访问的元素，或者此时为最左下边，该元素前一个被访问的元素肯定为空。
                flag=1;//root的左孩子已经被访问；或者root为null

                while(!stack.isEmpty() && flag==1){
                    node=stack.peek();       //取到栈顶元素，但是不出栈；
                    if(node.rightChild==proot){
                        node=stack.pop();
                        System.out.print(node.data+"  ");
                        proot=node;
                    }else{
                        node=node.rightChild;
                        flag=0;//root左边孩子未被访问；
                    }
                }
            }while(!stack.isEmpty());
        }
    }

    @Override
    public void postTraByStack() {
        System.out.println("后序非递归遍历，借助栈");
        //新建栈，先进后出,将根结点入栈,双端队列
        Deque<Node> stack = new LinkedList<>();
        //新建一个list，记录结点的状态是否已经被访问过
        ArrayList<Node> list = new ArrayList<>();
//		stack.push(root);
        Node proot;
        Node node = root;
        int flag;
        //首先检查完树的左子树，再右子树，最后将根节点输出
        while(node != null  || stack.size()>0){
            //将最左子树添加完毕
            while(node != null){
                stack.push(node);
                node = node.leftChild;
            }
            //和中序遍历相似，为先输出左结点，但是做结点输出完毕之后，不能直接将根结点弹出，而是必须先将右结点弹出，
            //最后再将根结点弹出来，就会牵扯到一个根结点的访问状态的问题，是否已经被遍历过了
            //利用一个list集合记录已将被遍历过的根结点，防止产生死循环
            if(stack.size()> 0 ){
                Node peek = stack.peek();
                if(peek.rightChild!=null){
                    boolean con = list.contains(peek);
                    if(con ==true){
                        Node pop = stack.pop();
                        System.out.print(pop.data+"  ");
                    }else{
                        list.add(peek);
                        node = peek.rightChild;
                    }
                }else{
                    Node pop = stack.pop();
                    System.out.print(pop.data+"  ");
                }
            }
        }
    }

    @Override
    public void inOrderByStack() {
        System.out.println("中序栈遍历:");
        // 创建栈,和先序遍历类似，直接入栈直到没有最左左子树可以入栈
        Deque<Node> stack = new LinkedList<Node>();
        Node node = root;
        //添加暂时完毕，开始pop元素
        while(node!=null || stack.size()>0 ){
            while(node!=null){
                stack.push(node);
                node = node.leftChild;
            }
            //一边pop并且一边进行判断，右结点不会null的，右子树，继续按照添加方法，将最左结点全部添加进去
            if(stack.size()>0){
                Node pop = stack.pop();
                System.out.print(pop.data+"  ");
                if(pop.rightChild!=null){
                    node = pop.rightChild;
                }
            }
        }
        System.out.println();
    }
}

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

https://blog.youkuaiyun.com/eeeemon/article/details/109663628

 

 

Z字型遍历二叉树Java实现
Boush
01-17 902
Z字型遍历二叉树-Java实现
【数据结构 Java 版】二叉树的实现（超多图、超详解）
2401_84048895的博客
04-18 1029
外链图片转存中…(img-MCAzqjVU-1713420634005)][外链图片转存中…(img-DyAJEUlY-1713420634006)][外链图片转存中…(img-iwwwPSeL-1713420634006)]
二叉树的java实现
07-14
二叉树的java实现
java 二叉树实现
10-12
java二叉树实现 （简单实现，入门用） /**创建二叉树*/ public BinaryTree createTree(String treeStr); /**寻找结点*/ public BinaryTree findNode(BinaryTree tree ,char sign); /**找所给结点的左子树*/ public BinaryTree lChildren(BinaryTree node); /**找所给结点的右子树*/ public BinaryTree rChildren(BinaryTree node); /**求二叉树高度*/ public int treeDepth(BinaryTree tree); /**输出树（括号表示法）*/ public void disPlayTree(BinaryTree tree);
二叉树 JAVA 版
06-03
用JAVA事先二叉树的建立与遍历！！！！！！！！！！！
二叉树（Java实现）
热门推荐
JiaXingNashishua的博客
05-22 1万+
声明：本文部分文章取自于 Java中关于二叉树详解_来学习的小张的博客-优快云博客_java 二叉树原理 更多关于二叉树详情可以点击上面链接 一：树形结构 树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点： 有一个特殊的节点，称为根节点，根节点没有前驱节点； 除根节点外，其余节点被分成M(M > 0)个互不相交的集合T1、T2、......、Tm，其中每一个
二叉树（JAVA实现）
weixin_43589025的博客
05-18 378
为什么需要树这种数据结构？ 1、数组存储方式分析： （1）优点：通过下标访问元素，速度快。对于有序数组，还可以使用二分查找提高检索速度。 （2）缺点：如果检索具体某个值，或者插入值（按一定顺序）会整体移动，效率较低 2、链式存储方式的分析： （1）优点：在一定程度上对数组存储方式有优化（如插入一个数值节点，只需要将插入的节点，链接到链表中即可，删除效率也很好） （2）缺点：在进行检索是，效率仍然较低，需要从头开始遍历 3、树存储方式的分析： （1）优点：能提高数据存储效率，读取的效率，比如利用二叉排序树，既
二叉树java实现
08-27
在Java中实现二叉树，我们可以自定义一个类来表示树节点，并通过节点之间的连接来构建整个树形结构。这篇博客主要讨论了如何在Java中实现二叉树的基本操作，包括递归和非递归方式的三种遍历顺序：前序遍历、中序遍历...
数据结构-二叉树Java实现及其遍历算法
最新发布
09-24
在Java中实现二叉树，需要定义一个树节点类（TreeNode），每个节点包含存储数据的字段和指向其子节点的引用。此外，还需要一个二叉树类（BinaryTree），它包含用于操作树的各种方法，例如插入、删除和遍历节点等。 ...
java实现平衡二叉树
qq_45731129的博客
08-31 1117
平衡二叉树也叫平衡二叉搜索树(Self-balancing binary search tree)又被称为AVL树，可以保证查询效率较高。具有以下特点: 它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。平衡二叉树的常用实现方法有红黑树、AVL、替罪羊树、Treap、伸展树等。举例说明, 看看下面哪些AVL树,为什么?平衡二叉搜索树的左右子树，高度差不能大于1，所以前两个满足。...
Java实现二叉树
yw906002599的博客
03-17 431
Java实现二叉树 主要内容： 二叉树的链表表示法， 二叉树的先根、中根和后根三种遍历方法。 二叉树的查找、插入和构建。 二叉查找树BST的查找、插入、删除和构建。 平衡二叉树的查找、插入和构建。 代码完美可以运行，暂时不写基础内容了，直接上代码。 package com.tree.binary_Tree; //递归定义 /* 要不没有根节点 是一颗空树 要不由根结点 左子树 和 右子树构成 且左右子树均为二叉树*/ import com.sun.org.apache.bcel.internal.gen
二叉树（java实现）
qq_41835813的博客
09-10 191
二叉树基本概念： 二叉树也称为二分树，二元树，对分数等，当集合为空时，该二叉树被称为空二叉树。 结点的度：结点所拥有子树的个数称为该结点的度。 叶结点：度为0的结点称为叶结点，或称为终端结点。 分支结点：度不为0的结点，或者称为非终端结点，一颗的结点除了叶结点外，其他的都是分支结点。 左孩子，右孩子，双亲：书中一个结点的子树称为这个结点的双亲，具有同一个双亲孩子结点胡成为兄弟。 ...
二叉树(Java)
keke的博客
10-21 476
二叉树
二叉树（Java版）
WYSCODER的博客
08-04 3270
二叉树，看这一篇就够了~~~
二叉树Java实现
厚积薄发，持之以恒
08-21 294
二叉树Java实现定义相关概念遍历先序遍历中序遍历后序遍历搜索前继节点后继节点源码 定义 二叉树的定义是每个节点最多两个子节点，左子节点始终小于根节点，右子节点始终大于根节点。 相关概念 遍历 先序遍历 先访问根节点，再访问左子叶节点，最后访问右子叶节点 中序遍历 先访问左子节点，再访问根节点，最后访问右子节点，对每个节点访问时都执行以上规则，从而输出从小到大的排序 后序遍历 先访问左子叶节点，再访问右子叶节点，最后访问根节点 搜索 搜索过程模拟了就是一个二分搜索法 前继节点 小于当前节点值的最大节点 后继
平衡二叉树 java 实现
04-13
平衡二叉树（AVL树）是一种自平衡的二叉搜索树，它的左子树和右子树的高度差不超过1。...以上是一个简单的平衡二叉树的Java实现，包括插入节点、删除节点、旋转操作等方法。你可以根据需要进行调整和扩展。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值