二叉树

文章目录

二叉树
- 背景
- 二叉树的概念
- 遍历方式
- 代码实现

背景

数组存储方式的分析

优点：通过下标方式访问元素，速度快。对于有序数组，还可使用二分查找提高检索速度。

缺点：如果要检索具体某个值，或者插入值(按一定顺序)会整体移动，效率较低

链式存储方式的分析

优点：在一定程度上对数组存储方式有优化(比如：插入一个数值节点，只需要将插入节点，链接到链表中即可，删除效率也很好)。

缺点：在进行检索时，效率仍然较低，比如(检索某个值，需要从头节点开始遍历)

树存储方式的分析

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

知道数的优点那么就得知道树的常用术语有哪些

在这里插入图片描述

二叉树的概念

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

2.二叉树的子节点分为左节点和右节点。

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

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

例如下图：

在这里插入图片描述

遍历方式

二叉树有三种遍历方式

分别为前序遍历，中序遍历，后序遍历

前序遍历：先输出父节点，再遍历左子树和右子树

中序遍历：先遍历左子树，再输出父节点，再遍历右子树

后序遍历：先遍历左子树，再遍历右子树，最后输出父节点

小结: 看输出父节点的顺序，就确定是前序，中序还是后序

代码实现

节点类

package com.datestructures.tree;


public 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 HeroNode preOrderSearch(int no) {
        System.out.println("进入前序遍历查找");
        //先判断当前节点是否为目标值
        if (this.no == no) {
            return this;
        }
        //定义一个res来接收结果
        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 void infixOrder() {
        //向左递归
        if (this.left != null) {
            this.left.infixOrder();
        }
        //输出当前节点
        System.out.println(this);
        //向右递归
        if (this.right != null) {
            this.right.infixOrder();
        }
    }

    //中序遍历查找
    public HeroNode infixOrderSearch(int no) {
        //定义一个结果来存放结果
        HeroNode resNode = null;
        //先判断左子节点是否为空
        if (this.left != null) {
            resNode = this.left.infixOrderSearch(no);
        }
        //如果resNode不为空，表明找到 返回即可
        if (resNode != null) {
            return resNode;
        }
        System.out.println("进入中序遍历查找");
        //为空  就和当前节点比较
        if (this.no == no) {
            return this;
        }
        //当前节点不是目标值 则向右查找
        if (this.right != null) {
            resNode = this.right.infixOrderSearch(no);
        }
        //最后返回
        return resNode;
    }

    //后序遍历
    public void postOrder() {
        //向左递归
        if (this.left != null) {
            this.left.postOrder();
        }
        //向右递归
        if (this.right != null) {
            this.right.postOrder();
        }
        //输出当前节点
        System.out.println(this);
    }

    //后序遍历查找
    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.postOrderSearch(no);
        }
        //如果不为空 说明找到  返回即可
        if (resNode != null) {
            return resNode;
        }
        System.out.println("进入后序遍历查找");
        //否则和当前节点对比
        if (this.no == no) {
            return this;
        }
        return resNode;
    }
    //删除节点
    public void delNode(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.delNode(no);
        }
        //向右递归  进行删除
        if(this.right!=null){
            this.right.delNode(no);
        }
    }
}

二叉树类

package com.datestructures.tree;

public 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 HeroNode preOrder(int no){
        if(root!=null){
            return this.root.preOrderSearch(no);
        }else{
            return null;
        }
    }
    //中序遍历
    public void infixOrder(){
        if(this.root!=null){
            this.root.infixOrder();
        }else{
            System.out.println("二叉树为空，不能遍历");
        }
    }
    //中序遍历查找
    public HeroNode infixOrderSearch(int no){
        if(root!=null){
            return this.root.infixOrderSearch(no);
        }else{
            return null;
        }
    }
    //后序遍历
    public void postOrder(){
        if(this.root!=null){
            this.root.postOrder();
        }else{
            System.out.println("二叉树为空，不能遍历");
        }
    }
    //后序遍历查找
    public HeroNode postOrderSearch(int no){
        if(root!=null){
            return this.root.postOrderSearch(no);
        }else{
            return null;
        }
    }
    //删除节点
    public void delNode(int no){
        if(root!=null){
            //如果只有一个节点，先判断这个节点是不是要删除的节点
            if(root.getNo()==no){
                root=null;
            }else {
                //递归删除
                root.delNode(no);
            }
        }else{
            System.out.println("空树，不能删除");
        }
    }
}

测试类

package com.datestructures.tree;

public class BinaryTreeDemo {
    public static void main(String[] args) {
        //先创建一个二叉树
        BinaryTree binaryTree =new BinaryTree();
        //再创建四个节点
        HeroNode root = new HeroNode(1,"宋江");
        HeroNode hero2 = new HeroNode(2,"吴用");
        HeroNode hero3 = new HeroNode(3,"卢俊义");
        HeroNode hero4 = new HeroNode(4,"林冲");
        HeroNode hero5 = new HeroNode(5,"关胜");
        //再将几个节点关联起来
        root.setLeft(hero2);
        root.setRight(hero3);
        hero3.setRight(hero4);
        hero3.setLeft(hero5);
        //再将根节点赋予到树上
        binaryTree.setRoot(root);
        System.out.println("前序遍历");
        binaryTree.preOrder();//1 2 3 5 4
        System.out.println("中序遍历");// 2 1 5 3 4
        binaryTree.infixOrder();
        System.out.println("后序遍历");// 2 5 4 3 1
        binaryTree.postOrder();

        System.out.println("前序遍历方式");
        HeroNode resNode1 = binaryTree.preOrder(5);
        if(resNode1!=null){
            System.out.println("找到了，信息为 no = "+resNode1.getNo()+"  name = "+resNode1.getName());
        }else{
            System.out.println("没有找到编号为"+5+"的英雄");
        }
        System.out.println("中序遍历方式");
        HeroNode resNode2 = binaryTree.infixOrderSearch(5);
        if(resNode2!=null){
            System.out.println("找到了，信息为 no = "+resNode2.getNo()+"  name = "+resNode2.getName());
        }else{
            System.out.println("没有找到编号为"+5+"的英雄");
        }
        System.out.println("后序遍历方式");
        HeroNode resNode3 = binaryTree.postOrderSearch(5);
        if(resNode3!=null){
            System.out.println("找到了，信息为 no = "+resNode3.getNo()+"  name = "+resNode3.getName());
        }else{
            System.out.println("没有找到编号为"+5+"的英雄");
        }

        //删除测试
        System.out.println("删除前先遍历");
        binaryTree.postOrder();
        binaryTree.delNode(5);
        //binaryTree.delNode(3);
        System.out.println("删除后遍历");
        binaryTree.postOrder();
    }
}