二叉树的基本操作

最新推荐文章于 2025-05-12 22:58:11 发布
原创 最新推荐文章于 2025-05-12 22:58:11 发布 · 393 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#二叉树 #Java #伏都哥哥 #数据结构 #递归
本文详细介绍了二叉树的定义及其基本性质，并通过Java代码实现了一个二叉树节点类和二叉树操作类，包括创建二叉树、求深度、节点数、叶子节点数及三种遍历方式。

二叉树的定义是递归的

定义：
二叉树(Binary tree)是n(n≥0)个结点的有限集合。若n=0时称为空树，否则：
⑴有且只有一个特殊的称为树的根(Root)结点；
⑵若n>1时，其余的结点被分成为二个互不相交的子集T1,T2，分别称之为左、右子树，并且左、右子树又都是二叉树。

二叉树的性质：
1.在非空二叉树中，第i层上至多有2i-1个结点(i≧1)
2.深度为k的二叉树至多有2k-1个结点（k≧1)
3.对任何一棵二叉树，若其叶子结点数为n，度为2的结点数为m，则n=m+1

封装一个节点类

public class BTNode {
    char value;//节点存的值
    BTNode Lchild;//左子树
    BTNode Rchild;//右子树
    public char getValue() {
        return value;
    }
    public void setValue(char value) {
        this.value = value;
    }
    public BTNode getLchild() {
        return Lchild;
    }
    public void setLchild(BTNode lchild) {
        Lchild = lchild;
    }
    public BTNode getRchild() {
        return Rchild;
    }
    public void setRchild(BTNode rchild) {
        Rchild = rchild;
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((Lchild == null) ? 0 : Lchild.hashCode());
        result = prime * result + ((Rchild == null) ? 0 : Rchild.hashCode());
        result = prime * result + value;
        return result;
    }
    public BTNode(char value, BTNode lchild, BTNode rchild) {
        super();
        this.value = value;
        Lchild = lchild;
        Rchild = rchild;
    }
    public BTNode() {
        super();
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        BTNode other = (BTNode) obj;
        if (Lchild == null) {
            if (other.Lchild != null)
                return false;
        } else if (!Lchild.equals(other.Lchild))
            return false;
        if (Rchild == null) {
            if (other.Rchild != null)
                return false;
        } else if (!Rchild.equals(other.Rchild))
            return false;
        if (value != other.value)
            return false;
        return true;
    }
    @Override
    public String toString() {
        return "BTNode [value=" + value + ", Lchild=" + Lchild + ", Rchild=" + Rchild + "]";
    }
}

二叉树的操作类

public class BinaryTree {
    // 创建一颗二叉树
    public BTNode createBinaryTree(BTNode T) {

        char op = 0;
        Scanner sc = new Scanner(System.in);

        System.out.print("please enter the data:");
        char value;
        value = sc.next().charAt(0);
        T.setValue(value);

        if (T.value == ' ') {
            T.Lchild = null;
            T.Rchild = null;
        } else {
            // 左子树
            System.out.print("Does " + T.value + " have Lchild?(Y|N)");
            op = sc.next().charAt(0);
            // 防止输入y、Y、n、N以外的其他字符
            while (op != 'y' && op != 'Y' && op != 'n' && op != 'N') {
                System.out.println("error\nplease enter again");
                op = sc.next().charAt(0);
            }

            if (op == 'y' || op == 'Y') {
                T.Lchild = new BTNode();
                createBinaryTree(T.Lchild);//递归调用
            } else {
                T.Lchild = null;
            }
            // 右子树
            System.out.print("Does " + T.value + " have Rchild?(Y|N)");
            op = sc.next().charAt(0);
            // 防止输入y、Y、n、N以外的其他字符
            while (op != 'y' && op != 'Y' && op != 'n' && op != 'N') {
                System.out.println("error\nplease enter again");
                op = sc.next().charAt(0);
            }

            if (op == 'y' || op == 'Y') {
                T.Rchild = new BTNode();
                createBinaryTree(T.Rchild);
            } else {
                T.Rchild = null;
            }
        }

        return T;
    }

    // 求二叉树的深度
    public int depth(BTNode T) {
        int Rdepth = 0;//右子树的深度
        int Ldepth = 0;//左子树的深度

        if(T.Lchild != null){
            Ldepth = depth(T.Lchild);
        }
        if(T.Rchild != null){
            Rdepth = depth(T.Rchild);
        }
        return Rdepth > Ldepth ? Rdepth + 1 : Ldepth + 1;
    }

    // 求二叉树中节点的个数
    public int nodeNumber(BTNode T) {
        int Lchildnum = 0;//左子树节点的个数
        int Rchildnum = 0;//右子树节点的个数

        if(T.Lchild != null){
            Lchildnum = nodeNumber(T.Lchild);
        }
        if(T.Rchild != null){
            Rchildnum = nodeNumber(T.Rchild);
        }

        //返回每个节点的左右节点个数加上本身
        return Lchildnum + Rchildnum + 1;
    }

    //求叶子节点个数
    public int leafChild(BTNode T){
        int Lchildnum = 0;//左子树叶子节点个数
        int Rchildnum = 0;//右子树叶子节点个数

        if(T.Lchild != null)
            Lchildnum = leafChild(T.Lchild);
        if(T.Rchild != null)
            Rchildnum = leafChild(T.Rchild);

        //若是叶子节点，返回本身
        if(T.Lchild == null && T.Rchild == null)
            return 1;
        //若不是叶子节点 返回每个结点的左子树的叶子节点加上右子树的叶子节点
        else
            return Lchildnum + Rchildnum;
    }

    // 先序遍历
    public void preOrderTraverse(BTNode T) {
        if (T != null) {
            System.out.print(T.value);
            preOrderTraverse(T.Lchild);
            preOrderTraverse(T.Rchild);
        }
    }

    // 中序遍历
    public void inOrderTraverse(BTNode T) {
        if (T != null) {
            inOrderTraverse(T.Lchild);
            System.out.print(T.value);
            inOrderTraverse(T.Rchild);
        }
    }
    // 后序遍历
    public void postOrderTraverse(BTNode T){
        if(T != null){
            postOrderTraverse(T.Lchild);
            postOrderTraverse(T.Rchild);
            System.out.print(T.value);
        }
    }

    // 输出二叉树
    public void print(BTNode T) {
        System.out.println(T);
    }
}

主方法

public static void main(String[] args) {
        BinaryTree bt = new BinaryTree();
        BTNode T = new BTNode();

        bt.createBinaryTree(T);

        System.out.print("先序遍历：");
        bt.preOrderTraverse(T);
        System.out.println();

        System.out.print("中序遍历：");
        bt.inOrderTraverse(T);
        System.out.println();

        System.out.print("后序遍历：");
        bt.postOrderTraverse(T);
        System.out.println();

        System.out.println("结点个数：" + bt.nodeNumber(T));
        System.out.println("二叉树的深度：" + bt.depth(T));
        System.out.println("叶子结点的个数：" + bt.leafChild(T));
    }

以两个例子运行程序：
NO.1
这里写图片描述
运行结果：
这里写图片描述
NO.2
这里写图片描述
运行结果：
这里写图片描述

C++ 二叉树的基本操作
nichengwuxiao的博客
12-22 1万+
一：目的 用C++实现二叉树的基本操作，建立和遍历； 二：介绍 在计算机科学中，二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。 二叉树的遍历方式有三种，前序遍历，中序遍历，后序遍历。 它的前序遍历顺序为：ABDGHCEIF（规则是先是
二叉树的构建
li123128的博客
11-10 3626
二叉树是一种非常重要的数据结构。本文总结了二叉树的常见操作：二叉树的构建，查找，删除，二叉树的遍历(包括前序遍历、中序遍历、后序遍历、层次遍历)，二叉搜索树的构造等。
二叉树基本操作
青耕_的博客
02-17 1892
二叉树的先序，中序，后序遍历的递归与非递归，二叉排序树的建立，添加，删除，满二叉树，完全二叉树的判断
二叉树的基本操作（递归和非递归遍历，分支节点数）
小熊的学习记录
12-16 2073
二叉树的定义: 二叉树是由n(n>=0)个结点的有限集合构成，此集合或者为空集，或者由一个根结点及两棵互不相交的左右子树组成，并且左右子树都是二叉树. 递归定义:叉树可以是空集合，根可以有空的左子树或空的右子树。二叉树不是树的特殊情况，它们是两个概念。 typedef char ElemType; typedef struct BiTNode{ ElemType data; ...
二叉树的类型定义与基本操作
qq_45801780的博客
10-29 5459
二叉树的类型定义与基本操作 树结构是一类重要的非线性数据结构，在客观世界中广泛存在。树在计算机领域中也得到了广泛的应用，尤以二叉树最为常用。本文重点讨论二叉树的基本操作。 1. 二叉树的类型定义 二叉树通常由三个域组成：数据域、左孩子指针域和右孩子指针域。 其类型定义为： typedef struct BiNode { char data; // 数据域 struct BiNode* lchild, * rchild; // 左右孩子指针域 }Bi
二叉树的使用方法
qq_30534935的博客
02-11 1478
转载： http://blog.jobbole.com/108184/ https://blog.csdn.net/zhanggonglalala/article/details/79738213 https://blog.csdn.net/heyanxi0101/article/details/79593542 一、概述 平衡树：所有结点左右子树深度差≤1 排序树：所有结点“左小右大 字典树：由...
二叉树的基本操作——数据结构实验报告
热门推荐
qq_40878980的博客
12-03 5万+
一、实验名称：二叉树 二、实验目的 1）熟练掌握二叉树的存储方式的具体实现过程，实现二叉树的基本操作及运算； 2）进一步巩固指针的用法，栈及队列的基本操作，进一步体会递归算法，学会综合应用。 三、实验要求 使用链式存储结构实现二叉树的存储； 运用递归及非递归实现二叉树的三种顺序遍历，及层次遍历； 运用递归实现二叉树中结点，深度的计算和二叉树的复制相关操作； 将所有相关操作整合成一个...
二叉树的基本操作（共21个）
CXR_XC的博客
11-04 1万+
简单介绍二叉树，并给出二叉树的21种基本操作
【数据结构】二叉树的存储与基本操作的实现
m0_71731682的博客
08-30 4176
二叉树的存储结构分为：顺序存储和类似于链表的链式存储这里博主讲一下链式存储二叉树的链式存储是通过一个一个的节点引用起来的，常见的表示方式有二叉和三叉表示方式二叉表示： 三叉表示： 这里博主主要讲解一下孩子表示法在学习二叉树的基本操作前，需先要创建一棵二叉树，然后才能学习其相关的基本操作。由于现在大家对二叉树结构掌握还不够深入，为了降低大家学习成本，此处手动快速创建一棵简单的二叉树。 创建如下： 注意：上述代码并不是创建二叉树的方式，真正创建二叉树方式后序详解重点讲解在我们对二叉树进行基本操作之前，我们的先来
实验五 二叉树基本操作的编程实现
Htw18705081160的博客
04-13 1572
二叉树基本操作的编程实现（2学时，验证型），掌握二叉树的建立、遍历、插入、删除等基本操作的编程实现，也可以进一步编程实现查找等操作，存储结构主要采用顺序或链接结构。二叉树由根节点、左子树和右子树组成，而左子树和右子树也是一棵二叉树，它们的定义与原二叉树的定义相同，因此可以使用递归的方式来定义二叉树。=',') //输入数据不为逗号,表示不为虚结点,否则为虚结点。case 3:printf("二叉树中序遍历结果为：\n");case 4:printf("二叉树后序遍历结果为：\n");
二叉树的基本操作　C++代码实现
Tanswer_
10-29 1万+
首先定义节点typedef struct BTree { int value; struct BTree *lchild; struct BTree *rchild; }BTree;前序递归建立二叉树/* **num 前序序列 **index 下标 */ BTree *CreateBTree(BTree *node,int *num,int& index) {
Java 实现二叉树的基本操作
最新发布
LL_break的博客
05-12 1015
聚焦二叉树基本操作，包括获取节点数、叶子节点数、第K层节点数、树的深度、检测特定值是否存在以及判断是否为完全二叉树。代码，图解相结合帮助理解 整条街都是恋爱的人    我独自走在暖风的夜 ——寂寞的季节 DT
四、二叉树基本操作
kt_su的博客
09-06 631
有一个特殊的节点：根节点，根节点没有前驱节点。除根节点外，其余节点被分成 M（M > 0）个互不相交的集合，其中每一个集合又是一颗与树类似的子树。树是递归定义的。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值