10.树结构基础部分

最新推荐文章于 2022-10-25 21:32:39 发布
最新推荐文章于 2022-10-25 21:32:39 发布
阅读量119 收藏
点赞数
分类专栏： 数据结构与算法分析 文章标签： 数据结构 链表 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HK_Milky/article/details/119633074
版权

树

三种存储方式的比较

  • 数组存储方式分析
    • 优点：通过下标方式访问元素，速度快。对于有序数组，还可使用二分查找提高检索速度。
    • 缺点：如果要检索具体某个值，或者插入值(按一定顺序)会整体移动，效率较低
  • 链表存储方式分析
    • 优点：在一定程度上对数组存储方式有优化(比如：插入一个数值节点，只需要将插入节点，链接到链表中即可， 删除效率也很好)
    • 缺点：在进行检索时，效率仍然较低，比如(检索某个值，需要从头节点开始遍历)
  • 树的存储方式分析
    • 能提高数据存储，读取的效率, 比如利用 二叉排序树(Binary Sort Tree)，既可以保证数据的检索速度，同时也可以保证数据的插入，删除，修改的速度。
      在这里插入图片描述

树的示意图

在这里插入图片描述

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

二叉树

二叉树的概念

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

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

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

  4. 在这里插入图片描述

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

  6. 在这里插入图片描述

二叉树的遍历

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

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

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

  • 小结: 看输出父节点的顺序，就确定是前序，中序还是后序在这里插入图片描述

代码展示

package demo01;

public class BinaryTreeDemo {
    public static void main(String[] args) {
        //先创建一棵二叉树
        BinaryTree binaryTree=new BinaryTree();
        //创建需要的节点
        HeroNode root=new HeroNode(1,"zoffy");
        HeroNode node2=new HeroNode(2,"man");
        HeroNode node3=new HeroNode(3,"taro");
        HeroNode node4=new HeroNode(4,"taiga");

        //先手动创建该二叉树，后面学习递归方式创建二叉树
        root.setLeft(node2);
        root.setRight(node3);
        node3.setRight(node4);
        binaryTree.setRoot(root);

        //测试
        System.out.println("前序遍历");
        binaryTree.preOrder();
        System.out.println("中序遍历");
        binaryTree.infixOrder();
        System.out.println("后序遍历");
        binaryTree.postOrder();
    }
}
//定义BinaryTree 二叉树
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("二叉树为null，无法遍历");
        }
    }

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

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

}

//创建HeroNode 节点
class HeroNode{
    private int no;
    private String name;
    private HeroNode left;  //默认为null
    private HeroNode right; //默认为null

    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);
    }
}

二叉树的查找

在这里插入图片描述

代码展示

package demo02;

public class BinaryTreeDemoSearch {
    public static void main(String[] args) {
        //先创建一棵二叉树
        BinaryTree binaryTree=new BinaryTree();
        //创建需要的节点
        HeroNode root=new HeroNode(1,"zoffy");
        HeroNode node2=new HeroNode(2,"man");
        HeroNode node3=new HeroNode(3,"taro");
        HeroNode node4=new HeroNode(4,"taiga");

        //先手动创建该二叉树，后面学习递归方式创建二叉树
        root.setLeft(node2);
        root.setRight(node3);
        node3.setRight(node4);
        binaryTree.setRoot(root);

        //查找
        System.out.println("前序查找");
        HeroNode node = binaryTree.preOrderSearch(3);
        if (node!=null){
            System.out.printf("找到了，信息为no=%d,name=%s",node.getNo(), node.getName());
        }else {
            System.out.println("没找到");
        }
    }
}

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

    public void setRoot(HeroNode root){
        this.root=root;
    }
    
    //前序查找
    public HeroNode preOrderSearch(int no){
        if (root!=null){
            return root.preOrderSearch(no);
        }else {
            return null;
        }
    }

    //中序查找
    public HeroNode infixOrderSearch(int no){
        if (root!=null){
            return root.infixOrderSearch(no);
        }else {
            return null;
        }
    }

    //后序查找
    public HeroNode postOrderSearch(int no){
        if (root!=null){
            return root.postOrderSearch(no);
        }else {
            return null;
        }
    }

}

//创建HeroNode 节点
class HeroNode{
    private int no;
    private String name;
    private HeroNode left;  //默认为null
    private HeroNode right; //默认为null

    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 + "}";
    }

    //前序遍历查找

    /**
     * @param no    查找no
     * @return      如果找到就返回该Node，如果没有找到就返回 null
     */
    public HeroNode preOrderSearch(int no){
        //比较当前节点是不是要查找的节点
        if (this.no==no){
            return this;
        }
        //1.判断当前节点的左子节点是否为 null，如果不为 null，则递归前序查找
        //2.如果左递归前序查找，找到节点，则返回
        HeroNode resNode = null;
        if (this.left!=null){
            resNode=this.left.preOrderSearch(no);
        }
        if (resNode!=null){
            //说明找到了
            return resNode;
        }
        //1.左递归前序查找，找到节点，则返回，否则继续判断
        //2.当前的节点的右子节点是否为null，如果不为 null，则继续向右递归前序查找
        if (this.right!=null){
            resNode=this.right.preOrderSearch(no);
        }
        return resNode;
    }

    //中序遍历查找
    public HeroNode infixOrderSearch(int no){
        HeroNode resNode = null;
        //判断当前节点的左子节点是否为null，如果不为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;
        //判断当前节点的左子节点是否为null，如果不为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 (this.no==no){
            return this;
        }
        return resNode;
    }
}

二叉树的删除

在这里插入图片描述

代码展示

package demo03;

public class BinaryTreeDemoDelete {
    public static void main(String[] args) {
        //先创建一棵二叉树
        BinaryTree binaryTree = new BinaryTree();
        //创建需要的节点
        HeroNode root = new HeroNode(1, "zoffy");
        HeroNode node2 = new HeroNode(2, "man");
        HeroNode node3 = new HeroNode(3, "taro");
        HeroNode node4 = new HeroNode(4, "taiga");

        //先手动创建该二叉树，后面学习递归方式创建二叉树
        root.setLeft(node2);
        root.setRight(node3);
        node3.setRight(node4);
        binaryTree.setRoot(root);

        //测试删除
        binaryTree.delNode(1);

    }
}

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

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

    public void delNode(int no){
        if (root!=null){
            //如果只有一个root节点，这里立即判断root是不是就是要删除的节点
            if (root.getNo()==no){
                root=null;
            }else {
                root.delNode(no);
            }
        }else {
            System.out.println("这个树是空树，不能删除~~~");
        }
    }

}

//创建HeroNode 节点
class HeroNode {
    private int no;
    private String name;
    private HeroNode left;  //默认为null
    private HeroNode right; //默认为null

    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 + "}";
    }

    //递归删除节点
    //1.如果删除的节点是叶子节点，则删除该节点
    //2.如归删除的节点是非叶子节点，则删除该子树
    public void delNode(int no) {
        /**
         * 思路：
         * 1.因为我们的二叉树是单向的，所以我们是判断当前节点的子节点是否需要删除节点，而不能去判断当前这个节点是不是需要删除节点
         * 2.如果当前节点的左子节点不为空，而且左子节点就是要删除节点，就将this.left = null；并且就返回（结束递归删除）
         * 3.如果当前节点的右子节点不为空，并且右子节点就是要删除节点，就将this.right= null；并且就返回（结束递归删除）
         * 4.如果第2步和第3步没有删除节点，那么我们就需要向左子树进行递归删除
         * 5.如果第4步也没有删除节点应当向右子树进行递归删除
         */
        //2.如果当前节点的左子节点不为空，而且左子节点就是要删除节点，就将this.left = null；并且就返回（结束递归删除）
        if (this.left != null && this.left.no == no) {
            this.left = null;
            return;
        }
        //3.如果当前节点的右子节点不为空，并且右子节点就是要删除节点，就将this.right= null；并且就返回（结束递归删除）
        if (this.right != null && this.right.no == no) {
            this.right = null;
            return;
        }
        //4.向左子树进行递归删除
        if (this.left!=null){
            this.left.delNode(no);
        }
        //5.向右子树进行递归删除
        if (this.right!=null){
            this.right.delNode(no);
        }

    }
}

顺序存储二叉树

基本介绍

从数据存储来看，数组存储方式和树的存储方式可以相互转换，即数组可以转换成树，树也可以转换成数组，如下面所示。
在这里插入图片描述

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

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

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

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

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

代码展示

package demo04;
//顺序存储二叉树的前、中、后序遍历
public class ArrayBinaryTreeDemo {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7};
        //创建一个ArrBinaryTree
        ArrayBinaryTree binaryTree=new ArrayBinaryTree(arr);
        System.out.println("前序遍历");
        binaryTree.preOrder();
        System.out.println();
        System.out.println("中序遍历");
        binaryTree.infixOrder();
        System.out.println();
        System.out.println("后序遍历");
        binaryTree.postOrder();

    }
}

//编写一个ArrayBinaryTree，实现顺序存储二叉树遍历

class ArrayBinaryTree {
    private int[] arr;//存储数据节点的数组

    public ArrayBinaryTree(int[] arr) {
        this.arr = arr;
    }
    //重载 preOrder
    public void preOrder(){
        this.preOrder(0);
    }

    //重载 infixOrder
    public void infixOrder(){
        this.infixOrder(0);
    }

    //重载 postOrder
    public void postOrder(){
        this.postOrder(0);
    }

    //编写一个方法，完成顺序存储二叉树的前序遍历

    /**
     * @param index 数组下标
     */
    public void preOrder(int index) {
        //如果数组为空，或者 arr.length == 0;
        if (arr == null || arr.length == 0) {
            System.out.println("数组为空，无法进行二叉树的前序遍历");
        }
        //输出当前这个元素
        System.out.print(arr[index]);
        //向左遍历递归
        if (index * 2 + 1 < arr.length) {
            preOrder(2 * index + 1);
        }
        //向右遍历递归
        if (index * 2 + 2 < arr.length) {
            preOrder(2 * index + 2);
        }
    }

    //编写一个方法，完成顺序存储二叉树的中序遍历

    /**
     * @param index 数组下标
     */
    public void infixOrder(int index) {
        //如果数组为空，或者 arr.length == 0;
        if (arr == null || arr.length == 0) {
            System.out.println("数组为空，无法进行二叉树的中序遍历");
        }
        //向左遍历递归
        if (index * 2 + 1 < arr.length) {
            infixOrder(2 * index + 1);
        }
        //输出当前这个元素
        System.out.print(arr[index]);
        //向右遍历递归
        if (index * 2 + 2 < arr.length) {
            infixOrder(2 * index + 2);
        }
    }

    //编写一个方法，完成顺序存储二叉树的后序遍历

    /**
     * @param index 数组下标
     */
    public void postOrder(int index) {
        //如果数组为空，或者 arr.length == 0;
        if (arr == null || arr.length == 0) {
            System.out.println("数组为空，无法进行二叉树的后序遍历");
        }
        //向左遍历递归
        if (index * 2 + 1 < arr.length) {
            postOrder(2 * index + 1);
        }
        //向右遍历递归
        if (index * 2 + 2 < arr.length) {
            postOrder(2 * index + 2);
        }
        //输出当前这个元素
        System.out.print(arr[index]);
    }
}

线索化二叉树

基本介绍

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

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

  • 一个结点的前一个结点，称为前驱结点

  • 一个结点的后一个结点，称为后继结点
    在这里插入图片描述

  • 说明：当线索化二叉树，Node节点的属性left和right，有以下两种情况：(根据上图分析)

    1. left指向的是左子树，也可能是指向的前驱节点，比如 1号 节点left指向的左子树，而 10号 节点的left指向的就是前驱节点
    2. right指向的是右子树，也可能是指向后继节点， 比如 1号 节点right指向的右子树，而 10号 节点的right指向的是后继节点

代码展示

package demo05;

public class ThreadedBinaryTreeDemo {
    public static void main(String[] args) {
        //创建需要的节点
        HeroNode root = new HeroNode(1, "zoffy");
        HeroNode node2 = new HeroNode(3, "man");
        HeroNode node3 = new HeroNode(6, "taro");
        HeroNode node4 = new HeroNode(8, "taiga");
        HeroNode node5 = new HeroNode(10, "mebius");
        HeroNode node6 = new HeroNode(14, "zero");

        //二叉树，后面我们递归创建，现在简单处理使用手动创建
        root.setLeft(node2);
        root.setRight(node3);
        node2.setLeft(node4);
        node2.setRight(node5);
        node3.setLeft(node6);

        //测试线索化
        ThreadedBinaryTree threadedBinaryTree = new ThreadedBinaryTree();
        threadedBinaryTree.setRoot(root);
        threadedBinaryTree.threadedNodes();

        HeroNode left = node5.getLeft();
        System.out.println(left);

        //当线索化二叉树后，不能再使用原来的方法遍历
        System.out.println("使用线索化的方式遍历线索化二叉树");
        threadedBinaryTree.threadedList();


    }
}

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

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

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

    //重载threadedNodes方法
    public void threadedNodes() {
        this.threadedNodes(root);
    }

    //遍历线索化二叉树的方法
    public void threadedList() {
        //定义一个变量，存储当前遍历的节点，从root开始
        HeroNode node = root;
        while (node != null) {
            //循环的找到leftType==1的节点，第一个找到的是8节点
            //后面随着遍历而变化，因为当leftType==1时，说明该节点是按照线索化处理后的有效节点
            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 threadedNodes(HeroNode node) {
        //如果node==null 不能线索化
        if (node == null) {
            return;
        }
        //第一步 先线索化左子树
        threadedNodes(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;

        //第三步 再线索化右子树
        threadedNodes(node.getRight());
    }

}


//创建HeroNode 节点
class HeroNode {
    private int no;
    private String name;
    private HeroNode left;  //默认为null
    private HeroNode right; //默认为null
    //说明：
    //1.如果leftType == 0 表示指向的是左子树，如果leftType == 1 则表示指向前驱节点
    //2.如果rightType ==0 表示指向的是右子树，如果rightType == 1 表示指向后继节点
    private int leftType;
    private int rightType;


    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;
    }

    public int getLeftType() {
        return leftType;
    }

    public void setLeftType(int leftType) {
        this.leftType = leftType;
    }

    public int getRightType() {
        return rightType;
    }

    public void setRightType(int rightType) {
        this.rightType = rightType;
    }

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

}
梦~开始
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java算法与数据结构测试——二叉树
Junds0的博客
03-25 1177
第1关：向二叉树中插入叶子节点 本关任务：向二叉树中插入左叶子节点，请补全insertLeft(T x, Node parent)函数实现插入左叶子节点的功能。 package step1; class Node<T> { private T data; public Node<T> lChild; public Node<T> rChild; public Node() { data = null; lChild = null; rChild =
数据结构与算法java篇--二叉树
小马哥的博客
12-24 716
数据结构有算法，java
十道二叉树面试题，对二叉树理解更进一步
weixin_46016019的博客
05-06 2881
学习二叉树有一个很重要的思想就是分治（将一个大问题划分为最小规模的子问题），常用方法之一就是递归，而递归是很抽象的，当对递归过程不理解时，建议多画图将递归过程实例化，拒绝人脑压栈...
47面试常问：六大类二叉树面试题汇总解答
AI乔治
11-14 392
0 概述 继上一篇总结了二叉树的基础操作后，这一篇文章汇总下常见的二叉树相关面试题，主要分为判断类、构建类、存储类、查找类、距离类、混合类这六类大问题。 本文所有代码 https://github.com/shishujuan/dsalg/tree/master/code/ds/tree/binary_tree 1 判断类问题 判断类问题主要分下下判断二叉树是否是二叉搜索树、二叉完全树，以及两棵二叉树是否同构这三个问题。 1.1 判断一棵二叉树是否是二叉搜索树(BST) 题：给定...
答辩问题杂谈
那些回忆里
05-25 722
1、“抖动”导致算法性能下降/** * 抖动 27146ms * @param a * @param b * @return */ public static int[][] matrixClassic(int[][] a, int[][]b){ if(a[0].length != b.length){ ...
数据结构基础知识.doc
06-19
数据结构基础知识是计算机科学教育的重要组成部分，无论是语言编译、操作系统、数据库系统还是人工智能领域，都离不开对数据结构的理解和应用。 1. **数据结构的概念**： 数据结构研究的对象包括数据本身以及数据...
基础算法之数据结构.docx
05-09
**基础数据结构** 数据结构是计算机科学中存储、组织数据的一种方式，它是算法设计的基础。在编程语言如Scala中，理解基本的数据结构至关重要。这里我们主要讨论数组、链表、栈、队列、树和图这几种常见的数据结构...
【list转树结构】相关附件
最新发布
09-12
在IT行业中，数据结构是编程基础的重要组成部分，而树结构是一种非常常见且高效的数据结构，广泛应用于文件系统、数据库索引、编译器设计等多个领域。"List转树结构"通常指的是将一个扁平化的数据列表转换为树形结构...
24wd数据结构树部分缺失的视频
07-04
遍历对于理解和操作二叉树至关重要，比如在打印树结构、查找或构建树时。 6. **线索二叉树**（09.5.3.2_1线索二叉树的概念.mp4、10.5.3.2_2二叉树的线索化.mp4）：线索二叉树是在普通二叉树的基础上增加线索，以便...
广工数据结构实验-B树
05-04
在IT领域，数据结构是计算机科学的基础，它研究如何有效地组织和存储数据，以便于算法的执行。B树，作为一种自平衡的多路查找树，是数据结构中的一个重要概念，尤其在数据库和文件系统中应用广泛。这个"广工数据结构...
Java 数据结构与算法之树（BST）
AS011x的博客
09-21 353
Binary Search Tree历史。二叉搜索树算法是由包括 PF Windley、Andrew Donald Booth、Andrew Colin、Thomas N. Hibbard 在内的几位研究人员独立发现的。该算法归功于 Conway Berners-Lee 和 David Wheeler ，他们在 1960 年使用它在磁带中存储标记数据。最早和流行的二叉搜索树算法之一是 Hibbard 算法。用于组成一颗树的节点，则需要包括；值和与之关联的三角结构，一个父节点、两个孩子节点。
尚硅谷数据结构与算法(Java)--24线索化二叉树
shlr_的博客
05-30 1255
：线索化二叉树 线索二叉树基本介绍 1)n个结点的二叉链表中含有n+1公式2n-(n-1)=n+1个空指针域。利用二叉链表中的空指针域，存放指向结点在某种遍历次序下的前驱和后继结点的指针（这种附加的指针称为"线索") 2)这种加上了线索的二叉链表称为线索链表，相应的二叉树称为线索二叉树(Threaded BinaryTree),根据线索性质的不同，线索二叉树可分为前序线索二叉树、中序线索二叉树和后序线索二叉树三种 3)一个结点的前一个结点，称为前驱结点 4)一个结点
数据结构与算法(Java)之二叉树
weixin_42284219的博客
08-31 116
二叉树 package com.weeks.tree; /** * @author 达少 * @version 1.0 * * 实现二叉树数据结构 */ public class BinaryTreeDemo { public static void main(String[] args) { //定义二叉树 BinaryTree binaryTree = new BinaryTree(); //定义二叉树的节点对象 Her
Java数据结构——二叉树
ShirleyZ1007的博客
05-23 667
二叉树前中后序的实现、层序遍历的实现、求树的结点个数、高度等
Java数据结构与算法---二叉树
weixin_44961794的博客
04-30 375
不得不说二叉树很容易把人搞晕，这两天一直在学习探索二叉树。看起来挺简单的内容，实际上实现起来真的不是那么容易，更何况要达到熟练运用就更难了。路漫漫其修远兮。先把实现的内容分享出来吧，明天继续研究。 这部分内容包括：二叉树的实现、前序，中序，后序遍历二叉树的递归算法。后面会继续实现关于树的相关算法。 实现的二叉树结构长这样： 实现二叉树包含三部分代码，分别是二叉树的节点类、二叉树类、创建二叉树及测...
SDUT 二叉树（模板题）
qq_45830025的博客
10-14 240
I - 二叉树 Description 已知二叉树的一个按前序遍历输入的字符序列，如abc,de,g,f, (其中,表示空结点)。请建立二叉树，并输出建立二叉树的前序遍历序列、中序遍历序列、后序遍历序列、层次遍历序列、深度、叶子数。 Input 多组测试数据，对于每组测试数据，输入一个长度小于５０的按前序遍历输入的字符序列。 Output 对于每组测试数据，第1行输出其前序遍历序列、第2行输出其中序遍历序列、第3行输出其后序遍历序列、第4行输出其深度、第5行输出其叶子数。 Sample Input abc,
Java数据结构之二叉树
fear_wolf的博客
10-25 2299
二叉树的创建很简单，但是难就难在操作上，我们为了简便，先自己手动创建一个简陋的二叉树的结构，着重介绍二叉树的操作，先创建一棵二叉树。我们有前面的概念可以看出，二叉树定义是递归式的，因此后序基本操作中基本都是按照递归实现的。完全二叉树：完全二叉树是效率很高的数据结构，完全二叉树是从满二叉树中引出来的，对于。的数据结构，它是由n（n >= 0）个有限节点组成的一个具有层次关系的集合，遍历是二叉树上最重要的操作之一，是二叉树进行其他运算的基础。称之为完全二叉树，由此可知，满二叉树是一种特殊的完全二叉树。
算法（Java）——二叉树
小朱小朱绝不认输的博客
03-12 1086
二叉树在算法中也是比较常用的数据结构，根据二叉树的遍历算法，在算法题中遇到二叉树经常优先考虑递归算法。同时二叉树中的二叉搜索树也是常用的，主要结合中序遍历有序的特性。 二叉树 ...
二叉树【Java数据结构】
weixin_69417428的博客
10-05 300
二叉树超详细讲解！ 【Java数据结构】

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值