二叉树-前序中序后续遍历，以及查找删除操作！

最新推荐文章于 2024-10-21 18:32:33 发布
最新推荐文章于 2024-10-21 18:32:33 发布
阅读量312 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： 二叉树 算法 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46074155/article/details/117443457
本文围绕二叉树展开，介绍了二叉树的基本概念，包括左右节点、叶子节点、满二叉树和完全二叉树等。详细阐述了二叉树的前序、中序、后序遍历思路及步骤，还说明了三种遍历方式下的查找思路，最后讲解了二叉树的删除操作思路并给出全代码。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

一、二叉树的介绍

1.二叉树：每个节点最多只能有两个子节点的一种形式的树
在这里插入图片描述
2.左右节点：也叫孩子节点，二叉树的子节点分为左节点和右节点，如图21为11的左子节点，31为11的右子节点，11为21和31的父节点
在这里插入图片描述
3.叶子节点：叶子节点就是树中最底段的节点,叶子节点没有子节点。
4.满二叉树：二叉树的所有叶子节点都在最后一层，并且满足节点总数为2^(n-1),n为层数。
在这里插入图片描述
5.完全二叉树：二叉树的所有叶子节点都在最后一层或者分布在倒数第二层，并且满足最后一层的叶子节点在左边连续，倒数第二层的叶子节点在右边连续！
在这里插入图片描述
6.满二叉树是完全二叉树的一个特列，但完全二叉树不一定是满二叉树

二、二叉树的前序，中序，后续遍历

1.逻辑结构示意图
在这里插入图片描述
2.前序中序后序遍历思路分析即步骤
1.创建一颗二叉树

2.前序遍历思路分析：
先输出父节点，在输出左子节点，在输出右子节点
步骤
①先输出当前节点(初始的时候是root节点)
②如果左子节点不为空，则左子节点递归继续前序遍历
③如果右子节点不为空，则右子节点递归继续前序遍历

3.中序遍历思路分析：
先输出左子节点，在输出父节点，在输出右子节点
步骤
3.1如果当前节点的左子节点不为空，则左子节点递归中序遍历，
3.2输出当前节点
3.2如果当前节点的右子节点不为空，则右子节点递归中序遍历

4.后序遍历思路分析：
先输出左子节点，在输出右子节点，最后输出父节点
步骤
3.1如果当前节点的左子节点不为空，则左子节点递归后序遍历，
3.2如果当前节点的右子节点不为空，则右子节点递归后序遍历
3.3输出当前节点

代码实现

package tree;


public class TreeTest {
    public static void main(String[] args){
        //初始化节点
        HeroNode root = new HeroNode(1,"宋江","及时雨");
        HeroNode hero2 = new HeroNode(2,"吴用","智多星");
        HeroNode hero3 = new HeroNode(3,"李逵","黑旋风");
        HeroNode hero4 = new HeroNode(4,"卢俊义","玉麒麟");
        HeroNode hero5 = new HeroNode(5,"武松","豹子头");

        //初始化二叉树
        BinaryTree tree = new BinaryTree();
        //数中添加节点
        tree.setRoot(root);
        root.setLeft(hero2);
        root.setRight(hero3);
        hero3.setLeft(hero4);
        hero3.setRight(hero5);

        System.out.println("-----------①遍历测试-------------");
        //前序遍历
        System.out.println("--------前序遍历--------");
        tree.preOrder();
        //中序遍历
        System.out.println("--------中序遍历--------");
        tree.infixOrder();
        //后序遍历
        System.out.println("--------后序遍历--------");
        tree.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("该二叉树没有根节点，无法遍历");
        }
    }
}



//定义一个节点类
class HeroNode{
    private int id;//id
    private String name;//姓名
    private String nickName;//别名
    private HeroNode left;//左节点
    private HeroNode right;//右节点，默认为空


    //无参构造器
    public HeroNode() {

    }


    //有参构造器
    public HeroNode(int id, String name, String nickName) {
        this.id = id;
        this.name = name;
        this.nickName = nickName;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public String getNickName() {
        return nickName;
    }

    public void setNickName(String nickName) {
        this.nickName = nickName;
    }

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

    //重写toString 不用加左右节点，默认为空
    @Override
    public String toString() {
        return "HeroNode{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", nickName='" + nickName + '\'' +
                '}';
    }

    //前序遍历
    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.先判断当前结点的no是否等于要查找的
2.如果是相等，则返回当前结点
3.如果不等，则判断当前结点的左子节点是否为空，如果不为空,则递归前序查找
4.如果左递归前序查找，找到结点，则返回，否继续判断，当前的结点的右子节点是否为空，如果不空，则继续向右递归前序查找
中序查找思路
1.判断当前结点的左子节点是否为空，如果不为空，则递归中序查找
2.如果找到，则返回，如果没有找到，就和当前结点比较，如果是则返回当前结点,否则继续进行右递归的中序查找
3.如果右递归中序查找，找到就返回，否则返回null
后序查找思路
1.判断当前结点的左子节点是否为空，如果不为空，则递归后序查找
2.如果找到，就返回，如果没有找到，就判断当前结点的右子节点是否为空，如果不为空，则右递归进行后序查找,如果找到，就返回。
3.就和当前结点进行，比如，如果是则返回，否则返回null

package tree;


public class TreeTest {
    public static void main(String[] args){
        //初始化节点
        HeroNode root = new HeroNode(1,"宋江","及时雨");
        HeroNode hero2 = new HeroNode(2,"吴用","智多星");
        HeroNode hero3 = new HeroNode(3,"李逵","黑旋风");
        HeroNode hero4 = new HeroNode(4,"卢俊义","玉麒麟");
        HeroNode hero5 = new HeroNode(5,"武松","豹子头");

        //初始化二叉树
        BinaryTree tree = new BinaryTree();
        //数中添加节点
        tree.setRoot(root);
        root.setLeft(hero2);
        root.setRight(hero3);
        hero3.setLeft(hero4);
        hero3.setRight(hero5);

        System.out.println("-----------①遍历测试-------------");
        //前序遍历
        System.out.println("--------前序遍历--------");
        tree.preOrder();
        //中序遍历
        System.out.println("--------中序遍历--------");
        tree.infixOrder();
        //后序遍历
        System.out.println("--------后序遍历--------");
        tree.postOrder();


        System.out.println("-----------②查找测试-------------");
        //前序查找编号为5的节点信息
        System.out.println("查找编号为5的节点信息..");
        HeroNode searchHero = tree.preOrderSearch(1);
        if (searchHero != null){
            System.out.printf("查找成功！！节点信息:id=%d,name=%s,nickName=%s\n",searchHero.getId(),searchHero.getName(),searchHero.getNickName());
        }else{
            System.out.printf("查询失败！！没有编号%d的节点信息\n",1);
        }

        //中序查找编号为6的节点信息
        System.out.println("查找编号为6的节点信息..");
        HeroNode curNode = tree.infixOrderSearch(6);
        if (curNode != null){
            System.out.printf("查找成功！！节点信息:id=%d,name=%s,nickName=%s\n",curNode.getId(),curNode.getName(),curNode.getNickName());
        }else{
            System.out.printf("查询失败！！没有编号%d的节点信息\n",6);
        }
        //后续查找编号为5的节点信息
        System.out.println("查找编号为7的节点信息..");
        HeroNode heroNode = tree.postOrderSearch(3);
        if (heroNode != null){
            System.out.printf("查找成功！！节点信息:id=%d,name=%s,nickName=%s\n",heroNode.getId(),heroNode.getName(),heroNode.getNickName());
        }else{
            System.out.printf("查询失败！！没有编号%d的节点信息\n",3);
        }

        System.out.println("-----------③删除测试-------------");
        //删除4号节点
        System.out.println("删除4号节点中.....");
        tree.delNode(4);
        System.out.println("删除后，前序遍历...");
        tree.preOrder();
        System.out.println("删除后，中序遍历...");
        tree.infixOrder();
        System.out.println("删除后，后续遍历...");
        tree.postOrder();

    }
}

//定义一个二叉树
class BinaryTree{
    private  HeroNode root;//定义一个根节点

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


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

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

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

}



//定义一个节点类
class HeroNode{
    private int id;//id
    private String name;//姓名
    private String nickName;//别名
    private HeroNode left;//左节点
    private HeroNode right;//右节点，默认为空


    //无参构造器
    public HeroNode() {

    }


    //有参构造器
    public HeroNode(int id, String name, String nickName) {
        this.id = id;
        this.name = name;
        this.nickName = nickName;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public String getNickName() {
        return nickName;
    }

    public void setNickName(String nickName) {
        this.nickName = nickName;
    }

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

    //重写toString 不用加左右节点，默认为空
    @Override
    public String toString() {
        return "HeroNode{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", nickName='" + nickName + '\'' +
                '}';
    }

    //前序查找
    public HeroNode preOrderSearch(int no) {
        System.out.println("查找中~~~~~");
        //1.判断当前节点的no是不是要查找的
        if (this.id == no) {
            return this;
        }
        //定义一个当前节点，用于返回
        HeroNode curNode = null;
        //2.左递归
        if (this.left != null) {
            curNode = this.left.preOrderSearch(no);
        }
        if (curNode != null) {//当前节点不为空，说明找到该节点
            return curNode;
        }
        //3.右递归
        if (this.right != null) {
            curNode = this.right.preOrderSearch(no);
        }
        return curNode;

    }

    //中序查找
    public HeroNode infixOrderSearch(int no) {
        //定义一个当前节点，用于返回
        HeroNode curNode = null;
        //1.左递归
        if (this.left != null) {
            curNode = this.left.infixOrderSearch(no);
        }
        if (curNode != null) {//当前节点不为空，说明找到该节点
            return curNode;
        }

        System.out.println("查找中~~~~~");
        //判断当前节点的no是不是要查找的
        if (this.id == no) {
            return this;
        }

        //右递归
        if (this.right != null) {
            curNode = this.right.infixOrderSearch(no);
        }
        return curNode;

    }


    //后序查找
    public HeroNode postOrderSearch(int no) {
        //定义一个当前节点，用于返回
        HeroNode curNode = null;
        //1.左递归
        if (this.left != null) {
            curNode = this.left.postOrderSearch(no);
        }
        if (curNode != null) {//当前节点不为空，说明找到该节点
            return curNode;
        }

        //右递归
        if (this.right != null) {
            curNode = this.right.postOrderSearch(no);
        }
        if (curNode != null) {
            return curNode;
        }

        System.out.println("查找中~~~~~");
        //判断当前节点的no是不是要查找的
        if (this.id == no) {
            return this;
        }
        return curNode;
    }

  
}

结果截图
在这里插入图片描述

四、二叉树的删除操作

完成删除结点的操作
1)如果刪除的节点是叶子节点，则删除该节点
2)如果删除的节点是非叶子节点，则删除该子树
思路
首先先处理:
如果树是空树root,如果只有一个root结点，则等价将二叉树置空
接着进行下面步骤
1.因为我们的二叉树是单向的，所以我们是判断当前结点的子结点是否需要删除结点,而不能去判断当前这个结点是不是需要删除结点.
2.如果当前结点的左子结点不为空,并且左子结点就是要删除结点,就将this.eft=null;并且就返回(结束递归删除)
3.如果当前结点的右子结点不为空，并且右子结点就是要删除结点，就将this.right=null ;并且就返回(结束递归删除)
4.如果第2和第3步没有删除结点，那么我们就需要向左子树进行递归删除
5.如果第4步也没有删除结点，则应当向右子树进行递归删除.

二叉树全代码

package tree;


public class TreeTest {
    public static void main(String[] args){
        //初始化节点
        HeroNode root = new HeroNode(1,"宋江","及时雨");
        HeroNode hero2 = new HeroNode(2,"吴用","智多星");
        HeroNode hero3 = new HeroNode(3,"李逵","黑旋风");
        HeroNode hero4 = new HeroNode(4,"卢俊义","玉麒麟");
        HeroNode hero5 = new HeroNode(5,"武松","豹子头");

        //初始化二叉树
        BinaryTree tree = new BinaryTree();
        //数中添加节点
        tree.setRoot(root);
        root.setLeft(hero2);
        root.setRight(hero3);
        hero3.setLeft(hero4);
        hero3.setRight(hero5);

        System.out.println("-----------①遍历测试-------------");
        //前序遍历
        System.out.println("--------前序遍历--------");
        tree.preOrder();
        //中序遍历
        System.out.println("--------中序遍历--------");
        tree.infixOrder();
        //后序遍历
        System.out.println("--------后序遍历--------");
        tree.postOrder();


        System.out.println("-----------②查找测试-------------");
        //前序查找编号为5的节点信息
        System.out.println("查找编号为5的节点信息..");
        HeroNode searchHero = tree.preOrderSearch(1);
        if (searchHero != null){
            System.out.printf("查找成功！！节点信息:id=%d,name=%s,nickName=%s\n",searchHero.getId(),searchHero.getName(),searchHero.getNickName());
        }else{
            System.out.printf("查询失败！！没有编号%d的节点信息\n",1);
        }

        //中序查找编号为6的节点信息
        System.out.println("查找编号为6的节点信息..");
        HeroNode curNode = tree.infixOrderSearch(6);
        if (curNode != null){
            System.out.printf("查找成功！！节点信息:id=%d,name=%s,nickName=%s\n",curNode.getId(),curNode.getName(),curNode.getNickName());
        }else{
            System.out.printf("查询失败！！没有编号%d的节点信息\n",6);
        }
        //后续查找编号为5的节点信息
        System.out.println("查找编号为7的节点信息..");
        HeroNode heroNode = tree.postOrderSearch(3);
        if (heroNode != null){
            System.out.printf("查找成功！！节点信息:id=%d,name=%s,nickName=%s\n",heroNode.getId(),heroNode.getName(),heroNode.getNickName());
        }else{
            System.out.printf("查询失败！！没有编号%d的节点信息\n",3);
        }

        System.out.println("-----------③删除测试-------------");
        //删除4号节点
        System.out.println("删除4号节点中.....");
        tree.delNode(4);
        System.out.println("删除后，前序遍历...");
        tree.preOrder();
        System.out.println("删除后，中序遍历...");
        tree.infixOrder();
        System.out.println("删除后，后续遍历...");
        tree.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("该二叉树没有根节点，无法遍历");
        }
    }



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

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

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

    //删除节点
    public void delNode(int no){
        //先判断当前树是否为空树
        if (root != null){
            //只有一个root节点
            if (root.getId() == no){
                root =null;
            }else{
                //root有左右节点，则递归删除
                root.delNode(no);
            }
        }else{
            System.out.println("当前树是空树，不能删除！!");
       }
    }
}



//定义一个节点类
class HeroNode{
    private int id;//id
    private String name;//姓名
    private String nickName;//别名
    private HeroNode left;//左节点
    private HeroNode right;//右节点，默认为空


    //无参构造器
    public HeroNode() {

    }


    //有参构造器
    public HeroNode(int id, String name, String nickName) {
        this.id = id;
        this.name = name;
        this.nickName = nickName;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public String getNickName() {
        return nickName;
    }

    public void setNickName(String nickName) {
        this.nickName = nickName;
    }

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

    //重写toString 不用加左右节点，默认为空
    @Override
    public String toString() {
        return "HeroNode{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", nickName='" + nickName + '\'' +
                '}';
    }

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

    }

    //前序查找
    public HeroNode preOrderSearch(int no) {
        System.out.println("查找中~~~~~");
        //1.判断当前节点的no是不是要查找的
        if (this.id == no) {
            return this;
        }
        //定义一个当前节点，用于返回
        HeroNode curNode = null;
        //2.左递归
        if (this.left != null) {
            curNode = this.left.preOrderSearch(no);
        }
        if (curNode != null) {//当前节点不为空，说明找到该节点
            return curNode;
        }
        //3.右递归
        if (this.right != null) {
            curNode = this.right.preOrderSearch(no);
        }
        return curNode;

    }

    //中序查找
    public HeroNode infixOrderSearch(int no) {
        //定义一个当前节点，用于返回
        HeroNode curNode = null;
        //1.左递归
        if (this.left != null) {
            curNode = this.left.infixOrderSearch(no);
        }
        if (curNode != null) {//当前节点不为空，说明找到该节点
            return curNode;
        }

        System.out.println("查找中~~~~~");
        //判断当前节点的no是不是要查找的
        if (this.id == no) {
            return this;
        }

        //右递归
        if (this.right != null) {
            curNode = this.right.infixOrderSearch(no);
        }
        return curNode;

    }


    //后序查找
    public HeroNode postOrderSearch(int no) {
        //定义一个当前节点，用于返回
        HeroNode curNode = null;
        //1.左递归
        if (this.left != null) {
            curNode = this.left.postOrderSearch(no);
        }
        if (curNode != null) {//当前节点不为空，说明找到该节点
            return curNode;
        }

        //右递归
        if (this.right != null) {
            curNode = this.right.postOrderSearch(no);
        }
        if (curNode != null) {
            return curNode;
        }

        System.out.println("查找中~~~~~");
        //判断当前节点的no是不是要查找的
        if (this.id == no) {
            return this;
        }
        return curNode;
    }

    //节点删除，因为二叉树是单向的，所以需要判断是当前节点的子节点需要删除
    public void delNode(int no){
        //1.如果当前节点的左子树不为空，并且左子树刚好是待删除节点
        if (this.left != null && this.left.id == no){
            this.left =null;
            return;
        }
        //2.如果当前节点的右子树不为空，并且右子树刚好是待删除节点
        if (this.right != null && this.right.id == no){
            this.right =null;
            return;
        }
        //3.当1，2都不满足，则左子树递归删除
        if (this.left != null){
            this.left.delNode(no);
        }
        //4.当3不满足时，递归删除右子树
        if (this.left != null){
            this.right.delNode(no);
        }

    }
}

删除截图
在这里插入图片描述

gougege0514
关注
一文彻底搞定二叉树的前序、中序、后序遍历(图解递归非递归)
bigsai
09-22 1万+
前言 大家好，我是bigsai，在数据结构与算法中，二叉树无论是考研、笔试都是非常高频的考点内容，在二叉树中，二叉树的遍历又是非常重要的知识点，今天给大家讲讲二叉树的层序遍历。 这部分很多人可能会但是需要注重一下细节。 前面介绍了二叉排序树的构造和基本方法的实现，遍历也是比较重要的一环，并且二叉树的层序遍历也是bfs的最简单情况，这里我就将二叉树的层序遍历以及常考问题给大家分享一下。 在了解二叉树的遍历之前，需要具备数据结构与算法有队列、递归、栈、二叉树，这些内容咱们前面都有讲过，有这方面知识欠缺的同学可以
二叉树的前序，中序，后序遍历【详细】【JS实现】
m0_57482322的博客
07-07 1802
二叉树的前序，中序，后序遍历算法，包含迭代和递归两种做法，内附图详细说明步骤
二叉树的前序中序后序遍历代码
01-03
用C语言实现数据结构中二叉树的前序中序后序遍历 int main()//主函数部分 { BiTree T=NULL; int Layer=0; int LayerT=0; printf("请输入二叉树：\n"); CreatBiTree(&T);printf("你输入的二叉树为：(竖型树状表示)\n"); PrintBinary(T,Layer); printf("\n"); printf("先序遍历二叉树为：\n"); PreOrderTraverse(T); printf("\n"); printf("中序遍历二叉树为：\n"); InOrderTraverse(T); printf("\n"); printf("后序遍历二叉树为：\n"); PostOrderTraverse(T); printf("\n"); printf("二叉树转换为树显示出来为：(竖型树状表示)\n"); PrintTree(T,LayerT); system("pause"); return 0; }
剑指 Offer 07. 重建二叉树 - python
javaisnotgood的博客
10-12 506
输入某二叉树的前序遍历和中序遍历的结果，请重建该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。 例如，给出 前序遍历 preorder =[3,9,20,15,7] 中序遍历 inorder = [9,3,15,20,7] 返回如下的二叉树： 3 / \ 9 20 / \ 15 7 思路：首先通过先序遍历序列可以得到树的根节点，然后在中序序列中找到根节点的位置，则以根节点为界限，向左到0,为左子树，向右到len() - 1 位右子树，然...
二叉树的前序，中序及后续遍历
Luis的个人博客
04-07 644
前序遍历：先访问跟结点，然后遍历左子树，最后遍历右子树。即“根左右”。 实现代码： class Solution { public: vector preorderTraversal(TreeNode *root) { if (root==NULL) { return vector(); } vector resu
二叉树的前序,中序,后续遍历
Zyong139064359的博客
05-03 277
看了一篇有关这方面的博客,于是就运行了一下上面的代码. #include<iostream> #include<algorithm> #include<string> using namespace std; typedef struct node{ char data; struct node *lc,*rc;//左右孩子 }*TBT,TBTNode; voi...
二叉树的前序/中序/后序遍历以及删除实现
weixin_43752378的博客
03-30 291
二叉树的前序/中序/后序遍历 概念 1.每个节点最多只有两个子节点的树称之为二叉树 2.二叉树的子节点分为左节点/右节点 3.如果二叉树所有的叶子节点都在最后一层，并且节点总数=2*n-1（n为层数），则称之为满二叉树 4.如果该二叉树的所有叶子节点最后一层或者倒数第二层，而且最后一层叶子节点在左面连续，倒数第二层节点在右面连续，我们称之为完全二叉树 分析 前/中/后序遍历都是针对于父节点来说的 前序遍历： 先输出父节点，再遍历左子树，最后遍历右子树 中序遍历： 先遍历左子树，再输出父节点，最后遍历右
链式二叉树--前序中序后序层序遍历，高度，销毁及完全二叉树的判断
Miwll的博客
03-17 465
链式二叉树作为后续AVL树，B系列树的雏形，理解掌握链式二叉树的各种操作很重要，此处就需要用递归来实现链式二叉树的各种操作，相信认真学习过后会对递归有更深刻的理解，接下来我们就开始上菜
C语言实现二叉树的前序、中序、后续遍历（递归法）
12-13
### C语言实现二叉树的前序、中序、后续遍历（递归法） #### 一、前序遍历 前序遍历是二叉树遍历的一种方式，其顺序为“根节点 -> 左子树 -> 右子树”。这种遍历方式在很多应用场景中都非常有用，例如构建表达式树...
二叉树前序、中序、后序遍历-1
平凡小智
03-19 1005
目录 前序遍历： 中序遍历： 后序遍历： 使用递归方法进行遍历的代码: 一、前序遍历： 前序遍历（VLR），是二叉树遍历的一种，也叫做先根遍历、先序遍历、前序周游，可记做根左右。前序遍历首先访问根节点然后遍历左子树，最后遍历右子树。 前序遍历首先访问根结点然后遍历左子树，最后遍历右子树。在遍历左、右子树时，仍然先访问根节点，然后遍历左子树，最后遍历右子树。 若二叉树为空则结束返回，否则： （1）访问根结点。 （2）前序遍历左子树。 （3）前序遍历右子树 。 需要注意的是...
二叉树的操作 建立 删除 中序，先序 后序遍历
12-05
二叉树的操作 建立 删除 中序，先序 后序遍历
二叉树的前序、中序、后续遍历
Kevin-Ding的博客
03-14 1066
二叉树的前序、中序、后序遍历方法
二叉树遍历（前序、中序、后续）
最新发布
weixin_70042862的博客
10-21 4742
树：树的根节点没有前驱，除根节点以外，其他所有节点有且只有一个前驱。二叉树：是n个有限元素的集合，该集合或者为空、或者由一个称为根（root）的元素及两个不相交的、被分别称为左子树和右子树的二叉树组成，是有序树。当集合为空时，称该二叉树为空二叉树。在二叉树中，一个元素也称作一个节点。以此图为例，F为根节点，C为F的左子节点，E为F的右子节点。
【二叉树】四种遍历——前序、中序、后续和层序遍历
weixin_54383080的博客
01-08 460
二叉树遍历，前、中、后、层序遍历，递归、迭代以及 Morris方法.
Java实现二叉树的前序、中序、后序查找、删除结点
baolingye的博客
09-19 485
请编写前序查找，中序查找和后序查找的方法，分别使用三种查找方式，查找 num = 5 的节点 我们一这样一棵二叉树为例 一、前序查找 实现思路： 先判断当前节点的num是否等于要查找的，如果相等，则返回当前节点 如果不相等，则判断当前节点的左子节点是否为空，如果不为空，则递归前序查找 如果左递归前序查找找到节点则返回该节点，否则继续判断当前节点的右子节点是否为空，如果不为空，则继续右递归前序...
二叉树前序、中序、后续、广度优先遍历
MuErHuoXu的博客
12-25 430
二叉树遍历 二叉树的遍历之前也看过，但好记性不如烂笔头，记录下吧 二叉树定义： 二叉树遍历： 有深度遍历和广度遍历，深度遍历有前序、中序以及后序三种遍历方法，广度遍历即我们平常所说的层次遍历。因为树的定义本身就是递归定义，因此采用递归的方法去实现树的三种遍历不仅容易理解而且代码很简洁，而对于广度遍历来说，需要其他数据结构的支撑，比如堆了。所以，对于一段代码来说，可读性有时候要比代码本身的效率要重要...
二叉树 - 中序先序后序遍历 - 插入 - 删除 - 查找 - 二叉查找树
weixin_45653525的博客
04-10 316
#include <iostream> #include <stack> #include <queue> #include <string> using namespace std; #define MAX_N 100 typedef char ElementType; typedef struct TNode *Possition; typede...
二叉树顺序存储之 前序，中序 ，后序遍历
热门推荐
weixin_41316824的博客
03-21 8万+
二叉树遍历的概念： 二叉树的遍历是指从根结点出发，按照某种次序依次访问二叉树中的所有结点，使得每个结点被访问一次且仅被访问一次。 1、前序遍历 先输出当前结点的数据，再依次遍历输出左结点和右结点 如下图二叉树分析： 遍历过程 A(B,C) (括号里代表该节点的子节点， 每次把遍历节点放再子节点的左右节点之前) ...
数据结构之二叉树先序后续中序遍历
qq_38147044的博客
08-11 1356
二叉树的遍历（traversing binary tree）是指从根结点出发，按照某种次序依次访问二叉树中所有结点，使得每个结点被访问一次且仅被访问一次。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值