简单二叉树

于 2021-03-23 13:33:50 发布
阅读量271 收藏
点赞数
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43956763/article/details/115119392
版权

二叉树（一）

一、二叉树的概述

1.1 为什么需要树这样的数据结构

在前面已经学习了数组和链表这两种数据结构，这两种数据结构都有着鲜明的特点

数组存储方式的分析：

  1. 优点：通过下标方式访问元素，速度快。对于有序数组，还可使用二分查找提高检索速度。
  2. 缺点：如果要检索具体某个值，或者插入值(按一定顺序)会整体移动，效率较低

链式存储方式的分析：

  1. 优点：在一定程度上对数组存储方式有优化(比如：插入一个数值节点，只需要将插入节点，链接到链表中即可， 删除效率也很好)。
  2. 缺点：在进行检索时，效率仍然较低，比如(检索某个值，需要从头节点开始遍历)

树存储方式的分析：

能提高数据存储，读取的效率, 比如利用 二叉排序树(Binary Sort Tree)，既可以保证数据的检索速度，同时也可以保证数据的插入，删除，修改的速度。

从它们的特点我们可以总结出：数组方式查找快、增删慢，而链表方式查找慢、增删快。而树这种数据结构，可以在查找速度快的同时又兼顾了增删的效率，可以说是结合了数组和链表的优点。

在这里插入图片描述

树的常用术语
在这里插入图片描述
这些常用术语包括：

  1. 节点
  2. 根节点
  3. 父节点
  4. 子节点
  5. 叶子节点（没有子节点的节点）
  6. 节点的权（节点值）
  7. 路径（从 root 节点找到该节点的路线）
  8. 层
  9. 子树
  10. 树的高度（最大层数）
  11. 森林（多颗子树构成森林）

1.2 什么是二叉树

  1. 树有很多种，每个节点最多只能有两个子节点的一种形式称为二叉树。
  2. 二叉树的子节点分为左节点和右节点。

在这里插入图片描述

  1. 如果该二叉树的所有叶子节点都在最后一层，并且结点总数= 2^n -1 , n 为层数，则我们称为满二叉树。

在这里插入图片描述

  1. 如果该二叉树的所有叶子节点都在最后一层或者倒数第二层，而且最后一层的叶子节点在左边连续，倒数第二层的叶子节点在右边连续，我们称为完全二叉树。

在这里插入图片描述

1.3 二叉树遍历的概述

二叉树的遍历共有三种情况：

  • 前序遍历: 先输出父节点，再遍历左子树和右子树
  • 中序遍历: 先遍历左子树，再输出父节点，再遍历右子树
  • 后序遍历: 先遍历左子树，再遍历右子树，最后输出父节点

二、二叉树的基本操作

2.1 二叉树的遍历

案例需求：

对二叉树进行前序、中序、后序的遍历

实现步骤：

其中前序遍历的思路如下：

  1. 首先输出当前节点；
  2. 如果左子节点不为空，就对左子节点递归前序遍历；
  3. 如果右子节点不为空，就对右子节点递归前序遍历。

中序遍历的思路如下：

  1. 首先判断左子节点是否为空，如果不为空，就对左子节点递归中序遍历；
  2. 然后输出当前节点；
  3. 最后判断右子节点是否为空，如果不为空，就对右子节点递归中序遍历。

后序遍历的思路如下：

  1. 首先判断左子节点是否为空，如果不为空，就对左子节点递归后序遍历；
  2. 然后判断右子节点是否为空，如果不为空，就对右子节点递归后序遍历；
  3. 最后输出当前节点。

代码实现：

package tree;

public class BinaryTreeDemo {
    public static void main(String[] args) {
        //创建一颗二叉树
        binaryTree binaryTree = new binaryTree();
        //创建需要的节点
        HeroNode node1 = new HeroNode(1, "宋江");
        HeroNode node2 = new HeroNode(2, "吴用");
        HeroNode node3 = new HeroNode(3, "卢俊义");
        HeroNode node4 = new HeroNode(4, "林冲");
        HeroNode node5 = new HeroNode(5, "武松");

        node1.setLeft(node2);
        node1.setRight(node3);
        node2.setRight(node4);
        node3.setRight(node5);
        binaryTree.setRoot(node1);

        System.out.println("前序遍历");
        binaryTree.preOrder();
        System.out.println("============================");
        System.out.println("中序遍历");
        binaryTree.infixOrder();
        System.out.println("============================");
        System.out.println("后序遍历");
        binaryTree.postOrder();
    }
}

//定义一个二叉树
class binaryTree{
    private HeroNode root;

    public void setRoot(HeroNode root) {
        this.root = root;
    }
    //前序遍历
    public void preOrder(){
        if(this.root != null){
            this.root.preOrder();
        }else{
            System.out.println("二叉树为空，无法遍历");
        }
    }
    //中序遍历
    public void infixOrder(){
        if(this.root != null){
            this.root.infixOrder();
        }else{
            System.out.println("二叉树为空，无法遍历");
        }
    }
    //后序遍历
    public void postOrder(){
        if(this.root != null){
            this.root.postOrder();
        }else{
            System.out.println("二叉树为空，无法遍历时");
        }
    }
}

class HeroNode{
    private int no;
    private String name;
    private HeroNode left;
    private HeroNode right;

    public HeroNode(int no, String name) {
        this.no = no;
        this.name = name;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public HeroNode getLeft() {
        return left;
    }

    public void setLeft(HeroNode left) {
        this.left = left;
    }

    public HeroNode getRight() {
        return right;
    }

    public void setRight(HeroNode right) {
        this.right = right;
    }

    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                '}';
    }

    //编写前序遍历的方法
    public void preOrder(){
        System.out.println(this);//输出父节点
        //递归向左子树
        if(this.left != null){
            this.left.preOrder();
        }
        //递归向右子树程序遍历
        if(this.right != null){
            this.right.preOrder();
        }
    }
    //中序遍历
    public void infixOrder(){
        if(this.left != null){
            this.left.infixOrder();
        }
        //输出父节点
        System.out.println(this);
        //递归向右子树中序遍历
        if(this.right != null){
            this.right.infixOrder();
        }
    }
    //后序遍历
    public void postOrder(){
        if(this.left != null){
            this.left.postOrder();
        }
        //递归向右子树中序遍历
        if(this.right != null){
            this.right.postOrder();
        }
        System.out.println(this);
    }
}

输出结果：
在这里插入图片描述

2.2 二叉树的查找

案例要求：

  1. 请编写前序查找，中序查找和后序查找的方法。
  2. 并分别使用三种查找方式，查找 heroNO = 5 的节点
  3. 并分析各种查找方式，分别比较了多少次

实现步骤：

前序查找思路：

  1. 首先判断当前节点的编号是否等于指定编号
  2. 如果相等，则直接返回当前节点；
  3. 如果不相等，再判断左子节点是否为空，如果不为空则左子节点递归前序查找；
  4. 如果左子节点递归前序查找找到了节点，则返回节点；
  5. 否则，继续判断右子节点是否为空，如果不为空则对右子节点递归前序查找；
  6. 如果找到则返回节点，否则返回 NULL。

中序查找思路：

  1. 首先判断判断左子节点是否为空，如果不为空则左子节点递归中序查找；
  2. 如果左子节点递归中序查找找到了节点，则返回节点；
  3. 否则，判断当前节点是否等于指定节点，如果相等，则直接返回当前节点；
  4. 否则，继续判断右子节点是否为空，如果不为空则对右子节点递归中序查找；
  5. 如果找到则返回节点，否则返回 NULL。

后序查找思路：

  1. 首先判断判断左子节点是否为空，如果不为空则左子节点递归后序查找；
  2. 如果左子节点递归后序查找找到了节点，则返回节点；
  3. 否则，继续判断右子节点是否为空，如果不为空则对右子节点递归后序查找；
  4. 如果右子节点递归后序查找找到了节点，则返回节点；
  5. 否则，判断当前节点的编号是否等于指定编号。如果相等，则直接返回当前节点，否则，返回 NULL。

代码实现：

前序、中序、后序查找的代码实现

//定义一个二叉树
class binaryTree{
    private HeroNode root;

    public void setRoot(HeroNode root) {
        this.root = root;
    }

    //前序查找
    public void preOrderSearch(int no){
        if(root != null){
            HeroNode res = root.preOrderSearch(no);
            if(res != null){
                System.out.println(res);
            }
        }else{
            System.out.println("未找到该节点");
        }
    }

    public void infixOederSearch(int no){
        if(root != null){
            HeroNode res = root.infixOrderSearch(no);
            if(res != null){
                System.out.println(res);
            }
        }else{
            System.out.println("未找到该节点");
        }
    }

    public void postOederSearch(int no){
        if(root != null){
            HeroNode res = root.postOrderSearch(no);
            if(res != null){
                System.out.println(res);
            }
        }else{
            System.out.println("未找到该节点");
        }
    }
}

class HeroNode {
    private int no;
    private String name;
    private HeroNode left;
    private HeroNode right;

    public HeroNode(int no, String name) {
        this.no = no;
        this.name = name;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public HeroNode getLeft() {
        return left;
    }

    public void setLeft(HeroNode left) {
        this.left = left;
    }

    public HeroNode getRight() {
        return right;
    }

    public void setRight(HeroNode right) {
        this.right = right;
    }

    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                '}';
    }

    //前序查找
    public HeroNode preOrderSearch(int no) {
        if (this.no == no) {
            return this;
        } else {
            //1.判断当前节点的左子节点是否为空，如果不为空，则递归前序查找
            //2.如果左递归前序查找，找到节点，则返回
            HeroNode resNode = null;
            if (this.left != null) {
                resNode = this.left.preOrderSearch(no);
            }
            if (resNode != null) {//说明左子树找到
                return resNode;
            }
            if (this.right != null) {
                resNode = this.right.preOrderSearch(no);
            }
            return resNode;

        }
    }
    //中序查找
    public HeroNode infixOrderSearch(int no) {
        HeroNode resNode = null;
        if (this.left != null) {
            resNode = this.left.infixOrderSearch(no);
        }
        if (resNode != null) {
            return resNode;
        }
        if (this.no == no) {
            return this;
        }
        if (this.right != null) {
            resNode = this.right.infixOrderSearch(no);
        }
        return resNode;
    }

    //后序查找
    public HeroNode postOrderSearch(int no) {
        HeroNode resNode = null;
        if (this.left != null) {
            resNode = this.left.postOrderSearch(no);
        }
        if (resNode != null) {
            return resNode;
        }
        if (this.right != null) {
            resNode = this.right.infixOrderSearch(no);
        }
        if (resNode != null) {
            return resNode;
        }
        if (this.no == no) {
            return this;
        }
        return resNode;
    }
}

2.3 二叉树删除节点

实现要求：

  1. 如果删除的节点为叶子节点，直接删除；
  2. 如果节点为父节点，则把节点和节点的整个子树都删除。

思路分析：

除了二叉树的根节点之外，其余的节点都是有父节点的。由于二叉树的每个节点关系都是单向的，所以我们要判断当前节点的子节点是否是需要删除的节点，而不能判断当前节点是不是需要删除的节点

  1. 如果当前节点的左子节点不为空，并且就是需要删除的节点，那么直接置空this.left = null，结束递归
  2. 如果当前节点的右子节点不为空，并且就是需要删除的节点，那么直接置空this.right = null，结束递归
  3. 如果第一步和第二步都没有删除节点，那么就判断左子树是否为空，然后向左子树递归删除
  4. 如果第四步都没有删除节点，那么就判断右子树是否为空，然后向右子树递归删除

实现代码：

//定义一个二叉树
class binaryTree {
    private HeroNode root;
    
    public void setRoot(HeroNode root) {
        this.root = root;
    }

    //删除节点
    public void delete(int no){
        if(root != null){
            if(root.getNo() == no){
                root = null;
            }else{
                root.delete(no);
            }
        }else{
            System.out.println("该树为空，无法删除");
        }
    }
}

class HeroNode {
    private int no;
    private String name;
    private HeroNode left;
    private HeroNode right;

    public HeroNode(int no, String name) {
        this.no = no;
        this.name = name;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public HeroNode getLeft() {
        return left;
    }

    public void setLeft(HeroNode left) {
        this.left = left;
    }

    public HeroNode getRight() {
        return right;
    }

    public void setRight(HeroNode right) {
        this.right = right;
    }

    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                '}';
    }

    //删除节点
    public void delete(int no) {
        if (this.left != null && this.left.no == no) {
            this.left = null;
            return;
        }
        if (this.right != null && this.right.no == no) {
            this.right = null;
            return;
        }
        if (this.left != null) {
            this.left.delete(no);
        }
        if (this.right != null) {
            this.right.delete(no);
        }
    }
}

运行结果：
在这里插入图片描述

VaingloryYS
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值