二叉树的Java实现

最新推荐文章于 2023-07-08 00:00:00 发布
最新推荐文章于 2023-07-08 00:00:00 发布
阅读量264 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/eeeemon/article/details/110082622
版权

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.csdn.net/eeeemon/article/details/109663628

 

 

a-bit
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java实现二叉树
weixin_44616879的博客
06-06 231
Java实现树结点、二叉树
二叉树（Java实现）
热门推荐
JiaXingNashishua的博客
05-22 1万+
声明：本文部分文章取自于 Java中关于二叉树详解_来学习的小张的博客-CSDN博客_java 二叉树原理 更多关于二叉树详情可以点击上面链接 一：树形结构 树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点： 有一个特殊的节点，称为根节点，根节点没有前驱节点； 除根节点外，其余节点被分成M(M > 0)个互不相交的集合T1、T2、......、Tm，其中每一个
【Java】二叉树
qq_61635026的博客
07-08 2320
二叉树（Binary Tree）是一种常见的树形结构，它由节点（Node）和节点之间的关系构成。每个节点最多有两个子节点，分别称为左子节点和右子节点。二叉树中的每个节点可以为空（null）。
数据结构（二叉树）——Java实现
m0_56911284的博客
11-03 2790
认识二叉树，并用Java实现其一系列的操作。
Java语言----二叉树
tq02的博客
05-28 2906
二叉树详细讲解，以及Java实现代码
Java二叉树
m0_64318128的博客
10-16 1739
二叉树的概念、性质、以及二叉树的基本操作
二叉树java实现
08-27
在Java中实现二叉树，我们可以自定义一个类来表示树节点，并通过节点之间的连接来构建整个树形结构。这篇博客主要讨论了如何在Java中实现二叉树的基本操作，包括递归和非递归方式的三种遍历顺序：前序遍历、中序遍历...
Java实现先序遍历二叉树
最新发布
04-26
在Java中，实现二叉树的先序遍历可以通过递归来完成。先序遍历的顺序是：首先访问根节点，然后递归地先序遍历左子树，最后递归地先序遍历右子树。 在这段代码中，Node类定义了二叉树的节点，包含数据域和指向左右子...
Java实现表达式二叉树
09-01
【Java实现表达式二叉树】是编程领域中一种数据结构的应用，主要用于处理数学表达式。在计算机科学中，二叉树是一种特殊的树形数据结构，每个节点最多有两个子节点，通常分为左子节点和右子节点。表达式二叉树，又...
数据结构-二叉树 JAVA语言实现
10-16
总结来说，理解和掌握二叉树以及如何用JAVA实现它们是成为优秀程序员的关键一步。通过实践，你可以更深入地了解数据结构的精髓，提升算法设计能力，并为解决复杂问题打下坚实基础。对于初学者，可以从简单的二叉树...
基于JAVA开发的二叉树课程设计与实现
07-10
在本项目中，“基于JAVA开发的二叉树课程设计与实现”主要涵盖了计算机科学中的数据结构和算法领域，特别是关于二叉树的理论知识、Java编程语言的应用以及软件工程的基本实践。二叉树是一种重要的非线性数据结构，...
二叉树（Java版）
WYSCODER的博客
08-04 2925
二叉树，看这一篇就够了~~~
Java数据结构————二叉树
爱敲代码的三毛的博客
08-20 1101
文章目录一、树型结构（了解）1.概念2. 树与非树3. 树的一些重要的概念4. 树的表示形式（了解）5. 树的一些应用二、二叉树1.二叉树的概念2.二叉树的基本形态3.两种特殊的二叉树4. 二叉树的性质5. 二叉树的存储三、二叉树的基本操作1.二叉树的遍历2.前序遍历3. 中序遍历4. 后序遍历5. 求结点个数6.求叶子结点个数7. 求第 k 层结点个数8.获取二叉树的高度9. 查找 val 所在结点10. 层序遍历11. 判断一棵树是不是完全二叉树完！ 要想了解二叉树先要知道什么是树 一、树型结构（..
【数据结构】之二叉树的java实现
dawuafang
10-02 531
二叉树的定义： 二叉树是树形结构的一个重要类型。许多实际问题抽象出来的数据结构往往是二叉树的形式，即使是一般的树也能简单地转换为二叉树，而且二叉树的存储结构及其算法都较为简单，因此二叉树显得特别重要。 二叉树(BinaryTree)是n(n≥0)个结点的有限集，它或者是空集(n=0)，或者由一个根结点及两棵互不相交的、分别称作这个根的左子树和右子树的二叉树组成。 这个定义是递归的。由于左...
【数据结构】用Java实现一棵二叉树
qq_53869058的博客
03-30 3928
这里给出从前序与中序遍历序列构造二叉树、从中序与后序遍历序列构造二叉树以及二叉树的基本操作。
二叉树的遍历-由中序和后序遍历序列确定一颗二叉树
eeeemon的博客
11-25 7372
概述 中序遍历的结果和后序遍历的结果可以确定一颗二叉树 方法 后序序列可以知道根结点和子树的子节点；中序序列可以知道根结点（子树的子节点）的左子树有哪些元素，右子树有哪些元素 推演 中序遍历序列和后序遍历序列确定树 中序序列：cbedahgijf 后序序列：cedbhjigfa 案例 Given the postorder and inorder traversal sequences 给出后序和中序序列 you are supposed to output th...
平衡二叉树 java 实现
04-13
平衡二叉树（AVL树）是一种自平衡的二叉搜索树，它的左子树和右子树的高度差不超过1。在Java中，可以通过以下步骤实现平衡二叉树： 1. 定义节点类：首先定义一个节点类，包含节点值、左子节点和右子节点等属性。 ```java class Node { int value; Node left; Node right; public Node(int value) { this.value = value; this.left = null; this.right = null; } } ``` 2. 实现平衡二叉树类：创建一个平衡二叉树类，包含插入节点、删除节点、旋转操作等方法。 ```java class AVLTree { private Node root; // 插入节点 public void insert(int value) { root = insertNode(root, value); } private Node insertNode(Node root, int value) { if (root == null) { return new Node(value); } if (value < root.value) { root.left = insertNode(root.left, value); } else if (value > root.value) { root.right = insertNode(root.right, value); } else { // 如果存在相同值的节点，可以根据需求进行处理 return root; } // 更新节点的高度 root.height = 1 + Math.max(getHeight(root.left), getHeight(root.right)); // 平衡操作 int balance = getBalance(root); // 左左情况，进行右旋操作 if (balance > 1 && value < root.left.value) { return rightRotate(root); } // 右右情况，进行左旋操作 if (balance < -1 && value > root.right.value) { return leftRotate(root); } // 左右情况，先左旋再右旋 if (balance > 1 && value > root.left.value) { root.left = leftRotate(root.left); return rightRotate(root); } // 右左情况，先右旋再左旋 if (balance < -1 && value < root.right.value) { root.right = rightRotate(root.right); return leftRotate(root); } return root; } // 删除节点 public void delete(int value) { root = deleteNode(root, value); } private Node deleteNode(Node root, int value) { // 空树或未找到节点 if (root == null) { return root; } if (value < root.value) { root.left = deleteNode(root.left, value); } else if (value > root.value) { root.right = deleteNode(root.right, value); } else { // 找到要删除的节点 // 节点只有一个子节点或无子节点 if (root.left == null || root.right == null) { Node temp = null; if (temp == root.left) { temp = root.right; } else { temp = root.left; } // 无子节点的情况 if (temp == null) { temp = root; root = null; } else { // 一个子节点的情况 root = temp; } } else { // 节点有两个子节点，找到右子树中最小的节点 Node temp = minValueNode(root.right); // 将右子树中最小节点的值赋给要删除的节点 root.value = temp.value; // 删除右子树中最小的节点 root.right = deleteNode(root.right, temp.value); } } // 更新节点的高度 root.height = 1 + Math.max(getHeight(root.left), getHeight(root.right)); // 平衡操作 int balance = getBalance(root); // 左左情况，进行右旋操作 if (balance > 1 && getBalance(root.left) >= 0) { return rightRotate(root); } // 左右情况，先左旋再右旋 if (balance > 1 && getBalance(root.left) < 0) { root.left = leftRotate(root.left); return rightRotate(root); } // 右右情况，进行左旋操作 if (balance < -1 && getBalance(root.right) <= 0) { return leftRotate(root); } // 右左情况，先右旋再左旋 if (balance < -1 && getBalance(root.right) > 0) { root.right = rightRotate(root.right); return leftRotate(root); } return root; } // 获取节点的高度 private int getHeight(Node node) { if (node == null) { return 0; } return node.height; } // 获取节点的平衡因子 private int getBalance(Node node) { if (node == null) { return 0; } return getHeight(node.left) - getHeight(node.right); } // 右旋操作 private Node rightRotate(Node y) { Node x = y.left; Node T2 = x.right; x.right = y; y.left = T2; y.height = Math.max(getHeight(y.left), getHeight(y.right)) + 1; x.height = Math.max(getHeight(x.left), getHeight(x.right)) + 1; return x; } // 左旋操作 private Node leftRotate(Node x) { Node y = x.right; Node T2 = y.left; y.left = x; x.right = T2; x.height = Math.max(getHeight(x.left), getHeight(x.right)) + 1; y.height = Math.max(getHeight(y.left), getHeight(y.right)) + 1; return y; } // 获取最小值节点 private Node minValueNode(Node node) { Node current = node; while (current.left != null) { current = current.left; } return current; } } ``` 以上是一个简单的平衡二叉树的Java实现，包括插入节点、删除节点、旋转操作等方法。你可以根据需要进行调整和扩展。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值