数据结构：树的遍历、查找和删除，整树创建

已于 2022-07-20 18:15:32 修改
阅读量656 收藏 3
点赞数
文章标签： 数据结构
于 2022-02-09 12:34:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63544124/article/details/122819344
版权

遍历

 

public class HeroNode {
    private int no;
    private String name;
    private HeroNode left;
    private HeroNode right;

    public HeroNode() {
    }

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

    //中序遍历
    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 class BinaryTree {
    private HeroNode root;

    public HeroNode getRoot() {
        return root;
    }

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

    //前序遍历
    public void preOderTree() {
        if (this.root != null) {
            this.root.proOrder();
        }
    }

    //中序遍历
    public void infixOrdeTree() {
        if (this.root != null) {
            this.root.infixOrder();
        }
    }

    //后序遍历
    public void postOderTree() {
        if (this.root != null) {
            this.root.postOrder();
        }
    }
}
public class BinaryTreeDemo {
    public static void main(String[] args) {
        BinaryTree bt = new BinaryTree();
        HeroNode node1 = new HeroNode(1, "宋江");
        HeroNode node2 = new HeroNode(2, "吴用");
        HeroNode node3 = new HeroNode(3, "卢俊义");
        HeroNode node4 = new HeroNode(4, "林冲");
        HeroNode node5 = new HeroNode(5, "关胜");
        bt.setRoot(node1);
        node1.setLeft(node2);
        node1.setRight(node3);
        node3.setLeft(node5);
        node3.setRight(node4);

        bt.preOderTree();//前序遍历：12354
        bt.infixOrdeTree();//中序遍历：21534
        bt.postOderTree();//后序遍历：25431
    }
}

查找

 public class HeroNode {
    private int no;
    private String name;
    private HeroNode left;
    private HeroNode right;

   //前序查找
    public HeroNode preOderSearch(int no) {
        System.out.println("进入前序查找");
        if (this.no == no) {
            return this;
        }
        HeroNode resNode = null;
        if (this.left != null) {
            resNode = this.left.preOderSearch(no);
        }
        if(resNode!=null){
            return resNode;
        }
        if (this.right != null) {
            resNode = this.right.preOderSearch(no);
        }
        return resNode;
    }

    //中序查找
    public HeroNode infixOderSearch(int no) {
        HeroNode resNode=null;
        if(this.left!=null){
            resNode=this.left.infixOderSearch(no);
        }
        if(resNode!=null){
            return resNode;
        }
        System.out.println("进入中序查找");
        if(this.no==no){
            return this;
        }
        if(this.right!=null){
            resNode=this.right.infixOderSearch(no);
        }
        return resNode;
    }

    //后序查找
    public HeroNode postOderSearch(int no) {
        HeroNode resNode=null;
        if(this.left!=null){
            resNode=this.left.postOderSearch(no);
        }
        if(resNode!=null){
            return resNode;
        }
        if(this.right!=null){
            resNode=this.right.postOderSearch(no);
        }
        if(resNode!=null){
            return resNode;
        }
        System.out.println("进入后序查找");
        if(this.no==no){
            return this;
        }
        return resNode;
    }
}

public class BinaryTree {
    private HeroNode root;

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

    //中序查找
    public HeroNode infixOderTreeSearch(int no) {

        if (this.root != null) {
            return this.root.infixOderSearch(no);
        } else {
            return null;
        }
    }

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

删除

 public class BinaryTree {
    private HeroNode root;

    //删除
    public HeroNode delTreeNode(int no) {
        if (this.root == null) {
            System.out.println("此树为空");
            return null;
        } else {
            if (this.root.getNo() == no) {
                HeroNode resNode = null;
                this.root = null;
                return resNode;
            } else {
                return this.root.delNode(no);
            }
        }
    }

    //删除2
    public HeroNode delTreeNode2(int no) {
        if (this.root == null) {
            System.out.println("此树为空");
            return null;
        }
        if (this.root.getNo() == no) {
            HeroNode resNode = null;
            this.root = null;
            return resNode;
        }
        return this.root.delNode2(no);
    }
}


public class HeroNode {
    private int no;
    private String name;
    private HeroNode left;
    private HeroNode right;

    //删除
    public HeroNode delNode(int no) {
        HeroNode resNode = null;
        if (this.left != null && this.left.no == no) {
            resNode = this.left;
            this.left = null;
            return resNode;
        }
        if (this.right != null && this.right.no == no) {
            resNode = this.right;
            this.right = null;
            return resNode;
        }
        if (this.left != null) {
            resNode = this.left.delNode(no);
        }
        if (this.right != null) {
            resNode = this.right.delNode(no);
        }
        return resNode;
    }

    //删除2
    public HeroNode delNode2(int no) {
        HeroNode resNode = null;
        if (this.left != null) {
            if (this.left.no == no) {
                resNode = this.left;
                this.left = null;
                return resNode;
            } else {
                resNode = this.left.delNode(no);
            }
        }
        if (this.right != null) {
            if (this.right.no == no) {
                resNode = this.right;
                this.right = null;
                return resNode;
            } else {
                resNode = this.right.delNode(no);
            }
        }
        return resNode;
    }
}

整树创建：通过先序遍历结果建立二叉树

 

public class ThreadedBinaryTreeDemo {
    public static void main(String[] args) {
//        ThreadedBinaryTree tbt = new ThreadedBinaryTree();
//        Node node1 = new Node(1);
//        Node node3 = new Node(3);
//        Node node6 = new Node(6);
//        Node node8 = new Node(8);
//        Node node10 = new Node(10);
//        Node node12 = new Node(12);
//        Node node14 = new Node(14);
//        Node node16 = new Node(16);
//        tbt.setRoot(node1);
//        node1.left = node3;
//        node1.right = node6;
//        node3.left = node8;
//        node3.right = node10;
//        node8.right = node12;
//        node6.left = node14;
//        node14.right = node16;
//        tbt.getRoot().preOrder();//1 3 8 12 10 6 14 16
//        System.out.println();
//        tbt.getRoot().infixOrder();//8 12 3 10 1 14 16 6
//        System.out.println();
//        tbt.getRoot().postOrder();//12 8 10 3 16 14 6 1
//        System.out.println();

        //根据先序遍历结果创建二叉树
        ThreadedBinaryTree tbt = new ThreadedBinaryTree();
        int[] arr = {1, 3, 8, 0, 12, 0, 0, 10, 0, 0, 6, 14, 0, 16, 0, 0, 0};
        Node root = tbt.createTree(arr);
        root.preOrder();//1 3 8 12 10 6 14 16
        System.out.println();
        root.infixOrder();//8 12 3 10 1 14 16 6
        System.out.println();
        root.postOrder();//12 8 10 3 16 14 6 1
    }
}

public class ThreadedBinaryTree {
    private Node root;

    public Node getRoot() {
        return root;
    }

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

    public static int num = 0;

    public Node createTree(int[] arr) {
        if (num  >= arr.length) {
            return null;
        }
        Node root = null;
        if (arr[num] != 0) {
            root = new Node(arr[num]);//创建当前节点
            num++;
        }
        if (arr[num] != 0) {
            root.left = createTree(arr);
        } else {
            root.left = null;
            num++;
        }
        if (arr[num] != 0) {
            root.right = createTree(arr);
        } else {
            root.right = null;
            num++;
        }
        return root;
    }
}

public class Node {

    public int no;
    public Node left;
    public Node right;

    public Node() {
    }

    public Node(int no) {
        this.no = no;
    }

    public void preOrder() {
        System.out.print(this.no + " ");
        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.print(this.no + " ");
        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.print(this.no + " ");
    }
}

m0_63544124
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
树的增删改查
Mr.田的博客
11-07 921
package Tree; import java.util.Stack; //定义树节点 class TreeNode{ int val; TreeNode left; TreeNode right; TreeNode(int x){ val=x; } } //我想要跟链表一样实现一个树的增删改查 //1.建立一个二叉树TreeBuild(); //2.增 add(TreeNode root); //3.删delete(TreeNode root
数据结构和算法——树结构（二叉树的创建、查找、遍历和删除）
zhupup
11-15 400
（1）二叉树    二叉树的任意一个节点的子节点不超过两个。 （2）满二叉树    所有的叶子节点都在最后一层，而且节点的总数为2^-1，n是树的高度。 （3）完全二叉树    完全二叉树的所有叶子节点都在最后一层或者倒数第二层，并且倒数第二层的叶子节点从右向左连续，最后一层的叶子节点从左向右连续。 （4）二叉树的链式存储结构 （5）二叉树的代码实现（创建、添加节点、遍历节点、删除节点）  ...
遍历树查找
11-25 268
<br />function blTree(const NodeCaption: string): TTreeNode;<br />    function GetNode(node: TTreeNode): TTreeNode; <br />    var <br />        I:integer; <br />    begin<br />        Result := nil;<br />        if node.Text = NodeCaption then<br />       
java-数据结构-前中后序查找
e891377的专栏
08-08 168
java-数据结构-前中后序查找 前序遍历查找 //前序遍历查找 /** * * @param no 查找no * @return 如果找到就返回该Node ,如果没有找到返回 null */ public HeroNode preOrderSearch(int no) { System.out.println("进入前序遍历"); //比较当前结点是不是 if...
数据结构---二叉树(遍历查找)
qq_45115146的博客
08-14 481
数据结构-树遍历
二叉树的遍历查找
单引号的博客
08-13 283
二叉树的遍历创建节点、包含插入、查找、删除节点创建树测试 创建节点、包含插入、查找、删除节点 //定义一个树节点 class Node { int id; Node left; Node right; public Node(int id) { this.id = id; } //前序遍历 public void pre(Node node) { if(node==null) { return ; } System.out.print(node.id + " ");
javascript数据结构之多叉树经典操作示例【创建、添加、遍历、移除等】
10-18
多叉树是数据结构中的一种重要结构，它能够有效地存储具有层级关系的数据，如组织结构、目录结构等。在JavaScript中，多叉树可以通过面向对象的方式构建，其中，节点（Node）是构成多叉树的基础，而树（Tree）则是由...
数据结构实验：B树及关键字的插入，删除和按层次遍历.doc
05-04
B树作为一种高效的数据结构，其插入、删除和查找操作具有良好的时间复杂度，尤其适合大数据量的场景。实验通过实现这些操作，使学生深入理解B树的工作原理和特性，同时也提供了实际操作的机会，有助于巩固理论知识。
swift代码-swift数据结构：树
07-16
3. 数据库索引：B树和B+树等数据结构用于高效地存储和检索大量数据。 在`main.swift`文件中，可能包含了具体实现这些概念的示例代码，例如创建树节点、插入节点、遍历树等操作。而`README.txt`可能包含了关于代码的...
数据结构:树与图
yeye924的博客
09-23 927
树图结构树型结构：树的相关术语：树的种类：二叉树的性质：二叉树的种类：有序二叉树：线索二叉树：堆：哈夫曼树：平衡二叉树：二叉树的链式存储：二叉树的顺序存储：二叉树的遍历：图图的相关术语:图的存储:图的遍历: 树型结构： 元素之间存在一对多关系的数据结构，适合存储具有层次关系的数据模型，如：文件树、组织关系、族谱。 树的相关术语： 根结点：树的最顶层结点，一棵树最多只有一个根结点。 双亲结点、父结点：结点的上一层结点，一个结点只有唯一一个双亲结点。 子结点：结点的下层结点，可以有若干个。 叶子节点：没有子结点
数据结构二叉树的遍历、查找、删除
freshing123的博客
02-07 401
数据结构树，二叉树，后续有理解到的或有用到在新增，其他很多高级树多是基于二叉树， 主要来自慕课 此处知乎上的一些说法，可进一步根据这些深入学习，现在还未学习数据库和后台，先了解下， 主要用途多是查找、删除、插入等的操作 二叉树 定义： 应用 code function BinaryTree (){ // "use strict"; var Node = functi
树的三种遍历三种查找, 还有顺序存储, 中序线索化以及线索化之后如何遍历
weixin_45032905的博客
11-18 663
树: 能提高数据的存储, 读取的效率 例如二叉排序树 既可以保证数据的检索速度, 还能保证数据的插入, 删除, 修改的速度 遍历二叉树的三种方式 看父节点的输出顺序 有前序, 中序, 和后序 前序: 先输出父节点, 再遍历左子树和右子树 中序: 先遍历右子树, 在输出父节点, 最后遍历右子树 后序: 先遍历左子树, 再遍历右子树, 最后输出父节点 示例 手动创建一个这样的二叉树, 并遍历 public class ErChaShuTest { public static void main(S.
001数据结构之树增删改查介绍
热爱编写程序的药学在读书
11-03 595
这篇文章讲解关于树的一系列知识，后续可能会根据知识点的数量分开写成多个文章，你可以从中获取如下知识： 对之前已有的存储方式回顾 对树有个简单的了解 问题引入：为什么需要树这种结构呢？ 一、已知的存储方式回顾 1、数组的优点与缺点 可以方便查找，排序等 当他数据满之后，当要插入数据的，都会降低效率。 比如我们的ArrayList这个类，它也是按一定的比例来扩容。 2、链表的优点与缺点 链表摒弃了数组的浪费内存，但是它仍然存在检索比较浪费时间的。 3、需要原因 能提高数据存储，读取得效率，比如利
【数据结构7-2】-二叉排序树（建立、遍历、查找、增加、删除）
最新发布
w384829981的博客
04-26 1008
二叉树的建立、查找和修改-C语言
JavaScript数据结构与算法 --树的遍历和搜索（2）
qq_43955202的博客
03-09 168
12.遍历二叉搜索树 前面，我们向树中插入了很多的数据，为了能更好的看到测试结果，我们先来学习一下树的遍历。 注意：我们这里学习了树的遍历，针对所有的二叉树都是适用的，不仅仅二叉搜索树。 树的遍历： 建立二叉树 遍历一棵树是指访问的树的每个节点(也可以对每个节点进行某些操作，我们这里就是简单的打印) 但是树和线性结构不太一样，线性结构我们通常按照从前到后的顺序遍历。 应该从树的顶端还是底端...
binary-tree-preorder-traversal（二叉树前序遍历）
傻月菇凉的博客
08-22 2028
题目描述 Given a binary tree, return the preorder traversal of its nodes’ values. For example:Given binary tree{1,#,2,3},return[1,2,3]. Recursive solution is trivial, could you do it iteratively? 翻译：给定二...
树形结构递归遍历，根据某个属性值查找其所在的对象
热门推荐
摆脱菜鸟，砥砺前行
11-07 1万+
今天在做一个组织结构图时，图是用一个树来表示的，有唯一的根节点以及若干个子节点，二话不说我瞬间就写出来了这个结构，我的定义如下： var data = { id: 1, name: "根节点", children:[{ id: 2, name: "节点1", children: [{ i...
前端 -- 树结构过滤（数遍历查询）
sodakii的博客
09-05 1380
树结构的复杂性决定了不能通过一次遍历解决，那么肯定需要用到递归调用
树的前序遍历、中序遍历、后序遍历及查找
Eliot的博客
04-19 2442
树的前序遍历、中序遍历、后序遍历及查找 近日学习了二叉树，之前对其遍历和操作有些疑惑，今天重新打了一遍代码好像悟了些许东西出来，浅浅的讲述一下吧。 首先是中规中矩的树图。 遍历 前序遍历 先上java实现代码 public void preOrder(){ //输出当前节点 System.out.println(this); //如果当前节点的左子树不为空，则递归调用 if (this.left != null){ this.left.preOrder(); } //如果当前节点的右子树不
Java数据结构复习：二叉树遍历详解
"Java基础复习笔记08数据结构-二叉树和二叉树的遍历" 这篇笔记主要探讨了Java中的数据结构——二叉树及其遍历方法。二叉树是一种非线性数据结构，每个节点最多有两个子节点，通常分为左子节点和右子节点。在计算机...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值