数据结构与算法——二叉树

最新推荐文章于 2024-08-11 20:00:32 发布
最新推荐文章于 2024-08-11 20:00:32 发布
阅读量504 收藏 7
点赞数 7
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45942515/article/details/140635509
版权

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

  • 数组存储方式的分析

    • 优点：通过下标方式访问元素，速度快。对于有序数组，还可以使用二分查找来提高检索速度。
    • 缺点：如果要检索具体某个值，或者插入值（按一定顺序）会整体移动，效率低
      在这里插入图片描述

  • 链式存储方式的分析

    • 优点：在一定程度上对数组存储方式有优化（比如：插入一个数值节点，只需要将插入节点，链接到链表中即可，删除效率也很高）
    • 缺点：在进行检索时，效率仍然很低（比如检索某个值，需要从头检点开始遍历）
    • 在这里插入图片描述

  • 树存储方式的分析

    • 能提高数据存储，读取的效率，比如使用二叉排序树，即可以保证数据的检索速度，同时也可以保证数据的插入，删除，修改的速度。
    • 在这里插入图片描述在这里插入图片描述

2. 树的示意图和常用术语

在这里插入图片描述

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

3. 二叉树的概念

1）树有很多种，每个节点最多只能有两个子节点的一种形式称为二叉树
2）二叉树的子节点分别为左节点和有节点。
在这里插入图片描述

3） 如果该二叉树的所有叶子节点都在最后一层，并且节点总数= 2ⁿ - 1，n为层数，则我们称为满二叉树
在这里插入图片描述
4）如果该二叉树的所有叶子节点都在最后一层或倒数第二层，而且最后一层的叶子节点在左边连续，倒数第二层的叶子节点在右边连续，我们称为完全二叉树。
在这里插入图片描述

4. 二叉树遍历的说明

使用前序、中序和后序对下面的二叉树进行遍历：
1）前序遍历：先输出父节点，再遍历左子树和右子树
2）中序遍历：先遍历左子树，再输出父节点，再遍历右子树
3）后序遍历：先遍历左子树，再遍历右子树，最后输出父节点
小结：看输出父节点的顺序

public class BinaryTreeDemo {
    public static void main(String[] args) {
        // 先创建一个二叉树
        BinaryTree binaryTree = new BinaryTree();
        // 创建需要的节点
        HeroNode root = new HeroNode(1,  "宋江");
        HeroNode heroNode2 = new HeroNode(2,  "吴用");
        HeroNode heroNode3 = new HeroNode(3,  "卢俊义");
        HeroNode heroNode4 = new HeroNode(4,  "林冲");
        HeroNode heroNode5 = new HeroNode(5,  "关胜");

        // 我们先手动创建该二叉树，后面我们学习递归的方式创建二叉树
        root.setLeft(heroNode2);
        root.setRight(heroNode3);
        heroNode3.setRight(heroNode4);
        heroNode3.setLeft(heroNode5);
        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("二叉树为空，无法遍历");
        }
    }

    // 中序遍历
    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);
    }
}

5. 使用前序、中序、后序的方式来查询指定的节点

在这里插入图片描述

public class BinaryTreeDemo {
    public static void main(String[] args) {
        // 先创建一个二叉树
        BinaryTree binaryTree = new BinaryTree();
        // 创建需要的节点
        HeroNode root = new HeroNode(1,  "宋江");
        HeroNode heroNode2 = new HeroNode(2,  "吴用");
        HeroNode heroNode3 = new HeroNode(3,  "卢俊义");
        HeroNode heroNode4 = new HeroNode(4,  "林冲");
        HeroNode heroNode5 = new HeroNode(5,  "关胜");

        // 我们先手动创建该二叉树，后面我们学习递归的方式创建二叉树
        root.setLeft(heroNode2);
        root.setRight(heroNode3);
        heroNode3.setRight(heroNode4);
        heroNode3.setLeft(heroNode5);
        binaryTree.setRoot(root);

        // 测试前序遍历
        System.out.println("前序遍历:");
        binaryTree.preOrder();

        // 测试中序遍历
        System.out.println("中序遍历:");
        binaryTree.infixOrder();

        // 测试后序遍历
        System.out.println("后序遍历:");
        binaryTree.postOrder();

        // 前序遍历
        System.out.println("前序遍历方式··");
        HeroNode node = binaryTree.preOrderSearch(5);
        if(node != null) {
            System.out.printf("找到了，信息为 no=%d name=%s", node.getNo(), node.getName());
        } else {
            System.out.printf("没有找到 no = %d 的英雄", 5);
        }

    }
}

// 定义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("二叉树为空，无法遍历");
        }
    }

    // 中序遍历
    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;
        }
    }
}


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

    // 前序遍历查找
    public HeroNode preOrdersearch(int no) {
        // 比较当前节点是不是
        if(this.no == no) {
            return this;
        }
        // 1、判断当前节点的左子节点是否为空，如果不为空，则递归前序查找
        // 2、如果左递归前序查找，找到节点，则返回
        HeroNode resNode = null;
        if(this.left != null) {
            resNode = this.left.preOrdersearch(no);
        }
        if(resNode != null) { // 说明我们左子树找到
            return resNode;
        }
        // 1、左递归前序查找，找到节点，则返回，否继续判断
        // 2、当前节点的右子节点是否为空，如果不空，则继续向右递归前序查找
        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.postOrderSearch(no);
        }
        if(resNode != null) {
            return resNode;
        }
        // 如果左右子树都没有找到，就比较当前节点是不是
        if(this.no == no) {
            return this;
        }
        return resNode;
    }
}

6. 二叉树删除节点思路图解

完成删除节点的操作：
规定：
1）如果删除节点是叶子节点，则删除该节点
2）如果删除的节点是非叶子节点，则删除该子树

思路
1、因为我们的二叉树是单向的，所以我们是判断当前节点的子节点是否需要删除节点，而不能去判断当前这个节点是不是需要删除节点
2、如果当前节点的左子节点不为空，并且左子节点就是要删除的节点，就将this.left = null；并且就返回（结束递归删除）
3、如果当前节点的右子节点不为空，并且右子节点就是要删除节点，就将this.right = null; 并且就返回（结束递归删除）
4、如果第2和第3步没有删除节点，那么我们就需要向左子树进行递归删除
5、如果第4步也没有删除节点，则应当向右子树进行递归删除
6、考虑如果树是空树root，如果只有一个root节点，则等价将二叉树置空

package com.sss.tree;

public class BinaryTreeDemo {
    public static void main(String[] args) {
        // 先创建一个二叉树
        BinaryTree binaryTree = new BinaryTree();
        // 创建需要的节点
        HeroNode root = new HeroNode(1,  "宋江");
        HeroNode heroNode2 = new HeroNode(2,  "吴用");
        HeroNode heroNode3 = new HeroNode(3,  "卢俊义");
        HeroNode heroNode4 = new HeroNode(4,  "林冲");
        HeroNode heroNode5 = new HeroNode(5,  "关胜");

        // 我们先手动创建该二叉树，后面我们学习递归的方式创建二叉树
        root.setLeft(heroNode2);
        root.setRight(heroNode3);
        heroNode3.setRight(heroNode4);
        heroNode3.setLeft(heroNode5);
        binaryTree.setRoot(root);

        // 测试前序遍历
        System.out.println("前序遍历:");
        binaryTree.preOrder();

       // 测试删除节点
        System.out.println("删除前遍历");
        binaryTree.delNode(5);
        System.out.println("删除后遍历");

    }
}

// 定义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.printf("空树，不能删除");
        }
    }

    // 前序遍历
    public void preOrder() {
        if(this.root != null) {
            this.root.preOrder();
        } 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 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);
        }
    }

    // 编写前序遍历的方法
    public void preOrder() {
        System.out.println(this);// 先输出父节点
        // 递归向左子树前序遍历
        if(this.left != null) {
            this.left.preOrder();
        }
        // 递归向右子树前序遍历
        if(this.right != null) {
            this.right.preOrder();
        }
    }
}
csunool
关注
  • 7
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构与算法——二叉树的建立与遍历
04-21
完成二叉树的建立然后分别先序中序后序遍历二叉树并算出二叉树的高度和叶节点的个数
数据结构——二叉树的生成与遍历
02-18
数据结构，实现二叉树的生成与遍历的算法。包含利用先序、中序、后序遍历二叉树算法，二叉树基本操作。（注意没有左子树或右子树时用@或#作为结束符号）
数据结构与算法——二叉树+带你实现表达式树（附源码）
热爱编程的小K的博客
03-22 1742
数据结构与算法——无序二叉树，先中后遍历，查找，插入，思想，图解，表达式树一应具有，带你深入浅出了解二叉树
数据结构与算法——二叉树的性质
m0_52792591的博客
02-14 90
主要讲二叉树的性质，三个性质总感觉很重要，前面两个性质也很好证明
数据结构与算法——二叉树的实现与原理
m0_62179366的博客
05-27 3269
目录 一、二叉树的原理 1.二叉树的基本概念 2.树的性质 3.二叉树的性质 二、二叉树的实现 1.二叉树的定义 2.二叉树的创建 3.前序遍历 4.中序遍历 5.后序遍历 6.层序遍历 7.二叉树的节点的个数 8.二叉树的叶子节点的个数 9.二叉树第k层节点个数 10.二叉树查找值为x的节点 11.判断二叉树是否是完全二叉树 12.二叉树销毁 一、二叉树的原理 1.二叉树的基本概念 在电脑科学中，二叉树（英语：Binary tree）是每个节点最多只.
数据结构与算法——二叉树遍历实现
Ipkiss Studio
04-14 959
遍历Traverse：就是按照某种次序访问所有节点，且每个节点恰好访问一次。 树的遍历可以看成是人为的将非线性结构线性化 将树看成三个部分：左子树、右子树、根 遍历的方法三种： 先序DLR：根、左子树、右子树 中序LDR：左子树、根、右子树 后序LRD：左子树、右子树、根 采用了递归的思路 面试题:有一个二叉树，它的后序遍历序列为5 4 3 7 6 2 1，中序遍历的序列为4 5 1 3 2 6 7，则其先序遍历的序列是什么？ 先序：1452367 实现： 先创建二叉树
数据结构与算法——二叉树的深度优先遍历
python全栈
11-21 557
例1：写出这棵树的先序遍历,中序遍历,后序遍历结果 1、先序遍历 遍历顺序：根节点——>左子树——>右子树 遍历结果：A—>B—>D—>H—>E—>C—>F—>G 2、中序遍历 遍历顺序：左子树——>根节点——>右子树 遍历结果：H—>D—>B—>E—>A—>F—>C—>G 3、后序遍历 遍历顺序：左子树——>右子树——>根节点 遍历结果：H—>D—>E—>B—>
数据结构与算法——二叉树（下）
caicaptain
05-31 127
讲解数据结构与算法——二叉树（下）
Java数据结构与算法——二叉树前中后序遍历 & 查找 & 删除
★★光亭★★
03-21 5304
Java数据结构与算法——二叉树前中后序遍历 & 查找 & 删除
数据结构与算法——二叉树（上）
caicaptain
05-31 121
讲解数据结构与算法——二叉树（上）
数据结构与算法 —— 二叉树 01
weixin_30832143的博客
05-31 96
上节介绍了二叉树的一些基本概念，这篇文章开始，我们开始学习二叉树的一些算法问题，今天先看一些层次遍历的题目。 二叉树的层次遍历 题目 给定一个二叉树，返回其按层次遍历的节点值。 （即逐层地，从左到右访问所有节点）。 例如:给定二叉树:[3,9,20,null,null,15,7], 3 / \ 9 20 / \ 15 7 返回其层...
武汉理工大学计算机数据结构与算法实验一——二叉树与哈夫曼图片压缩
06-03
(1)掌握树的存储结构 (2)掌握二叉树的三种遍历方法 (3)掌握并理解Huffman树、Huffman编码等知识和应用 (4)掌握文件的操作 (5)使用Huffman算法实现图像压缩程序 2.实验内容 使用Huffman压缩算法，对一幅BMP格式的...
广工数据结构实验——平衡二叉树
07-06
本实验“广工数据结构实验——平衡二叉树”着重探讨了一种特殊类型的数据结构，即平衡二叉树。平衡二叉树是二叉搜索树（Binary Search Tree, BST）的一个变体，它通过保持树的高度平衡来确保查找、插入和删除操作的...
数据结构与算法——专栏索引篇
01-20
数据结构与算法是计算机科学的基础，对于任何编程领域而言，理解和掌握它们都是至关重要的。本专栏将通过C语言这一基础且灵活的语言来深入探讨这些概念，以提供更全面的实践训练。C语言的特性使得在实现数据结构和...
（javaweb）请求响应postman
2301_79144798的博客
08-08 482
1.Tomcat又称为servlet容器前端浏览器发起请求携带http请求数据，web服务器负责请求协议的解析，Tomcat接收请求数据，并对请求数据进行解析。Tomcat将解析后所有的信息封装到一个对象当中：HttpServletRequest（请求对象）---应用程序从中获取请求数据。HttpServletResponse--通过这个对象设置要响应的数据 --响应信息给浏览器浏览器--服务器：：BS架构（通过浏览器能访问到的网站：京东 淘宝 天猫 唯品会都是BS架构）
SpringBoot快速入门（手动创建）
最新发布
m0_74124657的博客
08-11 269
代码如下//引导类项目的入口//注解添加导入进来你可以浏览器中查看自己编写的代码，看是否正确localhost：你命名的端口号（默认是8080。后面你也可以在配置文件修改）
springboot民办高校科研项目管理系统-计算机毕业设计源码54009
VX_DZbishe的博客
08-11 235
论文主要是对基于springboot的民办高校科研项目管理系统进行了介绍，包括研究的现状，还有涉及的开发背景，然后还对系统的设计目标进行了论述，还有系统的需求以及整个的设计方案，对系统的设计以及实现，也都论述的比较细致，最后对基于springboot的民办高校科研项目管理系统进行了一些具体测试。本次报告，首先分析了研究的背景、作用、意义，为研究工作的合理性打下了基础。
Spring事务
c1tenj2的博客
08-07 450
以银行转账为例，一次转账操作伴随着一个账户的扣钱和另一个账户的加钱，这个流程是一个原子操作，要么同时发生，一气呵成，要么都不做。AccountServiceImpl实现AccountService接口，里面只有一个转账方法AccountMapper以及其映射文件account数据库测试代码用1/0模拟程序运行时出现异常的情况由于没有开启事务，出现了莫名其妙少了100块钱的情况，说明这个事务不是连续的。
Java算法与数据结构测试——二叉树
04-06
二叉树是一种树形结构，其中每个节点最多有两个子节点。一个节点的左子节点比该节点小，右子节点比该节点大。二叉树通常用于搜索和排序。 2. 二叉树的遍历方法有哪些？ 二叉树的遍历方法包括前序遍历、中序遍历和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值