Java实现二叉树的前序、中序、后序查找、删除结点

最新推荐文章于 2022-04-11 16:55:04 发布
最新推荐文章于 2022-04-11 16:55:04 发布
阅读量406 收藏 2
点赞数
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baolingye/article/details/101003063
版权

请编写前序查找，中序查找和后序查找的方法，分别使用三种查找方式，查找 num = 5 的节点

我们一这样一棵二叉树为例
在这里插入图片描述

一、前序查找

实现思路：

  1. 先判断当前节点的num是否等于要查找的，如果相等，则返回当前节点
  2. 如果不相等，则判断当前节点的左子节点是否为空，如果不为空，则递归前序查找
  3. 如果左递归前序查找找到节点则返回该节点，否则继续判断当前节点的右子节点是否为空，如果不为空，则继续右递归前序查找

代码实现：

public class BinaryTreeDemo {
    public static void main(String[] args) {
        BinaryTree binaryTree = new BinaryTree();

        PersonNode root = new PersonNode(1, "张三");
        PersonNode node2 = new PersonNode(2, "李四");
        PersonNode node3 = new PersonNode(3, "王五");
        PersonNode node4 = new PersonNode(4, "赵六");
        PersonNode node5 = new PersonNode(5, "田七");

        root.setLeft(node2);
        root.setRight(node3);
        node3.setLeft(node4);
        node3.setRight(node5);
        binaryTree.setRoot(root);

        System.out.println("前序查找：");
        PersonNode personNode = binaryTree.preOrderSearch(4);
        System.out.println(personNode);
    }
}

class BinaryTree {
    private PersonNode root;

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

    //前序查找
    public PersonNode preOrderSearch(int num) {
        if (this.root != null) {
            return root.preOrderSearch(num);
        } else {
            return null;
        }
    }

}

class PersonNode {
    private int num;
    private String name;
    private PersonNode left;
    private PersonNode right;

    public PersonNode() {
    }

    public PersonNode(int num, String name) {
        this.num = num;
        this.name = name;
    }

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public PersonNode getLeft() {
        return left;
    }

    public void setLeft(PersonNode left) {
        this.left = left;
    }

    public PersonNode getRight() {
        return right;
    }

    public void setRight(PersonNode right) {
        this.right = right;
    }

    @Override
    public String toString() {
        return "PersonNode{" +
                "num=" + num +
                ", name='" + name + '\'' +
                '}';
    }

    //前序查找
    public PersonNode preOrderSearch(int num) {
        //先判断当前节点的num是否等于要查找的，如果相等，则返回当前节点
        if (this.num == num) {
            return this;
        }

        //如果不相等，则判断当前节点的左子节点是否为空，如果不为空，则递归前序查找
        PersonNode resNode = null; //定义一个节点用来存储查找结果
        if (this.left != null) {
            resNode = this.left.preOrderSearch(num);
        }
        if (resNode != null) {
            return resNode;
        }

        //如果左递归前序查找找到节点则返回该节点，否则继续判断当前节点的右子节点是否为空，如果不为空，则继续右递归前序查找
        if (this.right != null) {
            resNode = this.right.preOrderSearch(num);
        }
        return resNode;
    }

}

二、中序查找

实现思路：

  1. 判断当前节点的左子节点是否为空，如果不为空，则递归中序查找，如果找到则返回
  2. 如果左递归没有找到，则和当前节点进行比较，如果num和当前节点的num相等则返回当前节点
  3. 若不相等，则继续进行右递归中序查找，找到就返回，否则返回null
public class BinaryTreeDemo {
    public static void main(String[] args) {
        BinaryTree binaryTree = new BinaryTree();

        PersonNode root = new PersonNode(1, "张三");
        PersonNode node2 = new PersonNode(2, "李四");
        PersonNode node3 = new PersonNode(3, "王五");
        PersonNode node4 = new PersonNode(4, "赵六");
        PersonNode node5 = new PersonNode(5, "田七");

        root.setLeft(node2);
        root.setRight(node3);
        node3.setLeft(node4);
        node3.setRight(node5);
        binaryTree.setRoot(root);

        System.out.println("中序查找：");
        PersonNode personNode = binaryTree.midOrderSearch(4);
        System.out.println(personNode);
    }
}

class BinaryTree {
    private PersonNode root;

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

    //中序查找
    public PersonNode midOrderSearch(int num) {
        if (this.root != null) {
            return root.midOrderSearch(num);
        } else {
            return null;
        }
    }

}

class PersonNode {
    private int num;
    private String name;
    private PersonNode left;
    private PersonNode right;

    public PersonNode() {
    }

    public PersonNode(int num, String name) {
        this.num = num;
        this.name = name;
    }

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public PersonNode getLeft() {
        return left;
    }

    public void setLeft(PersonNode left) {
        this.left = left;
    }

    public PersonNode getRight() {
        return right;
    }

    public void setRight(PersonNode right) {
        this.right = right;
    }

    @Override
    public String toString() {
        return "PersonNode{" +
                "num=" + num +
                ", name='" + name + '\'' +
                '}';
    }

    //中序查找
    public PersonNode midOrderSearch(int num) {
        //1. 判断当前节点的左子节点是否为空，如果不为空，则递归中序查找，如果找到则返回
        PersonNode resNode = null;
        if (this.left != null) {
            resNode = this.left.midOrderSearch(num);
        }
        if (resNode != null) {
            return resNode;
        }

        //2. 如果左递归没有找到，则和当前节点进行比较，如果num和当前节点的num相等则返回当前节点
        if (this.num == num) {
            return this;
        }

        //3. 若不相等，则继续进行右递归中序查找，找到就返回，否则返回null
        if (this.right != null) {
            resNode = this.right.midOrderSearch(num);
        }
        if (resNode != null) {
            return resNode;
        }
        return null;
    }
}

三、后序查找

实现思路：

  1. 判断当前节点的左子节点是否为空，如果你不为空，则递归后序查找，如果找到，就返回该节点
  2. 如果没有找到，就判断当前节点的右子节点是否为空。如果不为空，则右递归进行后序查找，如果找到就返回
  3. 和当前节点进行比较，如果是则返回，否则返回null
public class BinaryTreeDemo {
    public static void main(String[] args) {
        BinaryTree binaryTree = new BinaryTree();

        PersonNode root = new PersonNode(1, "张三");
        PersonNode node2 = new PersonNode(2, "李四");
        PersonNode node3 = new PersonNode(3, "王五");
        PersonNode node4 = new PersonNode(4, "赵六");
        PersonNode node5 = new PersonNode(5, "田七");

        root.setLeft(node2);
        root.setRight(node3);
        node3.setLeft(node4);
        node3.setRight(node5);
        binaryTree.setRoot(root);

        System.out.println("后序查找：");
        PersonNode personNode = binaryTree.postOrderSearch(4);
        System.out.println(personNode);
    }
}

class BinaryTree {
    private PersonNode root;

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

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

}

class PersonNode {
    private int num;
    private String name;
    private PersonNode left;
    private PersonNode right;

    public PersonNode() {
    }

    public PersonNode(int num, String name) {
        this.num = num;
        this.name = name;
    }

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public PersonNode getLeft() {
        return left;
    }

    public void setLeft(PersonNode left) {
        this.left = left;
    }

    public PersonNode getRight() {
        return right;
    }

    public void setRight(PersonNode right) {
        this.right = right;
    }

    @Override
    public String toString() {
        return "PersonNode{" +
                "num=" + num +
                ", name='" + name + '\'' +
                '}';
    }

    //后序查找
    public PersonNode postOrderSearch(int num) {
        //1. 判断当前节点的左子节点是否为空，如果你不为空，则递归后序查找，如果找到，就返回该节点
        PersonNode resNode = null;
        if (this.left != null) {
            resNode = this.left.postOrderSearch(num);
        }
        if (resNode != null) {
            return resNode;
        }

        //2. 如果没有找到，就判断当前节点的右子节点是否为空。如果不为空，则右递归进行后序查找，如果找到就返回
        if (this.right != null) {
            resNode = this.right.postOrderSearch(num);
        }
        if (resNode != null) {
            return resNode;
        }

        //3. 和当前节点进行比较，如果是则返回，否则返回null
        if (this.num == num) {
            return this;
        }
        return null;
    }
}

三种查找方式都能查找到PersonNode{num=4, name='赵六'}节点

四、删除结点

实现思路：

  1. 因为我们的二叉树是单向的，所以我们是判断当前结点的子结点是否需要删除结点，而不能去判断当前这个结点是不是需要删除结点.
  2. 如果当前结点的左子结点不为空，并且左子结点 就是要删除结点，就将this.left = null; 并且就返回(结束递归删除)
  3. 如果当前结点的右子结点不为空，并且右子结点 就是要删除结点，就将this.right= null ;并且就返回(结束递归删除)
  4. 如果第2和第3步没有删除结点，那么我们就需要向左子树进行递归删除
  5. 如果第4步也没有删除结点，则应当向右子树进行递归删除

代码实现：

public class BinaryTreeDemo {
    public static void main(String[] args) {
        BinaryTree binaryTree = new BinaryTree();

        PersonNode root = new PersonNode(1, "张三");
        PersonNode node2 = new PersonNode(2, "李四");
        PersonNode node3 = new PersonNode(3, "王五");
        PersonNode node4 = new PersonNode(4, "赵六");
        PersonNode node5 = new PersonNode(5, "田七");

        root.setLeft(node2);
        root.setRight(node3);
        node3.setLeft(node4);
        node3.setRight(node5);
        binaryTree.setRoot(root);

        System.out.println("前序遍历：");
        binaryTree.preOrder();
        
        //测试删除结点
        binaryTree.delNode(5);
        binaryTree.preOrder();

    }
}

class BinaryTree {
    private PersonNode root;

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

    //前序遍历
    public void preOrder() {
        if (root != null) {
            root.preOrder();
        } else {
            System.out.println("二叉树为空，不能遍历");
        }
    }


    //删除结点
    public void delNode(int num) {
        if (root != null) {
            if (root.getNum() == num) {
                root = null;
            } else {
                root.delNode(num);
            }
        } else {
            System.out.println("空树，不能删除");
        }
    }
}

class PersonNode {
    private int num;
    private String name;
    private PersonNode left;
    private PersonNode right;

    public PersonNode() {
    }

    public PersonNode(int num, String name) {
        this.num = num;
        this.name = name;
    }

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public PersonNode getLeft() {
        return left;
    }

    public void setLeft(PersonNode left) {
        this.left = left;
    }

    public PersonNode getRight() {
        return right;
    }

    public void setRight(PersonNode right) {
        this.right = right;
    }

    @Override
    public String toString() {
        return "PersonNode{" +
                "num=" + num +
                ", 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 delNode(int num) {
//        如果当前结点的左子结点不为空，并且左子结点 就是要删除结点，就将this.left = null; 并且就返回(结束递归删除)
        if (this.left != null && this.left.num == num) {
            this.left = null;
            return;
        }
//        如果当前结点的右子结点不为空，并且右子结点 就是要删除结点，就将this.right= null ;并且就返回(结束递归删除)
        if (this.right != null && this.right.num == num) {
            this.right = null;
            return;
        }
//        如果第2和第3步没有删除结点，那么我们就需要向左子树进行递归删除
        if (this.left != null) {
            this.left.delNode(num);
        }
//        如果第4步也没有删除结点，则应当向右子树进行递归删除
        if (this.right != null) {
            this.right.delNode(num);
        }
    }
}

测试结果：
在这里插入图片描述

Marvellous丶
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
二叉树前序中序后序遍历.txt
01-31
建立一棵二叉树，并对其进行遍历（先序、中序、后序），打印输出遍历结果。 [基本要求] 从键盘接受输入（先序），以二叉链表作为存储结构，建立二叉树（以先序来建立），并采用递归算法对其进行遍历（先序、中序、...
java根据先序和中序求后序_通过先序和中序数组生成后序数组
weixin_39762075的博客
02-28 272
整体思路使用递归，顺序考察先序序列创建根节点，同时左右向对中序序列进行划分 #include#includetypedefstructBTree{intnum;structBTree*lc,*rc;}BTree;intk;//标记下个访问的先序结点位置voidCreateBTree(BTree*T,intordp[],intordi[],boolvisited[],in...
二叉树的前序中序后序遍历、查找的实现（Java代码实现）
共勉
05-14 2841
在前一篇文章对二叉树进行的部分介绍：数据结构—— 树（二叉树）详解 在后面当中简介了一下遍历方法，随后对遍历方法实现： 对一棵二叉树的代码实现，首先对每一个节点定义一个节点类，节点类定义no和name，用于标识节点，以及一个左指针和右指针。这里使用私有变量private，所以需要对这些变了进行getter/setter封装。代码省略。定义构造方法，进行初始化。往下，重写toString方法，用于输出节点信息。最后就是对前序中序后序的方法实现。 class Node { private int no; p
二叉树排序算法（java）
weixin_44591656的博客
02-19 1416
二叉树 主要包括根节点，左孩子和右孩子 二叉排序的基本原理： 把第一个元素作为根节点，之后的元素如果比第一个元素大，放到右面，否则放到左面 算法步骤 先声明一个节点类Node,里面有根节点，左孩子和右孩子 然后创建一个构造函数里面放的是根节点 然后写一个添加节点的方法，我们给他起名为add方法 先把创建树的代码写一下 class Node,声明一个节点类Node 里面有根节点，左右孩子，然后创建一个根节点的构造方法，方便后面使用。 class newTree{ class Node{ int data
Java实现二叉树的前序，中序，后序遍历(迭代，递归两种方法实现)
qswdaw的博客
04-11 4841
前言 二叉树，有深度优先遍历和广度优先遍历，但是这两个概念不止局限于二叉树，它们更是一种抽象的算法思想，决定了访问某些复杂数据结构的顺序。本文主要讲述深度优先遍历的三种方法！ 所谓深度优先，顾名思义，就是偏向于纵深，“一头扎到底”的访问方式。这样说很抽象，下边我们就通过深度优先的前序，中序，后序三种遍历方式，来看一看深度优先把。 三种遍历思想： 前序遍历：根结点 ---> 左子树 ---> 右子树 中序遍历：左子树--->根结点---> 右子树 后序遍历：左子树 ...
Java二叉查找树遍历（前序遍历，中序遍历，后序遍历）
timewilltell12的博客
03-30 2381
针对树这一数据结构的遍历问题主要有四种，前序遍历、中序遍历、后序遍历、层序遍历，我们主要说明一下二叉树前序、中序、后序的递归方式代码模板。 基本思想 前序遍历：根结点 —> 左子树 —> 右子树 中序遍历：左子树—> 根结点 —> 右子树 后序遍历：左子树 —> 右子树 —> 根结点 前序遍历 //前序遍历 //获取整个树中所有的键 public Queue<Key> preErgodic(){ Queue&l
erchashu.rar_前序 中序 后序
09-23
建立一个二叉树,然后进行前序,中序,后序遍例等功能.
LastOrderTree.rar_LastOrderTree_前序 中序 后序
09-24
创建二叉树，并实现二叉树前序、中序递归遍历算法和二叉树的后序非递归遍历
二叉树的前序中序后序遍历代码
01-03
用C语言实现数据结构中二叉树的前序中序后序遍历 int main()//主函数部分 { BiTree T=NULL; int Layer=0; int LayerT=0; printf("请输入二叉树：\n"); CreatBiTree(&T);printf("你输入的二叉树为：(竖型树状...
二叉树创建前序中序后序遍历
08-31
二叉树的建立，遍历。 #include"stdio.h" #include"stdlib.h" typedef struct BiTNode {char data; struct BiTNode *lchild,*rchild; }BiTNode,*BiTree; BiTree CreateBiTree() {char p; BiTree T; scanf("%c",&p); ...
算法笔记，前序与中序遍历构造二叉树
03-19
算法笔记，前序与中序遍历构造二叉树
Java版二叉树的前序遍历查找、中序遍历查找和后序遍历查找
qq_37837621的博客
02-19 1858
文章收藏的好句子：任何挫折，如果无法彻底击败你，那一定会使你更强。目录1、二叉树的节点查找 1、1 前序遍历查找 1、2 中序遍历查找 1、3 后序遍历查找1、二叉...
JAVA实现二叉树的创建、前序、中序、后序、层次遍历以及查找删除二叉树中元素节点
hukehukehukehuke的博客
09-24 362
什么是树? 树 （数据结构名词）: 树状图是一种数据结构，它是由n（n>=1）个有限结点组成一个具有层次关系的集合。把它叫做“树”是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点： 每个结点有零个或多个子结点；没有父结点的结点称为根结点；每一个非根结点有且只有一个父结点；除了根结点外，每个子结点可以分为多个不相交的子树 什么是二叉树? 树有很多种, 每个节点最...
使用Java实现二叉树的创建和前序、中序、后序三种遍历
weixin_58258124的博客
03-10 892
今天复习了一下二叉树，自己试着用代码实现了一下二叉树的创建和三种遍历，既是巩固一下二叉树的要点，也是练习一下java代码，毕竟有时间没有写代码了（都快忘了咋写了） 1.节点类 package Tree; /** * 节点类 */ public class Node { private char data; //数据就用字符表示，访问节点数据就是用打印字符代替 private Node lchild;//左节点 private Node rchild;//右节点
JAVA实现二叉排序树（创建、中序遍历、插入节点和删除节点操作）
梅森上校的博客 业精于勤荒于嬉，形成于思毁于随。
03-31 7786
JAVA实现二叉排序树 二叉排序树的定义 二叉排序树或者是一棵空树，或者是具有下列性质的二叉树： （1）若左子树不空，则左子树上所有结点的值均小于或等于它的根结点的值； （2）若右子树不空，则右子树上所有结点的值均大于或等于它的根结点的值； （3）左、右子树也分别为二叉排序树； 从上述定义可以看出，二叉排序树的定义本身就是依赖于递归思想的。 二叉排序树举例 二叉排序树的JAVA...
二叉树：实现java操作二叉排序树（生成、插入、遍历、删除）
Somhu的博客
09-14 2397
首先来了解一下二叉排序树的由来，也就是在什么情况下迫使老一辈头脑风暴的科学家发明使用这种方法。 先说普通顺序存储（注意并不是有序），先来先坐，有点类似于“栈”。插入数据直接放到最末尾，删除中间数据的话可以把待删除数据和最后一位数据进行互换，也可以把待删除数据后的全部数据统一往前挪一位。这里实在没有顺序的前提下，删除和插入的效率都没有毛病，但是查找就有点差强人意了，或者说效果很悲观。 那么对于有
java实现并图解二叉搜索树的添加、查找以及删除方法(保姆级教程)
weixin_48654011的博客
04-09 1622
目录 二叉搜索树的概念 实现二叉搜索树的添加方法 实现二叉搜索树的查找方法 实现二叉搜索树的删除方法 附带java代码 二叉搜索树的概念 二叉搜索树（二叉排序树）： 1.首先是一棵二叉树 2.其次左子树上所有节点的值都小于根节点的值，右子树上所有节点的值都大于根节点的值。 图解： 实现二叉搜索树的添加方法 先讲解思路，在进行图解，最后实现代码 实现二叉搜索树的查找方法 先讲解思路，在进行图解，最后实现代码 实现二叉搜索树的删除方法 先讲解思路，在进行图解，最后实现代码 .
Java实现二叉树的前、中、后序遍历和前序查找
wanglj的博客
06-10 425
二叉树定义类，通过根节点实现二叉树的索引: package cn.tree.test; import cn.tree.java.*; public class BinaryTree { Node root; //设置根节点 public void setRoot(Node root) { this.root = root; } //获取根节点 public Node getRoot() { return root; } //前序 public void frontShow()
数据结构和算法-树与二叉树
熊诗言的博客
04-28 157
感谢尚硅谷韩顺平老师深入细致的讲解 为什么需要树这种数据结构 数组存储方式的分析 优点：通过下标方式访问元素，速度快。对于有序数组，还可使用二分查找提高检索速度。 缺点：如果要检索具体某个值，或者插入值(按一定顺序)会整体移动，效率较低 链式存储方式的分析 优点：在一定程度上对数组存储方式有优化(比如：插入一个数值节点，只需要将插入节点，链接到链表中即可， 删除效率也很好)。 缺点：在进行检索时，效率仍然较低，比如(检索某个值，需要从头节点开始遍历) 树存储方式的分析 能提高数据存储，读取的效率, 比如利
java二叉树遍历前序中序后序层次
最新发布
04-29
Java中二叉树的遍历方式包括前序遍历、中序遍历、后序遍历和层次遍历。下面是它们的介绍： 1. 前序遍历（Preorder Traversal）： 前序遍历是指先访问根节点，然后按照先左后右的顺序递归地访问左子树和右子树。在...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值