【数据结构】java实现二叉树

已于 2023-08-28 10:45:30 修改
阅读量769 收藏 4
点赞数 1
文章标签： java 数据结构 算法
于 2023-08-27 19:54:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JZJ_LYH/article/details/132520942
版权

二叉树是一种常见的树状数据结构，它由一组节点组成，其中每个节点最多有两个子节点：一个左子节点和一个右子节点。二叉树的特性以及其在数学上的联系使其成为许多算法和数据结构中的重要概念。

二叉树的相关概念

  1. 根节点：二叉树的根节点是整个树的起点，它没有父节点。

  2. 子节点：每个节点可以有最多两个子节点，一个左子节点和一个右子节点。

  3. 叶子节点：叶子节点是没有子节点的节点，也称为终端节点。

  4. 度：节点的度表示该节点拥有的子节点个数。

  5. 深度：节点的深度表示从根节点到该节点的路径长度。

  6. 高度：二叉树的高度表示树中任意节点的最大深度。

  7. 父节点：一个节点的父节点是其直接上级节点。

  8. 祖先节点：一个节点的祖先节点是其在路径上的任意上级节点。

  9. 子孙节点：一个节点的子孙节点是其在路径上的任意下级节点。

  10. 节点的顺序：二叉树中节点的顺序分为前序遍历（根-左-右）、中序遍历（左-根-右）和后序遍历（左-右-根）。

二叉树的java实现

定义二叉树节点类

注意下面代码中使用到的栈和队列是用单链表模拟的，
如需使用代码请替换为Stack、LinkedList。

public class TreeNode<T> {
    private T data;
    private TreeNode leftChild;
    private TreeNode rightChild;
    public TreeNode(T data) {
        this.data = data;
    }

    public TreeNode() {
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public TreeNode getLeftChild() {
        return leftChild;
    }

    public void setLeftChild(TreeNode leftChild) {
        this.leftChild = leftChild;
    }

    public TreeNode getRightChild() {
        return rightChild;
    }

    public void setRightChild(TreeNode rightChild) {
        this.rightChild = rightChild;
    }
}

创建二叉树

public class BinaryTree<T> {
    private TreeNode<T> root;
    public BinaryTree(T data) {
        this.root = new TreeNode<>(data);
    }
    public BinaryTree() {}
    public BinaryTree(LinkListQueue<T> listQueue) {
        this.root = createBinaryTree(listQueue);
    }
    public TreeNode<T> getRoot() {
        return root;
    }
    //    层序遍历单链表队列创建二叉树方法
    public TreeNode createBinaryTree(LinkListQueue<T> listQueue) {
        if(listQueue==null||listQueue.isEmpty()){
            return null;
        }
        LinkListQueue<TreeNode> queue = new LinkListQueue<>();
        root = new TreeNode<>(listQueue.poll());
        queue.offer(root);
        while (!queue.isEmpty()){
            TreeNode poll = queue.poll();
            if(!listQueue.isEmpty()){
                poll.setLeftChild(new TreeNode<>(listQueue.poll()));
                queue.offer(poll.getLeftChild());
            }
            if(!listQueue.isEmpty()){
                poll.setRightChild(new TreeNode<>(listQueue.poll()));
                queue.offer(poll.getRightChild());
            }
        }
        return root;
    }
}

二叉树的常用操作和方法

  1. 遍历二叉树
    • 前序遍历
// 递归实现
public void preorderTraversal(TreeNode root){
    if(root==null){
        return;
    }
    System.out.print(root.getData()+" ");
    preorderTraversal(root.getLeftChild());
    preorderTraversal(root.getRightChild());
}
// 非递归实现，手动压栈
public void preorderTraversal1(TreeNode root){
    LinkListStack<TreeNode> stack = new LinkListStack<>();
    if (root!= null){
        stack.push(root);
        while (!stack.isEmpty()){
            root = stack.pop();
            System.out.print(root.getData() + " ");
            // 先把右子树压栈
            if (root.getRightChild() != null){
                stack.push(root.getRightChild());
            }
            // 再把左子树压栈
            if(root.getLeftChild() != null){
                stack.push(root.getLeftChild());
            }
        }
    }
    System.out.println();
}
  • 中序遍历
// 递归实现
public void inorderTraversal(TreeNode root){
    if(root==null){
        return;
    }
    inorderTraversal(root.getLeftChild());
    System.out.print(root.getData()+" ");
    inorderTraversal(root.getRightChild());
}
// 非递归实现，手动压栈
public void inorderTraversal1(TreeNode root){
    LinkListStack<TreeNode> stack = new LinkListStack<>();
    if (root != null){
        while (!stack.isEmpty() || root != null){
        	// 先把当前节点的子孙左子树全部压栈
            if (root != null) {
            	stack.push(root);
            	root = root.getLeftChild();
            } else {
            	// 打印完左子树再处理右子树
            	root = stack.pop();
            	System.out.print(root.getData() + " ");
            	root = root.getRightChild();
            }
        }
    }
    System.out.println();
}
  • 后序遍历
// 递归实现
public void postorderTraversal(TreeNode root){
    if(root==null){
        return;
    }
    postorderTraversal(root.getLeftChild());
    postorderTraversal(root.getRightChild());
    System.out.print(root.getData()+" ");
}
// 非递归实现，手动压栈
public void postorderTraversal1(TreeNode root){
    LinkListStack<TreeNode> stack1 = new LinkListStack<>();
    LinkListStack<TreeNode> stack2 = new LinkListStack<>();
    TreeNode node = root;
    if (root != null){
        stack1.push(node);
        while (!stack1.isEmpty()){
            node = stack1.pop();
            stack2.push(node);
            if(node.getLeftChild()!=null){
                stack1.push(node.getLeftChild());
            }
            if(node.getRightChild()!=null){
                stack1.push(node.getRightChild());
            }
        }
        while (!stack2.isEmpty()){
            System.out.print(stack2.pop().getData() + " ");
        }
    }
    System.out.println();
}
  • 层序遍历(广度优先)
public void sequenceTraversal(TreeNode root){
    LinkListQueue<TreeNode> queue = new LinkListQueue<>();
    TreeNode node = root;
    queue.offer(node);
    while (!queue.isEmpty()){
        node = queue.poll();
        System.out.print(node.getData()+" ");
        if(node.getLeftChild()!=null){
            queue.offer(node.getLeftChild());
        }
        if(node.getRightChild()!=null) {
            queue.offer(node.getRightChild());
        }
    }
}
  1. 求最深高度
//    求二叉树的高度
public int getHeight(TreeNode root) {
    int lefth, righth;
    if (root == null) {
        return 0;
    } else {
        lefth = getHeight(root.getLeftChild());
        righth = getHeight(root.getRightChild());
//            return Math.max(lefth,righth)+1;
        return 1 + (lefth > righth ? lefth : righth);
    }
}
  1. 求最大宽度
public int getWidth(TreeNode root) {
    if (root == null) {
        return 0;
    }
    LinkListQueue<TreeNode> queue = new LinkListQueue<>();
    TreeNode node = root;
    queue.offer(node);
    HashMap<TreeNode, Integer> map = new HashMap<>();
    map.put(node, 1);
    int curLevel = 1;   // 当前层级
    int curNodeLevel = 1;   // 当前节点层级
    int curLevelNodes = 0;  // 当前层级的节点数
    int max = Integer.MIN_VALUE;
    while (!queue.isEmpty()) {
        node = queue.poll();
        curNodeLevel = map.get(node);
        if (curNodeLevel == curLevel){
        	// 如果当前节点层级等于当前层级 当前层级节点数就+1
            curLevelNodes++;
        } else {
        	// 说明当前层级已经遍历完了 比较最大节点数 层级+1 当前层级节点数重置
            max = max > curLevelNodes? max : curLevelNodes;
            curLevel++;
            curLevelNodes = 1;
        }
        if (node.getLeftChild() != null) {
            map.put(node.getLeftChild(), curNodeLevel+1);
            queue.offer(node.getLeftChild());
        }
        if (node.getRightChild() != null) {
            map.put(node.getRightChild(), curNodeLevel+1);
            queue.offer(node.getRightChild());
        }
    }
    return max > curLevelNodes? max : curLevelNodes;
}
  1. 节点个数
public int numOfNodes(TreeNode root) {
    int c, l, r;
    if (root == null) {
        return 0;
    }
    c = 1;
    l = numOfNodes(root.getLeftChild());
    r = numOfNodes(root.getRightChild());
    return c + l + r;
}
  1. 删除节点
    这部分代码有一个bug就是如果待删除节点的左子树有左右子树 子树的子树又有左右子树的话就会丢失掉一颗左左左子树
public TreeNode deleteTreeNode(TreeNode root, T data) {
    if (root == null) {
        return null;
    }
    if (root.getData().equals(data)){
        if (root.getLeftChild() == null && root.getRightChild() == null) {
            // 如果待删除节点没有孩子就直接返回null
            return null;
        } else if (root.getLeftChild() != null) {
            // 如果待删除节点有左子树
            if (root.getLeftChild().getLeftChild() != null && root.getLeftChild().getRightChild() != null){
                root.getLeftChild().getLeftChild().setLeftChild(root.getLeftChild().getRightChild());
                root.getLeftChild().setRightChild(root.getRightChild());
            } else if (root.getLeftChild().getLeftChild() == null) {
                root.getLeftChild().setLeftChild(root.getLeftChild().getRightChild());
            }
            return root.getLeftChild();
        } else {
            // 如果待删除节点没有左子树那么右子树直接顶替该节点
            return root.getRightChild();
        }
    }
    // 向左遍历子树
    root.setLeftChild(deleteTreeNode(root.getLeftChild(), data));
    // 向右遍历子树
    root.setRightChild(deleteTreeNode(root.getRightChild(), data));
    return root;
}
  1. 判断是不是完全二叉树
public boolean isCompleteBinaryTree(TreeNode root){
    if(root==null) return true;
    LinkListQueue<TreeNode> queue = new LinkListQueue<>();
    // 是否遇到左左孩子不全的节点
    boolean decide = false;
    TreeNode left = null;
    TreeNode right = null;
    queue.offer(root);
    while (!queue.isEmpty()){
        root = queue.poll();
        left = root.getLeftChild();
        right = root.getRightChild();
        if ((left==null && right!=null) || (decide && (left!=null || right!=null))){
            // 有右无左或有左无右剩下不全是叶子节点，不是满二叉树
            return false;
        }
        if(left!=null){
            queue.offer(left);
        }
        if(right!=null){
            queue.offer(right);
        }
        if(left==null || right==null){
            decide = true;
        }
    }
    return true;
}
  1. 判断是不是搜素二叉树
public boolean isSearchBinaryTree(TreeNode root){
    if (root != null){
        int preValue = Integer.MIN_VALUE;
        LinkListStack<TreeNode> stack = new LinkListStack<>();
        while (!stack.isEmpty() || root!=null){
            if(root!=null){
                stack.push(root);
                root = root.getLeftChild();
            } else {
                root = stack.pop();
                if ((int)root.getData() <= preValue) {
                    return false;
                }else {
                    preValue = (int)root.getData();
                }
                root = root.getRightChild();
            }
        }
    }
    return true;
}
Monkey_Jun
关注
数据结构之二叉树（JAVA实现）
weixin_38419670的博客
02-22 2016
1. 什么是二叉树 满足以下两个条件的树称之为二叉树： 1. 本质上为有序树； 2. 每个结点的度不能超过2，即结点的度仅能为0，1，2。 2. 二叉树的性质 性质1：二叉树第i层的结点数最多为2^(i-1) (i>=1)。 性质2：深度为k的二叉树最多有2^k - 1个结点。 性质3：在任意一颗二叉树中，若终端结点（叶子结点）的个数为n0，度为2的结点树为n2，则n0=n2+1。 证明：设二叉树中度为1的结点数为n1，结点总数为n，则n = n0 + n1 +n2。同时，度为2的子结
java 数据结构二叉树的实现代码
09-01
在Java中，数据结构中的二叉树是一种重要的抽象数据类型，它由节点组成，每个节点最多有两个子节点，通常称为左子节点和右子节点。在本文中，我们将深入探讨如何使用Java实现二叉树，并通过接口、节点类和具体实现来...
Java创建二叉树java
08-17
代码实现： 二叉树的查找、插入、删除和输出根节点到当前节点的路径 二叉树的前序遍历，中序遍历和后续遍历 TreeNode.java --定义树节点 Mytree.java----创建树结构和上述功能函数 TestTree.java --测试上述的功能
JAVA 实现二叉树。
博海软件
01-18 73
一、创建结点类： package com.test.tree; public class Node { public Node leftNode; public Node rightNode; int data; /** * @author hbliu * @param newData */ public Node(int newData) {...
二叉树（Java实现）
热门推荐
JiaXingNashishua的博客
05-22 1万+
声明：本文部分文章取自于 Java中关于二叉树详解_来学习的小张的博客-CSDN博客_java 二叉树原理 更多关于二叉树详情可以点击上面链接 一：树形结构 树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点： 有一个特殊的节点，称为根节点，根节点没有前驱节点； 除根节点外，其余节点被分成M(M > 0)个互不相交的集合T1、T2、......、Tm，其中每一个
java创建二叉树
zl237104326的专栏
04-08 593
/**    * 创建非完全二叉树、完全二叉树、满二叉树  *    * 由于二叉树的节点增加没有什么规则，所以这里只是简单的使用了递一  * 次性把整棵树创建出来，而没有设计出一个一个添加节点的方法与删除  * @author jzj    * @date 2009-12-23    */   public class BinTree {// Bin=Binary(二进
创建二叉树 Java
obitosbb的博客
03-08 1720
网上的算法大多数是c语言的，Java对与树的操作比较少，都是指针操作，所以Java也可以实现。 网上的要么是一边输入一边构建，要么是手动insert，个人感觉不是一种特别好的写法。我这里用的是字符串构建，以‘#’分割。 本文主要是二叉树的构建，没有太多关于二叉树的操作，思路比较简单，故不做算法逻辑介绍。 二叉树结构类 public class BinaryTreeNode { char value; BinaryTreeNode left; BinaryTreeNode
JAVA 实现二叉树（链式存储结构）
09-02
总的来说，理解和实现二叉树是理解数据结构和算法的基础，这对于任何Java开发者来说都是至关重要的技能。通过这种方式，你可以更好地处理复杂的问题，优化代码性能，并为高级算法如排序和搜索奠定基础。
数据结构-二叉树Java实现及其遍历算法
最新发布
09-24
数据结构-二叉树Java实现及其遍历算法，代码示例中实现了中序遍历，简单易学。
数据结构-二叉树 JAVA语言实现
10-16
在IT领域，数据结构是计算机科学的基础，而二叉树作为一种重要的数据结构，被广泛应用于算法设计、数据库系统、编译器等领域。本教程将详细阐述如何使用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二叉树创建
qq_39559604的博客
05-05 548
   /*     * 先序创建二叉树     * 返回：根节点     */    public TreeNode&lt;T&gt;  creatBinaryPre(LinkedList&lt;T&gt; treeData)    {        TreeNode&lt;T&gt; root=null;        T data=treeData.removeFirst();        ...
【数据结构】之二叉树的java实现
dawuafang
10-02 546
二叉树的定义： 二叉树是树形结构的一个重要类型。许多实际问题抽象出来的数据结构往往是二叉树的形式，即使是一般的树也能简单地转换为二叉树，而且二叉树的存储结构及其算法都较为简单，因此二叉树显得特别重要。 二叉树(BinaryTree)是n(n≥0)个结点的有限集，它或者是空集(n=0)，或者由一个根结点及两棵互不相交的、分别称作这个根的左子树和右子树的二叉树组成。 这个定义是递归的。由于左...
JAVA实现二叉树
weixin_34067049的博客
04-25 93
树是编程中一种常用的数据结构。以前在学习数据结构时，总想着如何实际地实现出一颗二叉树出来，现在参考了《数据结构与算法分析 JAVA语言描述 第二版》之后，照着书中的例子实现了一颗二叉树，个人感觉书上面的二叉树实现操作比较复杂。下面将我学到的一些知识记录下来： 1，定义树的操作的基本接口，其中不包括插入或删除操作，因为这二种操作与树的结构相关，不同的树的实现有着不同的插入与删除方式，故不应该将这二...
用Java实现二叉树
快乐很伟大
09-08 954
在计算机科学 中，二叉树 是每个节点最多有两个子树 的有序树 。通常子树被称作“左子树”（left subtree ）和“右子树”（right subtree ）。二叉树常被用于实现二叉查找树 和二叉堆 。 二叉树的每个结点至多只有二棵子树(不存在度大于2的结点)，二叉树的子树有左右之分，次序不能颠倒。二叉树的第i层至多有2i − 1 个结点；深度为k的二叉树至多有2k − 1 个结点；
Java 实现 二叉树
amy acker的博客
09-02 92
1.定义节点 /** * 定义节点 */ public class BinaryTreeNode { private BinaryTreeNode leftChild ; // 左子树 private BinaryTreeNode rightChild; // 右子树 private Integer date; public BinaryTreeNod...
用java 实现二叉树创建
花生日记
04-21 2750
二叉树是数据结构中的一个重要的概念，二叉树的概念最早由 Linus Torvalds在1958年提出。他给出了一个树形数据结构，可以用来存储二叉树。每个节点的左子树和右子树都是空，中间层是子树。在一个给定的空间中，每一个节点都有两个左右子树。 在 Java中，我们可以用类似的方法来创建二叉树，但是这个方法只支持最简单的二叉树类型。例如，对于下面这种类型的二叉树，它需要四个节点：左子树、右子树和根结点。如果我们想创建一个节点为树根的二叉树，则需要更复杂的方法。 在本文中，我们将介绍如何在 Java中
Java数据结构复习：二叉树遍历详解
"Java基础复习笔记08数据结构-二叉树和二叉树的遍历" 这篇笔记主要探讨了Java中的数据结构——二叉树及其遍历方法。二叉树是一种非线性数据结构，每个节点最多有两个子节点，通常分为左子节点和右子节点。在计算机...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值