学习二叉树(java版)

已于 2022-04-23 13:58:32 修改
阅读量696 收藏 1
点赞数 3
分类专栏： 数据结构 文章标签： java 学习 b树
于 2022-03-18 10:46:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenbaifan/article/details/123554385
版权
本文详细讲解了树和二叉树的概念，特殊二叉树（满二叉树与完全二叉树），以及关键性质、遍历方法（先序、中序、后序）、基本操作（节点数、叶子数、层节点数、高度和元素查找）。通过实例代码演示，助你快速掌握二叉树核心知识点。
摘要由CSDN通过智能技术生成

树概念

树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点：

1: 有一个特殊的结点，称为根结点，根结点没有前驱结点.
2: 除根结点外，其余结点被分成M(M > 0)个互不相交的集合T1、T2、…、Tm，其中每一个集合 Ti (1 <= i<= m) 又是一棵与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继.
3: 树是递归定义的。

大概就是这种:

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

一些重要的概念:

在这里插入图片描述

结点的度: 一个结点含有子树的个数称为该结点的度； 如上图：A的度为6
树的度： 一棵树中，所有结点度的最大值称为树的度； 如上图：树的度为6
叶子结点或终端结点： 度为0的结点称为叶结点； 如上图：B、C、H、I…等节点为叶结点
双亲结点或父结点： 若一个结点含有子结点，则这个结点称为其子结点的父结点； 如上图：A是B的父结点
孩子结点或子结点： 一个结点含有的子树的根结点称为该结点的子结点； 如上图：B是A的孩子结点
根结点： 一棵树中，没有双亲结点的结点；如上图：A
结点的层次： 从根开始定义起，根为第1层，根的子结点为第2层，以此类推
树的高度或深度： 树中结点的最大层次； 如上图：树的高度为4
树的以下概念只需了解，在看书时只要知道是什么意思即可：
非终端结点或分支结点： 度不为0的结点； 如上图：D、E、F、G…等节点为分支结点
兄弟结点： 具有相同父结点的结点互称为兄弟结点； 如上图：B、C是兄弟结点
堂兄弟结点： 双亲在同一层的结点互为堂兄弟；如上图：H、I互为兄弟结点
结点的祖先： 从根到该结点所经分支上的所有结点；如上图：A是所有结点的祖先
子孙： 以某结点为根的子树中任一结点都称为该结点的子孙。如上图：所有结点都是A的子孙
森林： 由m（m>=0）棵互不相交的树组成的集合称为森林

二叉树概念(重点)

一棵二叉树是结点的一个有限集合，该集合：

  1. 或者为空
  2. 或者是由一个根节点加上两棵别称为左子树和右子树的二叉树组成。

在这里插入图片描述

从上图可以看出：
3. 二叉树不存在度大于2的结点
4. 二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树

注意： 对于任意的二叉树都是由以下几种情况复合而成的：

在这里插入图片描述

两种特殊的二叉树

1. 满二叉树: 一棵二叉树，如果每层的结点数都达到最大值，则这棵二叉树就是满二叉树。也就是说，如果一棵二叉树的层数为K，且结点总数是 ，则它就是满二叉树。
2. 完全二叉树: 完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从0至n-1的结点一一对应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二叉树。

在这里插入图片描述

二叉树的性质

  1. 若规定根结点的层数为1，则一棵非空二叉树的第i层上最多有 (i>0)个结点
  2. 若规定只有根结点的二叉树的深度为1，则深度为K的二叉树的最大结点数是 (k>=0)
  3. 对任何一棵二叉树, 如果其叶结点个数为 n0, 度为2的非叶结点个数为 n2,则有n0＝n2＋1
  4. 具有n个结点的完全二叉树的深度k为 上取整
  5. 对于具有n个结点的完全二叉树，如果按照从上至下从左至右的顺序对所有节点从0开始编号，则对于序号为i
    的结点有：
    若i>0，双亲序号：(i-1)/2；i=0，i为根结点编号，无双亲结点
    若2i+1<n，左孩子序号：2i+1，否则无左孩子
    若2i+2<n，右孩子序号：2i+2，否则无右孩子

二叉树三种遍历

这三种遍历是最基本的,必须掌握!

先给一颗二叉树

在这里插入图片描述

流程基本就是这样
在这里插入图片描述

在这里插入图片描述

二叉树的基本操作

这里才是本博客的重点,搞懂代码才算搞懂二叉树:

这是我们要模拟实现的二叉树的功能,这些搞懂了,二叉树就差不多入门了

// 获取树中节点的个数
int size(Node root);
// 获取叶子节点的个数
int getLeafNodeCount(Node root);
// 子问题思路-求叶子结点个数
// 获取第K层节点的个数
int getKLevelNodeCount(Node root);
// 获取二叉树的高度
int getHeight(Node root);
// 检测值为value的元素是否存在
Node find(Node root, int val);
// 判断一棵树是不是完全二叉树
boolean isCompleteTree(Node root);

我们这里用的是枚举法创建二叉树,并不是正确的创建方法,但是为了方便我们理解,先这样用一下.

class TreeNode {    //定义节点
    public char val;  //节点值
    public TreeNode left;//左孩子的引用
    public TreeNode right;//右孩子的引用
    public TreeNode(char val) {  //构造方法
        this.val = val;
    }
}
public class BinaryTree {
    //public BTNode root;//二叉树的根节点

    /**
     * 这种方式 是穷举的方式创建的
     * 但是 这样写不行 太low了。
     *
     * @return
     */
    public TreeNode createTree() {
        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 preOrder(TreeNode root) {
        if(root == null) { //判断根节点为不为空
            return;
        }
        System.out.print(root.val+" "); //打印节点
        preOrder(root.left);  //进入左子树
        preOrder(root.right); //进入右子树
    }

在这里插入图片描述

接下来的中序遍历和后序遍历都大同小异了:
中序遍历:

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

后序遍历:

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

测试一下刚刚的遍历:

public class TestDemo {

    public static void main(String[] args) {
        BinaryTree binaryTree = new BinaryTree();
       TreeNode root = binaryTree.createTree();
        System.out.print("前序遍历: ");
        binaryTree.preOrder(root);
        System.out.println();
        System.out.print("中序遍历: ");
        binaryTree.inOrder(root);
        System.out.println();
        System.out.print("后序遍历: ");
        binaryTree.postOrder(root);
        System.out.println();

    }
}

在这里插入图片描述

有了刚刚的遍历思维,我们现在再来实现一些二叉树的基本功能:

获取树中节点个数

在这里插入图片描述

 //获取树中节点个数
    int count = 0; //记录根节点个数
    public int size(TreeNode root){
        if(root == null){
            return 0;
        }
        count++;  //借用前序遍历思想,遇到根节点就加一
        size(root.left); //递归左子树
        size(root.right);//递归右子树
        return count;  //返回根节点
    }

public class TestDemo {

    public static void main(String[] args) {
        BinaryTree binaryTree = new BinaryTree();
       TreeNode root = binaryTree.createTree();
        System.out.print("前序遍历: ");
        binaryTree.preOrder(root);
        System.out.println();
        System.out.print("中序遍历: ");
        binaryTree.inOrder(root);
        System.out.println();
        System.out.print("后序遍历: ");
        binaryTree.postOrder(root);
        System.out.println();
        int ret = binaryTree.size(root);
        System.out.println("树中节点个数为: "+ret);

    }
}

在这里插入图片描述

我们这里还有一种思维方式,子问题思路:想到所有节点个数就是 根节点 + 左子树节点 + 右子树节点.

/**
     * 子问题思路
     * @param root
     * @return
     */
    public int size1(TreeNode root) {
        if(root == null) {
            return 0;
        }
        return size(root.left) + size(root.right) + 1; //递归左子树节点 + 右子树节点 + 根节点
    }

在这里插入图片描述
在这里插入图片描述

获取叶子节点个数

/**
     * 获取叶子节点的个数
     * 遍历思路：
     */
     int leafCount = 0; //记录叶子节点个数
    public int getLeafNodeCount(TreeNode root) {
        if(root == null) {
            return 0;
        }
        if(root.left == null && root.right == null) {  //知道叶子节点左子树和右子树都为空
            leafCount ++;
        }
        getLeafNodeCount(root.left);  //递归左子树
        getLeafNodeCount(root.right); //递归右子树
        return leafCount;
    }

public class TestDemo {

    public static void main(String[] args) {
        BinaryTree binaryTree = new BinaryTree();
       TreeNode root = binaryTree.createTree();
        System.out.print("前序遍历: ");
        binaryTree.preOrder(root);
        System.out.println();
        System.out.print("中序遍历: ");
        binaryTree.inOrder(root);
        System.out.println();
        System.out.print("后序遍历: ");
        binaryTree.postOrder(root);
        System.out.println();
        int ret = binaryTree.size(root);
        System.out.println("树中节点个数为: "+ret);
        System.out.println(binaryTree.size1(root));
        int ret2 = binaryTree.getLeafNodeCount(root);
        System.out.println("叶子节点个数为: "+ret2);

    }
}

在这里插入图片描述

一样的,我们这里也用子问题思维

 /**
     * 获取叶子节点的个数
     * 子问题思路
     * @param root
     * @return
     */
    public int getLeafNodeCount2(TreeNode root) {
        if(root == null) {
            return 0;
        }
        if(root.left == null && root.right == null) {
            //当前的root是叶子节点
            return 1;
        }
        return getLeafNodeCount2(root.left) + getLeafNodeCount2(root.right);
    }

在这里插入图片描述
在这里插入图片描述

获取第k层节点的个数

 /**
     * 获取第K层节点的个数
     * 子问题思路：
     *
     */
   public  int getKLevelNodeCount(TreeNode root,int k) {  //获取第k层节点
        if(root == null || k <= 0) {
            return 0;
        }
        if(k == 1) {  //处于当层节点
            return 1;
        }
        return getKLevelNodeCount(root.left,k-1) + getKLevelNodeCount(root.right,k-1);  //左子树当层节点 + 右子树当层节点
    }

 public static void main(String[] args) {
        BinaryTree binaryTree = new BinaryTree();
       TreeNode root = binaryTree.createTree();
        System.out.print("前序遍历: ");
        binaryTree.preOrder(root);
        System.out.println();
        System.out.print("中序遍历: ");
        binaryTree.inOrder(root);
        System.out.println();
        System.out.print("后序遍历: ");
        binaryTree.postOrder(root);
        System.out.println();
        int ret = binaryTree.size(root);
        System.out.println("树中节点个数为: "+ret);
        System.out.println(binaryTree.size1(root));
        int ret2 = binaryTree.getLeafNodeCount(root);
        System.out.println("叶子节点个数为: "+ret2);
        int ret3 = binaryTree.getLeafNodeCount2(root);
        System.out.println(ret3);
        int ret4 = binaryTree.getKLevelNodeCount(root,3);
        System.out.println("第三层节点个数为: "+ret4);


    }
}

在这里插入图片描述

获取二叉树的高度

/**
     * 获取二叉树的高度
     * 时间复杂度：O(n)
     * 空间复杂度：O()
     */
   public int getHeight(TreeNode root) {
        if(root == null) return 0;
        int leftHeight = getHeight(root.left);
        int rightHeight = getHeight(root.right);
        return leftHeight > rightHeight ? leftHeight+1 : rightHeight+1; //精髓就是后面的加一,每次递归满足条件就加一,最后返回的就是高的那颗子树
    }

public class TestDemo {

    public static void main(String[] args) {
        BinaryTree binaryTree = new BinaryTree();
       TreeNode root = binaryTree.createTree();
        System.out.print("前序遍历: ");
        binaryTree.preOrder(root);
        System.out.println();
        System.out.print("中序遍历: ");
        binaryTree.inOrder(root);
        System.out.println();
        System.out.print("后序遍历: ");
        binaryTree.postOrder(root);
        System.out.println();
        int ret = binaryTree.size(root);
        System.out.println("树中节点个数为: "+ret);
        System.out.println(binaryTree.size1(root));
        int ret2 = binaryTree.getLeafNodeCount(root);
        System.out.println("叶子节点个数为: "+ret2);
        int ret3 = binaryTree.getLeafNodeCount2(root);
        System.out.println(ret3);
        int ret4 = binaryTree.getKLevelNodeCount(root,3);
        System.out.println("第三层节点个数为: "+ret4);
        int ret5 = binaryTree.getHeight(root);
        System.out.println("二叉树的高度为: "+ret5);


    }
}

在这里插入图片描述

子问题思维我感觉相对简单些

public int getHeight2(TreeNode root){
       if(root == null){
           return 0;
       }
       return Math.max(getHeight2(root.left),getHeight(root.right)) + 1; //精髓还是在那个加一,每次取较大值后加一,最后返回的就是树的高度
    }

检测为value的元素是否存在

/**
     * 检测值为value的元素是否存在
     */
   public TreeNode find(TreeNode root, char value) {
        if(root == null) return null;
        if(root.val == value) return root; //检测根节点是不是指定的元素

        TreeNode ret = find(root.left,value); //遍历左子树检测
        if(ret != null) {
            return ret;
        }
        ret = find(root.right,value); //遍历右子树检测
        if(ret != null) {
            return ret;
        }
        return null; //没有
    }

public class TestDemo {

    public static void main(String[] args) {
        BinaryTree binaryTree = new BinaryTree();
       TreeNode root = binaryTree.createTree();
        System.out.print("前序遍历: ");
        binaryTree.preOrder(root);
        System.out.println();
        System.out.print("中序遍历: ");
        binaryTree.inOrder(root);
        System.out.println();
        System.out.print("后序遍历: ");
        binaryTree.postOrder(root);
        System.out.println();
        int ret = binaryTree.size(root);
        System.out.println("树中节点个数为: "+ret);
        System.out.println(binaryTree.size1(root));
        int ret2 = binaryTree.getLeafNodeCount(root);
        System.out.println("叶子节点个数为: "+ret2);
        int ret3 = binaryTree.getLeafNodeCount2(root);
        System.out.println(ret3);
        int ret4 = binaryTree.getKLevelNodeCount(root,3);
        System.out.println("第三层节点个数为: "+ret4);
        int ret5 = binaryTree.getHeight(root);
        System.out.println("二叉树的高度为: "+ret5);
        int ret6 = binaryTree.getHeight2(root);
        System.out.println(ret6);
        System.out.print("判断H值是否存在,存在,返回其引用");
        System.out.println(binaryTree.find(root,'H'));
        try {
            System.out.println(binaryTree.find(root, 'H').val);
        }catch(NullPointerException e){
            e.printStackTrace();
            System.out.println("指定元素不存在,空指针异常了!");
        }

    }
}

在这里插入图片描述在这里插入图片描述在这里插入图片描述

判断一棵树是不是完全二叉树

这个题用队列做就简单一些了

/**
     * 是不是完全二叉树
     * @param root
     * @return
             */
    boolean isCompleteTree(TreeNode root) {
        if(root == null) return true;//空树也是完全二叉树
        Queue<TreeNode> queue = new LinkedList<>(); //创建队列(先进先出)
        queue.offer(root);  //先入根节点
        while (!queue.isEmpty()) {
            TreeNode cur = queue.poll(); //出队
            if(cur != null) {  //不为null,就将对应的左右子树入队
                queue.offer(cur.left);
                queue.offer(cur.right);
            }else { //出队元素为null
                break;
            }
        }

        while (!queue.isEmpty()) {  //开始判断二叉树是否为完全二叉树
            TreeNode top = queue.peek();
            if(top != null) {  //如果此队列里还有不为null的节点,说明这颗二叉树不是完全二叉树
                return false;
            }
            queue.poll();
        }
        return true; //走到了这里,说明他是一颗完全二叉树
    }

这是我们创建的二叉树

在这里插入图片描述

此时他不是一颗完全二叉树

public class TestDemo {

    public static void main(String[] args) {
        BinaryTree binaryTree = new BinaryTree();
       TreeNode root = binaryTree.createTree();
        System.out.print("前序遍历: ");
        binaryTree.preOrder(root);
        System.out.println();
        System.out.print("中序遍历: ");
        binaryTree.inOrder(root);
        System.out.println();
        System.out.print("后序遍历: ");
        binaryTree.postOrder(root);
        System.out.println();
        int ret = binaryTree.size(root);
        System.out.println("树中节点个数为: "+ret);
        System.out.println(binaryTree.size1(root));
        int ret2 = binaryTree.getLeafNodeCount(root);
        System.out.println("叶子节点个数为: "+ret2);
        int ret3 = binaryTree.getLeafNodeCount2(root);
        System.out.println(ret3);
        int ret4 = binaryTree.getKLevelNodeCount(root,3);
        System.out.println("第三层节点个数为: "+ret4);
        int ret5 = binaryTree.getHeight(root);
        System.out.println("二叉树的高度为: "+ret5);
        int ret6 = binaryTree.getHeight2(root);
        System.out.println(ret6);
        System.out.print("判断H值是否存在,存在,返回其引用");
        System.out.println(binaryTree.find(root,'H'));
        try {
            System.out.println(binaryTree.find(root, 'H').val);
        }catch(NullPointerException e){
            e.printStackTrace();
            System.out.println("指定元素不存在,空指针异常了!");
        }
boolean flag = binaryTree.isCompleteTree(root);
        System.out.println(flag);
    }
}

在这里插入图片描述

这时我们屏蔽掉H

在这里插入图片描述
在这里插入图片描述

就可以判断他是一颗完全二叉树了.

各位,代码可以保存复习备用!!

粉色的志明
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
二叉树的概念（Java）
weixin_45634073的博客
04-23 428
深度优先遍历是指从根节点开始，先访问其左子树，然后访问其右子树，最后访问根节点的遍历方式。二叉树是一种特殊的树形结构，它的每个节点最多只有两个子节点，分别称为左子节点和右子节点。插入操作通常需要遍历二叉树，找到插入的位置，然后插入新节点。求二叉树的节点个数可以使用递归的方式实现，每个节点的节点个数为其左右子树节点个数之和再加1。二叉树的遍历是指按照一定的顺序访问树中的所有节点，分为深度优先遍历和广度优先遍历两种方式。求二叉树的深度可以使用递归的方式实现，每个节点的深度为其左右子树深度的较大值加1。
java学习之—二叉树
小皮的博客
05-07 244
java学习之—二叉树 package com.data.java.towtree; import java.io.IOException; /** * 二叉树 * @Title: uminton */ class Node{ public int iData; //数据用作关键值 public...
Java 学习树
qq_39267263的博客
04-18 93
【Java】二叉树入门详解（包含二叉树0J练习解析）
热门推荐
意愿三七
06-05 3万+
目录一、 树型结构（了解）1.1 概念1.2 概念（重要）1.3 树的表示形式（了解）1.4 树的应用二、 二叉树的认识（重点）2.1 概念2.2 二叉树的基本形态2.3 两种特殊的二叉树2.4 二叉树的性质2.5 二叉树的存储2.6 二叉树的基本操作2.6.1 二叉树的遍历.2.6.2 二叉树的基本操作（1）前序遍历（2）中序遍历（3）后序遍历(4)遍历思路-求结点个数(5.)子问题思路-求结点个数(6)遍历思路-求叶子结点个数(7)子问题思路-求叶子结点个数(8)子问题思路-求第 k 层结点个数(9)获
一个基于Java实现的二叉树学习项目 包含二叉树生成、遍历
最新发布
05-20
适用人群：计算机，电子信息工程、数学等专业的大学生学习二叉树等数据结构，作为“参考资料”使用。 二叉树，一个基于Java实现的二叉树学习项目。包含二叉树生成、遍历。适用人群：计算机，电子信息工程、数学等...
erchashu.rar_二叉树 java
09-24
在这个“erchashu.rar_二叉树 java”压缩包中，我们聚焦于使用Java语言来实现二叉树算法。下面将详细讨论二叉树的基本概念、类型、操作以及如何用Java来实现它们。 首先，二叉树是每个节点最多有两个子节点的数据...
数据结构-二叉树 JAVA语言实现
10-16
通过阅读和理解`BinaryTreeDemo`的代码，你可以深入学习二叉树的JAVA实现。 总结来说，理解和掌握二叉树以及如何用JAVA实现它们是成为优秀程序员的关键一步。通过实践，你可以更深入地了解数据结构的精髓，提升算法...
【java 数据结构】还不会二叉树？一篇搞定二叉树
12-21
二叉树是计算机科学中非常基础且重要的数据结构，它是一种每个节点最多有两个子节点的树形结构。本文将深入探讨二叉树的概念、类型及其遍历方法。...无论是理论学习还是实际项目开发，掌握二叉树都能带来显著的优势。
java版数据结构的 算术表达式与二叉树源码
06-08
总结，Java版的算术表达式与二叉树源码实现了将算术表达式转化为二叉树结构，并提供了遍历和计算功能。这对于理解和实践数据结构，特别是二叉树的操作，具有很大的帮助。通过分析和运行这样的源码，开发者可以深入...
Java二叉树学习
weixin_56738054的博客
09-25 252
二叉树
Java学习技能树
qq_26738489的博客
07-19 882
个人觉得对初学Java的人来说，这种类似知识树的东西非常有必要。至于最后的就业指导可以无视
java学习笔记（树）
qq_36334929的博客
12-07 247
目录计算机中的树二叉树查找树/排序树平衡树与不平衡树红黑树 计算机中的树 计算机中的树类似于现实中的树倒过来，最上面的节点叫做树根，每一个节点下面的节点叫做该节点的子节点，所有的节点都为树根的子节点。当某一节点不再有子节点时，该节点就叫做叶子节点。一般计算机中的的树的形状，都近似于金字塔形（上小下大） 二叉树 二叉树的分支不能超过两个，某一节点左边的分支叫做该节点的左子树（左孩子），右边的分支叫做该节点的右子树（右孩子） 查找树/排序树 在二叉树的基础上，其元素是有大小顺序的 左子树小，右子树
【JAVA】数据结构——二叉树的学习
qq_45864756的博客
07-11 285
二叉树相关概念及基本方法和代码实现
java 技能树（csdn学习篇）
weixin_51387754的博客
12-29 1048
Java 是由 Sun Microsystems 公司于 1995 年 5 月推出的高级程序设计语言。 Java 可运行于多个平台，如 Windows, Mac OS 及其他多种 UNIX 版本的系统。
C++二叉树理论基础
qq_46780256的博客
01-23 1261
目录 二叉树性质 ​二叉树种类 满二叉树 完全二叉树 二叉搜索树 ​平衡二叉搜索树 二叉树存储方式 二叉树的遍历方式 二叉树的定义 二叉树性质 二叉树种类 满二叉树 如果一棵二叉树只有度为0的结点和度为2的结点，并且度为0的结点在同一层上，则这棵二叉树为满二叉树。 完全二叉树 在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~2^h -1 个节点。...
JAVA中的二叉树
qq1223479499的博客
05-02 1606
一、树形结构 树结构是除了根结点和叶子结点之外,树中任意一个结点只有一个直接前驱结点(父结点)和多个直接后继结点(孩子结点),根结点没有前驱结点,叶子结点没有后继结点. 二、二叉树的构成 二叉树由节点（node）和边组成。节点分为根节点、父节点、子节点。如下图所示： 红色是根节点（root）。蓝色是子节点也是父节点，绿色的是子节点。其余的线是边。节点和链表中的节点一样都可以存放数据信息。树中的边可以用自引用表示，这种引用就是C/C++里面的指针。通常来说树是顶部小，底部大，且树呈分层结...
树的简单介绍
qq_45075338的博客
11-15 444
一. 树型结构 （1） 概念 树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。 它具有以下的特点：每个结点有零个或多个子结点；没有父结点的结点称为根结点；每一个非根结点有且只有一个父结点；除了根结点外，每个子结点可以分为多个不相交的子树 。 （2）概念 节点的度：一个节点含有的子树的...
Java中的二叉树
wssjiayou的博客
08-04 380
Java中的二叉树
二叉树后序遍历操作详解-Java实现
在Java环境下，后序遍历是一种常见的遍历二叉树的方法，其顺序为先遍历左子树，然后遍历右子树，最后访问根节点。此外，文章还涵盖了树的基本术语，如根节点、子树、度、叶子节点等，以及树的存储结构、遍历方法和...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

粉色的志明

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值