二叉树

最新推荐文章于 2024-10-06 13:02:04 发布
最新推荐文章于 2024-10-06 13:02:04 发布
阅读量59 收藏
点赞数
文章标签： 二叉树 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Syx80236/article/details/115742530
版权
本文深入探讨了树这种数据结构，特别是二叉树的特点和优势。分析了数组和链式存储的优缺点，并指出树如何优化数据存储和读取效率。详细介绍了二叉树的术语，如节点、根节点、子节点等，以及满二叉树和完全二叉树的概念。此外，还展示了二叉树的前序、中序和后序遍历方法，并通过实例解释了前序查找、中序查找和后序查找的实现。最后，讨论了删除节点的操作，包括删除叶子节点和非叶子节点的子树。
摘要由CSDN通过智能技术生成

二叉树

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

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

树的示意图

在这里插入图片描述

树的常用术语(结合示意图理解):

  • 节点
  • 根节点
  • 父节点
  • 子节点
  • 叶子节点 (没有子节点的节点)
  • 节点的权(节点值)
  • 路径(从root节点找到该节点的路线)
  • 层
  • 子树
  • 树的高度(最大层数)
  • 森林 :多颗子树构成森林

二叉树

  1. 树有很多种，每个节点最多只能有两个子节点的一种形式称为二叉树。
  2. 二叉树的子节点分为左节点和右节点。
  3. 3)如果该二叉树的所有叶子节点都在最后一层，并且结点总数= 2^n -1 , n 为层数，则我们称为满二叉树。
  4. 如果该二叉树的所有叶子节点都在最后一层或者倒数第二层，而且最后一层的叶子节点在左边连续，倒数第二层的叶子节点在右边连续，我们称为完全二叉树。

二叉树遍历说明

  • 前序遍历: 先输出父节点，再遍历左子树和右子树
  • 中序遍历: 先遍历左子树，再输出父节点，再遍历右子树
  • 后序遍历: 先遍历左子树，再遍历右子树，最后输出父节点
  • 小结: 看输出父节点的顺序，就确定是前序，中序还是后序
package com.yuxi.lesson10;

import java.util.Scanner;

public class BinaryTreeDemo {
    public static void main(String[] args) {

        //先创建一个二叉树
        BinaryTree binaryTree = new BinaryTree();
        //创建需要的节点
        HeroNode root = new HeroNode(1, "玉A");
        HeroNode node2 = new HeroNode(2, "玉B");
        HeroNode node3 = new HeroNode(3, "玉C");
        HeroNode node4 = new HeroNode(4, "玉D");
        HeroNode node5 = new HeroNode(5, "玉E");
        //创建二叉树
        root.setLeft(node2);
        root.setRight(node3);
        node3.setRight(node4);
        node3.setLeft(node5);
        binaryTree.setRoot(root);

        System.out.println("  前序遍历 ");
        binaryTree.preOrder();

        System.out.println("  中序遍历 ");
        binaryTree.infixOrder();

        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("二叉树为空~");
        }
    }

}

//先创建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() {
        //1.输出父节点
        System.out.println(this);
        //2.递归向左子树前序遍历
        if (this.left != null) {
            this.left.preOrder();
        }
        //3.递归向右子树前序遍历
        if (this.right != null) {
            this.right.preOrder();
        }
    }

    //中序遍历
    public void infixOrder() {
        //1.递归向左子树前序遍历
        if (this.left != null) {
            this.left.infixOrder();
        }
        //2.输出父节点
        System.out.println(this);
        //3.递归向右子树前序遍历
        if (this.right != null) {
            this.right.infixOrder();
        }
    }

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

在这里插入图片描述

查找指定节点

  1. 请编写前序查找，中序查找和后序查找的方法。

  2. 并分别使用三种查找方式，查找 heroNO = 5 的节点。

  3. 并分析各种查找方式，分别比较了多少次。

    package com.yuxi.lesson10;

import java.util.Scanner;

public class BinaryTreeDemo {
    public static void main(String[] args) {

        //先创建一个二叉树
        BinaryTree binaryTree = new BinaryTree();
        //创建需要的节点
        HeroNode root = new HeroNode(1, "玉A");
        HeroNode node2 = new HeroNode(2, "玉B");
        HeroNode node3 = new HeroNode(3, "玉C");
        HeroNode node4 = new HeroNode(4, "玉D");
        HeroNode node5 = new HeroNode(5, "玉E");
        //创建二叉树
        root.setLeft(node2);
        root.setRight(node3);
        node3.setRight(node4);
        node3.setLeft(node5);
        binaryTree.setRoot(root);

        System.out.println("  前序遍历 ");
        binaryTree.preOrder();

        System.out.println("  中序遍历 ");
        binaryTree.infixOrder();

        System.out.println("  后序遍历 ");
        binaryTree.postOrder();

        //前序遍历
        //次数 4
//        System.out.println("前序遍历 ~~");
//        HeroNode res = binaryTree.preOrderSearch(5);
//        if (res != null){
//            System.out.printf("找到了,信息为 no = %d name = %s",res.getNo(),res, node2.getName());
//        }else{
//            System.out.printf("没有找到 no = %d 的英雄",5);
//        }
        //中序遍历
        //次数 3
//        System.out.println("中序遍历 ~~");
//        HeroNode res = binaryTree.infixOrderSearch(5);
//        if (res != null){
//            System.out.printf("找到了,信息为 no = %d name = %s",res.getNo(),res, node2.getName());
//        }else{
//            System.out.printf("没有找到 no = %d 的英雄",5);
//        }

        //后序遍历
        //次数 2 
        System.out.println("后序遍历 ~~");
        HeroNode res = binaryTree.postOrderSearch(5);
        if (res != null){
            System.out.printf("找到了,信息为 no = %d name = %s",res.getNo(),res, node2.getName());
        }else{
            System.out.printf("没有找到 no = %d 的英雄",5);
        }


    }
}

//创建一个二叉树
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("二叉树为空~");
        }
    }
    //前序遍历
    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 +
                '}';
    }

    //前序遍历
    public void preOrder() {
        //1.输出父节点
        System.out.println(this);
        //2.递归向左子树前序遍历
        if (this.left != null) {
            this.left.preOrder();
        }
        //3.递归向右子树前序遍历
        if (this.right != null) {
            this.right.preOrder();
        }
    }

    //中序遍历
    public void infixOrder() {
        //1.递归向左子树前序遍历
        if (this.left != null) {
            this.left.infixOrder();
        }
        //2.输出父节点
        System.out.println(this);
        //3.递归向右子树前序遍历
        if (this.right != null) {
            this.right.infixOrder();
        }
    }

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


    /**
     * 前序遍历查找
     * @param no 查找no
     * @return 找到就返回 Node 没有就返回null
     */
    public HeroNode preOrderSearch(int no){
        System.out.println("进入前序遍历：");
        //比较当前的结点是不是
        if (this.no == no){
            return this;
        }
        //1.判断当前结点的左子结点是否为空，如果不为空，则递归前序查找
        //2.如果左递归前序查找，找到结点，则返回
        HeroNode res = null;
        if (this.left != null){
            res = this.left.preOrderSearch(no);
        }
        if (res != null){
            return res;
        }
        //1.左递归前序查找，找打结点，则返回，否则继续判断
        //2.当前结点的右子结点是否为空，如果不为空，则右递归前序查找
        if (this.right != null){
            res = this.right.preOrderSearch(no);
        }
        return res;
    }
    //中序
    public HeroNode infixOrderSearch(int no){
        //1.判断当前结点的左子结点是否为空，如果不为空，则递归中序查找
        HeroNode res = null;
        if (this.left != null){
            res = this.left.infixOrderSearch(no);
        }
        if (res != null){
            return res;
        }
        System.out.println("进入中序查找~");
        //2.如果找到结点，则返回，否则继续与当前结点比较 如果是返回当前结点
        if (this.no == no){
            return this;
        }
        //3.否则继续进行右递归的中序查找
        if (this.right != null){
            res = this.right.infixOrderSearch(no);
        }
        return res;
    }
    //后序查找
    public HeroNode postOrderSearch(int no){
        //1.判断当前结点的左子结点是否为空，如果不为空，则递归后序查找
        HeroNode res = null;
        if (this.left != null){
            res = this.left.postOrderSearch(no);
        }
        if (res != null){ //找到
            return res;
        }
        //2.如果左子树没找到，则就向右子树递归进行后后序查找
        if (this.right != null){
            res = this.right.postOrderSearch(no);
        }
        if (res != null){ //找到
            return res;
        }
        System.out.println("进入后序查找~");
        //如果左右子树都没找到，就比较当前
        if (this.no == no) {
            return this;
        }
        return res;
    }
}

删除节点

  1. 如果删除的节点是叶子节点，则删除该节点
  2. 如果删除的节点是非叶子节点，则删除该子树.
  3. 测试，删除掉 5号叶子节点 和 3号子树
package com.yuxi.lesson10;

import java.util.Scanner;

public class BinaryTreeDemo {
    public static void main(String[] args) {

        //先创建一个二叉树
        BinaryTree binaryTree = new BinaryTree();
        //创建需要的节点
        HeroNode root = new HeroNode(1, "玉A");
        HeroNode node2 = new HeroNode(2, "玉B");
        HeroNode node3 = new HeroNode(3, "玉C");
        HeroNode node4 = new HeroNode(4, "玉D");
        HeroNode node5 = new HeroNode(5, "玉E");
        //创建二叉树
        root.setLeft(node2);
        root.setRight(node3);
        node3.setRight(node4);
        node3.setLeft(node5);
        binaryTree.setRoot(root);

        System.out.println("  前序遍历 ");
        binaryTree.preOrder();

        System.out.println("  中序遍历 ");
        binaryTree.infixOrder();

        System.out.println("  后序遍历 ");
        binaryTree.postOrder();

        //前序遍历
        //次数 4
//        System.out.println("前序遍历 ~~");
//        HeroNode res = binaryTree.preOrderSearch(5);
//        if (res != null){
//            System.out.printf("找到了,信息为 no = %d name = %s",res.getNo(),res, node2.getName());
//        }else{
//            System.out.printf("没有找到 no = %d 的英雄",5);
//        }
        //中序遍历
        //次数 3
//        System.out.println("中序遍历 ~~");
//        HeroNode res = binaryTree.infixOrderSearch(5);
//        if (res != null){
//            System.out.printf("找到了,信息为 no = %d name = %s",res.getNo(),res, node2.getName());
//        }else{
//            System.out.printf("没有找到 no = %d 的英雄",5);
//        }

        //后序遍历
        //次数 2
        System.out.println("后序遍历 ~~");
        HeroNode res = binaryTree.postOrderSearch(5);
        if (res != null){
            System.out.printf("找到了,信息为 no = %d name = %s",res.getNo(),res, node2.getName());
        }else{
            System.out.printf("没有找到 no = %d 的英雄",5);
        }


        //删除节点
        System.out.println("删除节点，前序遍历");
        binaryTree.del(4);
        System.out.println("删除节点后，前序遍历");
        binaryTree.preOrder();

    }
}

//创建一个二叉树
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("二叉树为空~");
        }
    }
    //前序遍历
    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;
        }
    }
    public void del(int no){
        if (root != null){
            //如果只有一个root结点，这里立即判断root 是不是要删除的点
            if (root.getNo() == no){
                root = null;
            }else{
                //递归删除
                root.del(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 +
                '}';
    }

    //前序遍历
    public void preOrder() {
        //1.输出父节点
        System.out.println(this);
        //2.递归向左子树前序遍历
        if (this.left != null) {
            this.left.preOrder();
        }
        //3.递归向右子树前序遍历
        if (this.right != null) {
            this.right.preOrder();
        }
    }

    //中序遍历
    public void infixOrder() {
        //1.递归向左子树前序遍历
        if (this.left != null) {
            this.left.infixOrder();
        }
        //2.输出父节点
        System.out.println(this);
        //3.递归向右子树前序遍历
        if (this.right != null) {
            this.right.infixOrder();
        }
    }

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


    /**
     * 前序遍历查找
     * @param no 查找no
     * @return 找到就返回 Node 没有就返回null
     */
    public HeroNode preOrderSearch(int no){
        System.out.println("进入前序遍历：");
        //比较当前的结点是不是
        if (this.no == no){
            return this;
        }
        //1.判断当前结点的左子结点是否为空，如果不为空，则递归前序查找
        //2.如果左递归前序查找，找到结点，则返回
        HeroNode res = null;
        if (this.left != null){
            res = this.left.preOrderSearch(no);
        }
        if (res != null){
            return res;
        }
        //1.左递归前序查找，找打结点，则返回，否则继续判断
        //2.当前结点的右子结点是否为空，如果不为空，则右递归前序查找
        if (this.right != null){
            res = this.right.preOrderSearch(no);
        }
        return res;
    }
    //中序
    public HeroNode infixOrderSearch(int no){
        //1.判断当前结点的左子结点是否为空，如果不为空，则递归中序查找
        HeroNode res = null;
        if (this.left != null){
            res = this.left.infixOrderSearch(no);
        }
        if (res != null){
            return res;
        }
        System.out.println("进入中序查找~");
        //2.如果找到结点，则返回，否则继续与当前结点比较 如果是返回当前结点
        if (this.no == no){
            return this;
        }
        //3.否则继续进行右递归的中序查找
        if (this.right != null){
            res = this.right.infixOrderSearch(no);
        }
        return res;
    }
    //后序查找
    public HeroNode postOrderSearch(int no){
        //1.判断当前结点的左子结点是否为空，如果不为空，则递归后序查找
        HeroNode res = null;
        if (this.left != null){
            res = this.left.postOrderSearch(no);
        }
        if (res != null){ //找到
            return res;
        }
        //2.如果左子树没找到，则就向右子树递归进行后后序查找
        if (this.right != null){
            res = this.right.postOrderSearch(no);
        }
        if (res != null){ //找到
            return res;
        }
        System.out.println("进入后序查找~");
        //如果左右子树都没找到，就比较当前
        if (this.no == no) {
            return this;
        }
        return res;
    }

    //递归删除结点
     //1.如果删除的节点是叶子节点，则删除该该节点
     //2. 如果删除的节点非叶子节点，则删除该子树

    public void del(int no){
        //思路 ：
        //1.由于二叉树是单向的，所以我们判断当前节点的子节点是否为删除节点，而不能判断当前的节点是否为删除点
        //2.当前的节点的左子节点不为空，且左子节点就是删除节点 this.lest = null ; 返回 结束递归删除
        //3.当前的节点的右子节点不为空，且右子节点就是删除节点 this.right = null ; 返回 结束递归删除
        //4.如果第二和第三步没有删除节点，我们就需要向左子树进行递归删除
        //5.如果第4步也没有删除节点，则应当向右子树进行递归删除


        //2.当前的节点的左子节点不为空，且左子节点就是删除节点 this.lest = 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.del(no);
        }
        //5.应当向右子树进行递归删除
        if (this.right != null) {
            this.right.del(no);
        }
    }
}
Syx...
关注
二叉树_二叉树遍历_
10-04
1.二叉树的基本操作实现【问题描述】建立一棵二叉树，用递归方法实现二叉树的如下基本操作：（1）按先序序列构造一棵二叉链表表示的二叉树T；（2）对这棵二叉树进行遍历：先序、中序、后序以及层次遍历，分别输出...
二叉树 基础
03-08
在计算机科学中，二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。 二叉树的每个结点至多只有二棵子树...
将满二叉树转化为求和二叉树_二叉树_
09-30
在IT领域，特别是数据结构和算法的学习中，二叉树是一种重要的抽象数据类型。满二叉树是一种特殊的二叉树，其中每一层都是完全填充的，除了可能的最后一层，且最后一层的所有节点都尽可能地向左靠拢。而将满二叉树...
平衡二叉树
03-03
平衡二叉树Java实现，平衡二叉树Java实现，平衡二叉树Java实现，平衡二叉树Java实现，
线索二叉树
04-10
通过前序序列创建线索二叉树 1:中序遍历 2:查找节点前驱后继 3:插入节点 4:删除节点 0:退出
二叉树建立遍历
01-03
二叉树是一种重要的数据结构，它由节点组成，每个节点有两个子节点，分别称为左子节点和右子节点。在计算机科学中，二叉树被广泛应用于搜索、排序、表达式解析等多种场景。本主题主要关注的是二叉树的建立以及它的...
二叉树代码
04-29
在计算机科学中，二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。 二叉树的每个结点至多只有二棵子树...
二叉树深度_二叉树查询_二叉树深度_
10-01
二叉树是一种在计算机科学中广泛应用的数据结构，它由节点（也称为结点）组成，每个节点最多有两个子节点，通常称为左子节点和右子节点。二叉树的深度是指从根节点到最远叶节点的最长路径上边的数目，即树的最大层数...
有值二叉树
04-15
根据给定的信息，“有值二叉树”这一概念在IT领域通常是指一种特殊的二叉树结构，其中每个节点都包含具体的数值或者数据信息。在计算机科学中，二叉树是一种非常重要的数据结构，广泛应用于算法设计、数据组织与管理...
数据结构二叉树实验头文件
12-10
在计算机科学中，二叉树是每个结点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。 一棵深度为k，且有2^k-1个结点的...
递归方式遍历二叉树
09-27
java实现创建二叉树，并且遍历二叉树（此处使用递归方式遍历）； 创建二叉树的方式有很多，此处使用线性的链表转化成二叉树，链表节点的顺序就是前序遍历的顺序，链表中的null值，代表二叉树左节点或者右节点为null...
广义表创建二叉树及二叉树输出广义表
12-24
在计算机科学中，二叉树是一种特殊的图结构，其中每个节点最多有两个子节点，通常分为左子节点和右子节点。而广义表（Generalized List）是抽象数据类型的一种，它可以表示各种复杂的结构，包括链表、树等。本话题...
二叉树的遍历
11-07
二叉树的遍历，先序遍历，中序遍历，后续遍历。.
二叉树先根（先序）遍历的改进
09-04
二叉树是一种特殊的树结构，每个节点最多有两个子节点，分为左子节点和右子节点。在二叉树遍历中，先根遍历（先序遍历）是一种常见的访问方式，它按照“根-左-右”的顺序访问每个节点。在本文中，我们将深入探讨...
LeetCode 二叉树的直径
12-22
文章目录二叉树的直径题目解题思路代码实现实现结果 二叉树的直径 题目来源：https://leetcode-cn.com/problems/diameter-of-binary-tree/ 题目 给定一棵二叉树，你需要计算它的直径长度。一棵二叉树的直径长度是...
《数据结构》--队列【各种实现，算法推荐】
最新发布
Stark的博客
10-06 790
队列是一种常见的数据结构，按照先进先出（FIFO，First In First Out）的原则排列数据。也就是说，最早进入队列的元素最先被移除。：将元素添加到队列的尾部。：从队列的头部移除并返回元素。：初始化一个空队列。：返回但不移除队列的头部元素（通常称为“peek”或“front”）。：检查队列中是否还有元素。：返回队列中元素的数量。
数据结构之图（6）
2301_76246515的博客
10-05 1000
图G有顶点集V和边集E组成，记为G=(V,E),其中V（G）表示图G中顶点的有限非空集；E(G)表示图G中顶点之间的关系（边）集合。若V={v1,v2,…，vn}，则用|V|表示图G中顶点的个数。也称为图G的阶E={（u,v)|u ∈​​​V},用|E|表示图G中边的条数图不可以是空，V一定是非空集E是无向边（简称边）的有限集合E是有向边（弧）的有限集合弧是顶点的有序对，记为<v,w>,v为弧尾，w为弧头不存在重复边不存在顶点到自身的边。
C语言 动态数据结构的C语言实现内存映像
hangweijie的博客
10-04 468
在程序运行期间，用动态内存分配函数来申请的内 存都是从堆上分配的，动态内存的生存期由程序员 自己来决定。在执行函数调用时，系统在栈上为函数内的局部变 量及形参分配内存，函数执行结束时，自动释放这 些内存。在执行函数调用时，系统在栈上为函数内的局部变 量及形参分配内存，函数执行结束时，自释放这 些内存。存放函数参数值，局部变量值等。存放函数参数值，局部变量值等。C程序中变量的内存分配方式。C程序中变量的内存分配方式。C程序中变量的内存分配方式。C程序中变量的内存分配方式。
C语言二叉树性质详解
C语言公共基础部分之二叉树性质 根据给定的文件信息，我们可以总结出以下知识点： 1. 二叉树的定义：二叉树是树形结构的一个重要类型，由n个结点的有限集组成，或者是空集，或者由一个根结点及两棵互不相交的、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值