树

最新推荐文章于 2022-04-01 21:43:15 发布
最新推荐文章于 2022-04-01 21:43:15 发布
阅读量219 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41965731/article/details/109020496
版权

根据尚硅谷的韩顺平老师的数据结构视频总结的笔记

观看视频的网址

 

一、二叉树

1、为什么需要树这种数据结构

1）数组存储方式的分析

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

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

2）链式存储方式的分析

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

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

3）树存储方式的分析

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

 

2、二叉树的示意图

树的常用术语(结合示意图理解):
1）节点
2）根节点
3）父节点
4）子节点
5）叶子节点 (没有子节点的节点)
6）节点的权(节点值)
7）路径(从root节点找到该节点的路线)
8）层
9）子树
10）树的高度(最大层数)
11）森林 :多颗子树构成森林

 

3、二叉树的概念

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

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

 

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

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

 

二、二叉树的遍历

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

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

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

 

代码实现：

    //前序遍历     中前后
    public void preTraverse(){
        System.out.println(this);
        if(this.left != null)
            this.left.preTraverse();
        if(this.right != null)
            this.right.preTraverse();
    }

    //中序遍历     前中后
    public void midTraverse(){
        if(this.left != null)
            this.left.midTraverse();
        System.out.println(this);
        if(this.right != null)
            this.right.midTraverse();
    }

    //后序遍历     后中前
    public void afterTraverse(){
        if(this.right != null)
            this.right.afterTraverse();
        System.out.println(this);
        if(this.left != null)
            this.left.afterTraverse();
    }

 

三、二叉树的查找

    //前序遍历查找
    public HeroNode preTraverseSearch(int no){
        HeroNode node = null;
        if(this.no == no)
            return this;
        if(this.left != null)
            node = this.left.preTraverseSearch(no);
        if(node != null)
            return node;
        if(this.right != null)
            node = this.right.preTraverseSearch(no);
        return node;
    }

    //中序遍历查找
    public HeroNode midTraverseSearch(int no){
        HeroNode node = null;
        if(this.left != null) {
            node = this.left.midTraverseSearch(no);
        }
        if(node != null) {
            return node;
        }
        if(this.no == no)
            return this;
        if(this.right != null)
            node = this.right.midTraverseSearch(no);
        return node;
    }

    //后序遍历查找
    public HeroNode afterTraverseSearch(int no){
        HeroNode node = null;
        if(this.left != null)
            node = this.left.preTraverseSearch(no);
        if(this.right != null)
            node = this.right.preTraverseSearch(no);
        if(this.no == no)
            return this;
        return node;
    }

 

四、二叉树的删除

 

    //删除节点
    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);
    }
}


思考题(课后练习)

如果要删除的节点是非叶子节点，现在我们不希望将该非叶子节点为根节点的子树删除，需要指定规则, 假如规定如下:
如果该非叶子节点A只有一个子节点B，则子节点B替代节点A
如果该非叶子节点A有左子节点B和右子节点C，则让左子节点B替代节点A

 

    public void delete2(int no){
        HeroNode temp;
        //如果左子节点是要删除的节点
        if (this.left != null && this.left.no == no) {
            //左子节点只有左子树
            if(this.left.left != null && this.left.right == null) {
                this.left = this.left.left;
                return;
            }
            //左子节点只有右子树
            else if(this.left.left == null && this.left.right != null) {
                this.left = this.left.right;
                return;
            }
            //左子节点是叶子节点
            else if(this.left.left == null && this.left.right == null) {
                this.left = null;
                return;
            }
            //左子节点有左右子节点
            else if(this.left.left != null && this.left.right != null) {
                temp = this.left.left;
                while (temp.right!=null){
                    temp = temp.right;
                }
                temp.right = this.left.right;
                this.left = this.left.left;
                return;
            }
        }

        //如果右子节点是要删除的节点
        if (this.right != null && this.right.no == no) {
            //右子节点只有左子树
            if(this.right.left != null && this.right.right == null) {
                this.right = this.right.left;
                return;
            }
            //右子节点只有右子树
            else if(this.right.left == null && this.right.right != null) {
                this.right = this.right.right;
                return;
            }
            //右子节点是叶子节点
            else if(this.right.left == null && this.right.right == null) {
                this.right = null;
                return;
            }
            //右子节点有左右子节点
            else if(this.right.left != null && this.right.right != null) {
                temp = this.right.left;
                while (temp.right!=null){
                    temp = temp.right;
                }
                temp.right = this.right.right;
                this.right = this.right.left;
                return;
            }
        }

        if (this.left != null)
            this.left.delete(no);
        if(this.right != null)
            this.right.delete(no);
    }


二叉树的全部完整代码：

package tree;

/**
 * @description: 二叉树
 * @auther:田坤
 * @date 2020/10/12 6:43
 **/
public class BinaryTreeDemo {
    public static void main(String[] args) {
        //手动创建一个树
        HeroNode hero1 = new HeroNode(1, "宋江");
        HeroNode hero2 = new HeroNode(2, "卢俊义");
        HeroNode hero3 = new HeroNode(3, "吴用");
        HeroNode hero4 = new HeroNode(4, "公孙胜");
        HeroNode hero5 = new HeroNode(5, "关胜");
        HeroNode hero6 = new HeroNode(6, "林冲");
        HeroNode hero7 = new HeroNode(7, "秦明");
        HeroNode hero8 = new HeroNode(8, "呼延灼");
        HeroNode hero9 = new HeroNode(9, "花荣");
        HeroNode hero10 = new HeroNode(10, "柴进");

        hero5.setLeft(hero7);
        hero5.setRight(hero8);
        hero4.setLeft(hero9);
        hero4.setRight(hero10);
        hero3.setLeft(hero5);
        hero3.setRight(hero4);
        hero2.setLeft(hero6);
        hero1.setLeft(hero2);
        hero1.setRight(hero3);

        BinaryTree binaryTree = new BinaryTree();
        binaryTree.setRoot(hero1);
        System.out.println("前序遍历");
        binaryTree.preTraverse();
        binaryTree.delete2(3);
        System.out.println("删除后");
        binaryTree.preTraverse();
/*        System.out.println("中序遍历");
        binaryTree.midTraverse();
        System.out.println("后序遍历");
        binaryTree.afterTraverse();

        //前序遍历查找
        binaryTree.preTraverseSearch(2);
        //中序遍历查找
        binaryTree.midTraverseSearch(3);
        //后序遍历查找
        binaryTree.afterTraverseSearch(4);

        //删除
        binaryTree.delete(3);
        binaryTree.preTraverse();*/
    }
}

//二叉树
class BinaryTree {
    private HeroNode root;

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

    //前序遍历
    public void preTraverse() {
        if (root == null)
            System.out.println("树为空，无法遍历！");
        else
            root.preTraverse();
    }

    //中序遍历
    public void midTraverse() {
        if (root == null)
            System.out.println("树为空，无法遍历！");
        else
            root.midTraverse();
    }

    //后序遍历
    public void afterTraverse() {
        if (root == null)
            System.out.println("树为空，无法遍历！");
        else
            root.afterTraverse();
    }

    //前序遍历查找
    public void preTraverseSearch(int no) {
        if (root == null)
            System.out.println("树为空，查找不到！");
        else {
            HeroNode heroNode = root.preTraverseSearch(no);
            if (heroNode == null)
                System.out.println("没有查找到编号为" + no + "的英雄");
            else
                System.out.println("编号为" + no + "的英雄信息为：" + heroNode.toString());
        }
    }

    //中序遍历查找
    public void midTraverseSearch(int no) {
        if (root == null)
            System.out.println("树为空，查找不到！");
        else {
            HeroNode heroNode = root.preTraverseSearch(no);
            if (heroNode == null)
                System.out.println("没有查找到编号为" + no + "的英雄");
            else
                System.out.println("编号为" + no + "的英雄信息为：" + heroNode.toString());
        }
    }

    //后序遍历查找
    public void afterTraverseSearch(int no) {
        if (root == null)
            System.out.println("树为空，查找不到！");
        else {
            HeroNode heroNode = root.preTraverseSearch(no);
            if (heroNode == null)
                System.out.println("没有查找到编号为" + no + "的英雄");
            else
                System.out.println("编号为" + no + "的英雄信息为：" + heroNode.toString());
        }
    }

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

    //删除节点2
    public void delete2(int no){
        HeroNode temp;
        if(root == null)
            System.out.println("树为空，无法删除");
        else {
            //判断根节点是不是要删除的节点
            if(root.getNo() == no){
                //根节点有左右子节点
                if(root.getLeft()!=null && root.getRight()!=null){
                    temp = root.getLeft();
                    while (temp.getRight()!=null){
                        temp = temp.getRight();
                    }
                    temp.setRight(root.getRight());
                    root = root.getLeft();
                }
                //根节点只有左子树
               else if(root.getLeft() != null && root.getRight()==null)
                    root = root.getLeft();
                //根节点是叶子节点
                else if(root.getLeft() == null && root.getRight() == null)
                    root = null;
                else //根节点只有左子树
                    root = root.getRight();
            }
            else
                root.delete2(no);
        }
    }


}

//英雄类
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 preTraverse() {
        System.out.println(this);
        if (this.left != null)
            this.left.preTraverse();
        if (this.right != null)
            this.right.preTraverse();
    }

    //中序遍历     前中后
    public void midTraverse() {
        if (this.left != null)
            this.left.midTraverse();
        System.out.println(this);
        if (this.right != null)
            this.right.midTraverse();
    }

    //后序遍历     后中前
    public void afterTraverse() {
        if (this.right != null)
            this.right.afterTraverse();
        System.out.println(this);
        if (this.left != null)
            this.left.afterTraverse();
    }

    //前序遍历查找
    public HeroNode preTraverseSearch(int no) {
        HeroNode node = null;
        if (this.no == no)
            return this;
        if (this.left != null)
            node = this.left.preTraverseSearch(no);
        if (node != null)
            return node;
        if (this.right != null)
            node = this.right.preTraverseSearch(no);
        return node;
    }

    //中序遍历查找
    public HeroNode midTraverseSearch(int no) {
        HeroNode node = null;
        if (this.left != null) {
            node = this.left.midTraverseSearch(no);
        }
        if (node != null) {
            return node;
        }
        if (this.no == no)
            return this;
        if (this.right != null)
            node = this.right.midTraverseSearch(no);
        return node;
    }

    //后序遍历查找
    public HeroNode afterTraverseSearch(int no) {
        HeroNode node = null;
        if (this.left != null)
            node = this.left.preTraverseSearch(no);
        if (this.right != null)
            node = this.right.preTraverseSearch(no);
        if (this.no == no)
            return this;
        return node;
    }

    //删除节点
    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);
    }

    //删除2
    public void delete2(int no){
        HeroNode temp;
        //如果左子节点是要删除的节点
        if (this.left != null && this.left.no == no) {
            //左子节点只有左子树
            if(this.left.left != null && this.left.right == null) {
                this.left = this.left.left;
                return;
            }
            //左子节点只有右子树
            else if(this.left.left == null && this.left.right != null) {
                this.left = this.left.right;
                return;
            }
            //左子节点是叶子节点
            else if(this.left.left == null && this.left.right == null) {
                this.left = null;
                return;
            }
            //左子节点有左右子节点
            else if(this.left.left != null && this.left.right != null) {
                temp = this.left.left;
                while (temp.right!=null){
                    temp = temp.right;
                }
                temp.right = this.left.right;
                this.left = this.left.left;
                return;
            }
        }

        //如果右子节点是要删除的节点
        if (this.right != null && this.right.no == no) {
            //右子节点只有左子树
            if(this.right.left != null && this.right.right == null) {
                this.right = this.right.left;
                return;
            }
            //右子节点只有右子树
            else if(this.right.left == null && this.right.right != null) {
                this.right = this.right.right;
                return;
            }
            //右子节点是叶子节点
            else if(this.right.left == null && this.right.right == null) {
                this.right = null;
                return;
            }
            //右子节点有左右子节点
            else if(this.right.left != null && this.right.right != null) {
                temp = this.right.left;
                while (temp.right!=null){
                    temp = temp.right;
                }
                temp.right = this.right.right;
                this.right = this.right.left;
                return;
            }
        }

        if (this.left != null)
            this.left.delete(no);
        if(this.right != null)
            this.right.delete(no);
    }
}

 

五、顺便存储二叉树

1、顺序存储二叉树的概念

从数据存储来看，数组存储方式和树的存储方式可以相互转换，即数组可以转换成树，树也可以转换成数组。


2、顺序存储二叉树的特点:

1）顺序二叉树通常只考虑完全二叉树

2）第n个元素的左子节点为  2 * n + 1

3）第n个元素的右子节点为  2 * n + 2

4）第n个元素的父节点为  (n-1) / 2

n : 表示二叉树中的第几个元素(按0开始编号 如图所示)

 

3、顺序存储二叉树遍历

需求: 给你一个数组 {1,2,3,4,5,6,7}，要求以二叉树前序遍历的方式进行遍历。 前序遍历的结果应当为 1,2,4,5,3,6,7

代码实现：

package tree;

/**
 * @description:  顺序存储二叉树
 * @auther:田坤
 * @date 2020/10/12 21:29
 **/
public class ArrBinaryTreeDemo {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7};
        ArrBinaryTree abt = new ArrBinaryTree(arr);
        //前序遍历
        System.out.println("前序遍历");
        abt.preTraverse();
        //中序遍历
        System.out.println("中序遍历");
        abt.midTraverse();
        //后序遍历
        System.out.println("后序遍历");
        abt.afterTraverse();
    }
}

/**
 * 编写一个 ArrBinaryTree类，实现顺序存储二叉树遍历
 */
class ArrBinaryTree{
    private int[] arr;

    public ArrBinaryTree(int[] arr){
        this.arr = arr;
    }

    public void preTraverse(){
        this.preTraverse(0);
    }
    public void midTraverse(){
        this.midTraverse(0);
    }
    public void afterTraverse(){
        this.afterTraverse(0);
    }

    //编写一个方法实现顺序存储二叉树的前序遍历
    public void preTraverse(int index){
        if(arr == null || arr.length  == 0){
            System.out.println("数组为空，无法遍历");
            return;
        }
        System.out.println(arr[index]);
        if(2*index+1 < arr.length)
            preTraverse(2*index+1);
        if(2*index+2 < arr.length)
            preTraverse(2*index+2);
    }

    //顺序存储二叉树的中序遍历
    public void midTraverse(int index){
        if(arr == null || arr.length  == 0){
            System.out.println("数组为空，无法遍历");
            return;
        }
        if(2*index+1 < arr.length)
            midTraverse(2*index+1);
        System.out.println(arr[index]);
        if(2*index+2 < arr.length)
            midTraverse(2*index+2);
    }

    //顺序存储二叉树的中序遍历
    public void afterTraverse(int index){
        if(arr == null || arr.length  == 0){
            System.out.println("数组为空，无法遍历");
            return;
        }
        if(2*index+1 < arr.length)
            afterTraverse(2*index+1);
        if(2*index+2 < arr.length)
            afterTraverse(2*index+2);
        System.out.println(arr[index]);
    }

}

 

六、线索化二叉树

先看一个问题

将数列 {1, 3, 6, 8, 10, 14  } 构建成一颗二叉树.  n+1=7

问题分析:

当我们对上面的二叉树进行中序遍历时，数列为 {8, 3, 10, 1, 6, 14 }但是 6, 8, 10, 14 这几个节点的 左右指针，并没有完全的利用上.如果我们希望充分的利用 各个节点的左右指针， 让各个节点可以指向自己的前后节点,怎么办?

解决方案-线索二叉树

 

1、线索二叉树基本介绍

1）n个结点的二叉链表中含有n+1  【公式 2n-(n-1)=n+1】 个空指针域。利用二叉链表中的空指针域，存放指向该结点在某种遍历次序下的前驱和后继结点的指针（这种附加的指针称为"线索"）

2）这种加上了线索的二叉链表称为线索链表，相应的二叉树称为线索二叉树(Threaded BinaryTree)。根据线索性质的不同，线索二叉树可分为前序线索二叉树、中序线索二叉树和后序线索二叉树三种

3）一个结点的前一个结点，称为前驱结点

4）一个结点的后一个结点，称为后继结点

 

线索二叉树应用案例

思路分析:  中序遍历的结果：{8, 3, 10, 1, 14, 6}

说明: 当线索化二叉树后，Node节点的 属性 left 和 right ，有如下情况:

left 指向的是左子树，也可能是指向的前驱节点. 比如 ① 节点 left 指向的左子树, 而 ⑩ 节点的 left 指向的就是前驱节点.

right指向的是右子树，也可能是指向后继节点，比如 ① 节点right 指向的是右子树，而⑩ 节点的right 指向的是后继节点.

 

/**
 * @description:
 * @auther:田坤
 * @date 2020/10/13 17:18
 **/
public class ThreadedBinaryTreeDemo {
    public static void main(String[] args) {
        HeroNode hero1 = new HeroNode(1,"宋江");
        HeroNode hero3 = new HeroNode(3,"吴用");
        HeroNode hero6 = new HeroNode(6,"林冲");
        HeroNode hero8 = new HeroNode(8,"呼延灼");
        HeroNode hero10 = new HeroNode(10,"柴进");
        HeroNode hero14 = new HeroNode(14,"武松");
        hero3.setLeft(hero8);
        hero3.setRight(hero10);
        hero6.setLeft(hero14);
        hero1.setLeft(hero3);
        hero1.setRight(hero6);
        ThreadedBinaryTree threadedBinaryTree = new ThreadedBinaryTree();
        threadedBinaryTree.setRoot(hero1);

        //中序线索化
        //System.out.println("中序线索化");
        threadedBinaryTree.threadedMidTree();
        System.out.println(hero10.getLeft());
        System.out.println(hero10.getRight());
        //遍历
        threadedBinaryTree.thrededMidTreeTraverse();
    }
 }

//实现线索化功能的二叉树
class ThreadedBinaryTree {
    private HeroNode root;

    //为了实现线索化，需要创建要给指向当前节点的前驱结点的指针
    //在递归进行线索化的时候，pre是保留前一个节点
    private HeroNode pre = null;


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

    //中序线索化的二叉树的遍历
    public void thrededMidTreeTraverse(){
        HeroNode node = root;

        while (node != null){
            //找到始节点
            while (node.getLeftType() == 0){
                node = node.getLeft();
            }

            System.out.println(node);

            //如果当前节点的有指针指向后续节点就一直输出
            while (node.getRightType() == 1){
                node = node.getRight();
                System.out.println(node);
            }

            node = node.getRight();
        }
    }

    //对二叉树进行中序线索化方法的重载
    public void threadedMidTree(){
        this.threadedMidTree(root);
    }

    //编写对二叉树进行中序线索化的方法
    public void threadedMidTree(HeroNode node){
        if(node == null){
            return ;
        }

        //向左递归
        threadedMidTree(node.getLeft());

        if(node.getLeft()== null){
            node.setLeft(pre);
            node.setLeftType(1);
        }

        if(pre!=null && pre.getRight()==null){
            pre.setRight(node);
            pre.setRightType(1);
        }

        pre = node;

        //向右递归
        threadedMidTree(node.getRight());
    }
}

//英雄类
class HeroNode {
    private int no;
    private String name;
    private HeroNode left;
    private HeroNode right;

    //如果leftType == 0,表示指向的是左子树，如果是1 表示指向的是前驱结点
    private int leftType;
    //如果rightType == 0 表示指向的是右子树， 如果是1 表示指向的是后继节点
    private int rightType;

    //get  set 方法  toString
}

 

以南_ttrg
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构---树-删除节点
qq_45115146的博客
08-21 1267
树-删除节点
数据结构笔记 —— 二叉树删除节点
一纸春秋的博客
12-20 2786
本篇博客是根据b站尚硅谷的数据结构教程，学习后写的学习笔记，本篇博客的重点在自己编写的代码注释和过程分析上 https://www.bilibili.com/video/BV1E4411H73v?p=99 规定： （1）如果删除的节点是叶子节点，则删除该节点 （2）如果删除的节点是非叶子节点，则删除该子树 思路： 首先先处理：考虑如果树是空树，或者只有一个root节点，则等价于将二叉树置空 然后考虑其他的情况 因为我们的二叉树是单向的，所以我们是判断当前节点的子节点是否是需要删除的节点，而不能判断当前的这
二叉树删除结点
小吴
01-22 518
删除结点的思路 如果删除的结点是叶子结点，则删除该结点 如果删除的结点是非叶子结点，则删除该子树 考虑如果树是空树root，如果只有一个root结点，则等价将二叉树置空 因为二叉树是单向的，一般是判断当前结点的子结点是否需要删除结点，而不能去判断当前这个结点是不是需要删除结点。 如果当前结点的左子结点不为空，并且左子结点就是要删除结点，就将this.left=null;并且就返回(结束递归删除） 如果当前结点的右子结点不为空，并且右子结点就是要删除结点，就将this.right=null；并且就
数据结构 （四）树之删除结点篇
love、reading的博客
07-28 2412
删除树的结点是树的操作之中相对比较复杂的。 本文基于二叉排序树的基础上进行树的结点删除操作，删除结点后还要保持二叉树的有序。 考虑三种情况： （1）要删除的是叶结点：先查找到这个结点，直接删除， 并再修改其父结点指针---置为NULL 图1 （2）要删除的结点只有一个孩子结点: 将其父结点的指针指向要删除结点的孩子结点 图1图2图3​​​​ ...
尚硅谷-数据结构与算法-二叉树笔记3
weixin_52002922的博客
10-17 312
主要是删除节点的操作 package com.atguigu.tree; /** * 基础知识：节点（一个对象）、根节点（顶）、父节点、子节点、叶子节点（没有子节点得节点）、节点得权（节点得值）、路径（从root节点找到 * 该节点得路线），层、子树、树得高度（最大层数）、森林（多颗子树构成得森林） * 满二叉树：所有得叶子节点都在最后一层，并且系节点得总数=2^n-1，n为层数，则我们称为满二叉树 * 完全二叉树：如果该二叉树得所有叶子节点都在最后一层或者倒数第二层，而且最后一层得.
B树和B+树
12-14
所有的值都是按照顺序存储，没有重复的元素，并且每个叶子节点到根节点的距离相同，B树的中间节点会存储数据指针信息，B树索引能够加快访问速度，是因为存储引擎不再需要全表扫描来获取数据。 B+树 B+树有重复的...
模型树_模型树_
09-29
模型树是一种决策树方法，常用于机器学习领域，特别是在预测性建模中。它通过构建一系列的规则来预测目标变量，这些规则基于特征值的区间或分位数。与传统的决策树不同，模型树在每个内部节点不是选择最佳特征进行...
python决策树代码
10-12
决策树(Decision Tree）是在已知各种情况发生概率的基础上，通过构成决策树来求取净现值的期望值大于等于零的概率，评价项目风险，判断其可行性的决策分析方法，是直观运用概率分析的一种图解法。由于这种决策分支画...
LabVIEW的树形
01-19
树形控件用于向用户提供一个可供选择的层次化列表。用户将输入树形控件的项组织为若干组项或若干组节点，单击节点旁边的展开符号可展开节点，显示该节点中的所有项。单击节点旁的符号还可折叠节点。树形控件为目录状...
二叉排序树节点删除详解
云杉木屋
04-01 1万+
摘要：本篇笔记作为补充笔记，主要讲解在二叉排序树中的节点删除这一行为的操作
二叉树-删除节点
qq_30657195的博客
06-03 534
要求 如果删除的节点是叶子节点，则删除该节点。 如果删除的节点是非叶子节点，则删除树。 测试 删除5号叶子节点和3号树。 代码实现 package chapter18.binarytree object BinaryTreeDemo { def main(args: Array[String]): Unit = { //先使用比较简单的方法，直接关联 val root = new HeroNode(1, "宋江") val hero2 = new HeroNode(2,
数据结构——详解二叉查找树(BST)的删除操作
weixin_43744293的博客
07-06 3708
注意：此篇文章只是详细介绍文章数据结构——实现一个二叉查找树（BST）实现的二叉树的删除操作，所以一些类的定义并不在本文中。 **删除节点分类**： 删除的结点是叶子节点 需要做两件事： 断开和父节点的连接 释放删除节点的内存 由于这种情况很简单，不做说明，可参见代码。 删除的结点不是叶子节点 此时删除的节点必定有左子树或右子树或者两者兼具。 以图1的二叉树为例，我们可以有两种做法。就以删除节点3为例，即可以将节点3左子树的最大值节点补在节点3的位置，也可以将节点3右子树的最小值节点补在
数据结构之二叉树的删除
GiantCrocodile的博客
03-23 1374
二叉树的删除，要完成的操作（要求）： 删除的是叶子结点，那就删除叶子结点 如果删除的是非叶子节点，将该节点置空 思路： 注意：如果是空树 root==null, 或者只有一个root节点，等价于把二叉树置空 1.二叉树是单向的，判断当前节点的子节点是不是要被删除，而不是判断要删除的节点。（类似于单链表的删除，要找到被删除的前一个） 2.如果当前节点（根节点）的左子节点不为空，并且左子节点就是要...
二叉排序树
li-zhang-yu的博客
03-12 524
二：二叉排序树的特点
二叉树知识之3节点的删除
m0_56184347的博客
07-23 1709
二叉树的删除简单二叉树删除的思路简单删除的规定简单删除的思路简单删除的代码实现（以删除4号节点为例）复杂二叉树的删除复杂二叉树的删除规定复杂二叉树的删除思路复杂删除的代码实现（以删除5号节点为例）测试代码 简单二叉树删除的思路 简单删除的规定 如果删除的是叶子节点，则删除该节点 如果删除的节点是非叶子节点，则将该节点的子树一起删除 简单删除的思路 先判断是是不是空树，是空树则直接返回， 该树的root节点是不是要删除的节点，如果是root节点，则直接将整个树置为null 删除时先找到该要删除的节点的上
树的查找和删除节点
萌新Java工程师
01-26 382
查找指定节点 使用我们的前中后序遍历找到一个指定节点，查找HeroNode = 4 分别查找了几次？ 例子还是我们上面讲到的那个二叉树，我们先分析 前序查找：先判断当前的no是不是要查找的，是就返回当前节点，不是的话，判断当前节点的左子节点是否为空，若不为空则递归前序查找，找到返回，为空(或者没有找到)的话就去判断右子树，跟我们的左子节点一样 emmmm，其他两种都已一样的套路，这里就不多说了 前序遍历：小王——>小胡——>小黄——>老肥找到 中序遍历：小胡——>小王——&gt.
二叉树及其相关操作
小菜鸡
01-09 111
二叉树 二叉树的概念 树有很多种，每个节点最多只能有两个子节点的一种形式称为二叉树。 二叉树的子节点分为左节点和右节点。 满二叉树 如果该二叉树的所有叶子节点都在最后一层，并且结点总数= 2^n -1 , n 为层数，则我们称为满二叉树 完全二叉树 如果该二叉树的所有叶子节点都在最后一层或者倒数第二层，而且最后一层的叶子节点在左边连续，倒数第二层的叶子节点在右边连续，我们称为完全二叉树。 二叉树遍历 这里的二叉树的构建，我们手动构建二叉树。 创建树节点类TreeNode.java /** * @au
二叉树删除节点
xiaowanziddd的博客
02-06 1901
二叉树删除节点 完成删除结点的操作 规定：①如果删除的结点是叶子结点，则删除该结点    ②如果删除的结点是非叶子结点，则删除该子树 思路： 1.考虑如果树是空树root,如果只有一个root结点，则等价将二叉树置空。 2.因为二叉树数单向的，所以判断当前结点的子结点是否需要删除结点，而不能去判断当前结点是不是需要删除的结点。 3.如果当前结点的左子结点不为空，并且左子结点就是要删除的结点，就将this.left = null;并且就返回(结束递归删除) 4.如果当前结点的右子结点不为空，并且右子结点就是要

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值