数据结构-线索化二叉树

已于 2022-06-13 20:34:37 修改
阅读量4.9k 收藏 65
点赞数 15
分类专栏： Java 数据结构与算法 文章标签： 数据结构 链表
于 2021-10-26 17:37:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yao_wen_yu/article/details/120967824
版权

文章目录

1、什么是线索二叉树

线索二叉树是二叉树的一种，我们先看一个二叉树存储例子。

在这里插入图片描述
上图中的 # 是空的，会浪费一部分空间，如果我们希望将这些空的指针充分利用，让各个节点都可以指向自己的前驱结点和后继节点，那就需要使用到线索二叉树。

现有一颗节点数为 n 的二叉树，采用二叉链表的形式存储。对于每个节点均有指向左右孩子的两个指针域，二节点为 n 的二叉树一共有 n-1 个条有效分支路径。那么，则二叉链表中存在 2n-(n-1)=n+1个空指针域。那么这些空指针造成空间浪费。

此外，当对二叉树进行中序遍历时可以得到二叉树的中序序列。例如上图中二叉树的中序遍历结果为：DBEAGFC，可以得知 E 的前驱结点是 B，后继节点是 A。但是这种关系是在中序遍历完成之后得到的。

线索化二叉树分为三种：
在这里插入图片描述

上述情况是建立在遍历过的基础上，在二叉链表上，我们只能知道每个节点指向其左右孩子节点的地址，而不知道每个节点的前驱和后继，要想知道，必须遍历一次，以后每次需要知道时，都必须先遍历一次，太耗费时间。我们可以考虑在创建时就记住这些前驱和后继。这个时候我们就可以考虑利用那些空地址，存放指向节点在某种遍历次序下的前驱和后继节点的地址。这种指向前驱和后继的指针称为线索，所以叫线索二叉树。总结一下：

  • 若当前节点左指针域非空时，保留原指针不变；若左指针域为空时，添加该节点在相应遍历序列中前驱节点地址。
  • 若当前结点右指针域非空时，保留原指针不变；若右指针域为空时，添加该节点在相应遍历序列中后继节点地址。

这里要注意一下，我们怎么判断左/右指针域指向的是原指针还是前驱/后继节点?
在这里插入图片描述

2、中序线索化二叉树

中序线索化二叉树例子：
在这里插入图片描述

2.1 中序线索化二叉树实现

线索化：中序线索化二叉树，就按中序遍历，遍历的过程中在当前节点的左或右空指针域中添加前驱或后继节点。为了保留遍历过程中访问节点的前驱与后继关系，需要设置一个前一节点变量 pre 始终指向刚访问过的节点。

  • 如果当前节点 node.getLeft() == null (左子节点为空)，则node.setLeftType(1) ; node.setLeft(pre) ; (左指针域指向前驱节点，修改 leftType 为线索模式)。

  • 如果前一节点pre.getRight == null (右子结点为空)，则pre.setLeftType(1) ; pre.setRight(node) ; (右指针域指向后继节点，修改 rightType 为线索模式)。

💻 代码实现

package com.yao.tree;

/**
 * @Author: Yao
 * @Date: 2021/10/20 15:06
 */
public class ThreadedBinaryTreeDemo {
    public static void main(String[] args) {

        //测试
        HeroNode3 root = new HeroNode3(1, "tom");
        HeroNode3 node2 = new HeroNode3(3, "jack");
        HeroNode3 node3 = new HeroNode3(6, "mary");
        HeroNode3 node4 = new HeroNode3(8, "jon");
        HeroNode3 node5 = new HeroNode3(10, "mali");
        HeroNode3 node6 = new HeroNode3(14, "hh");

        ThreadedBinaryTree threadedBinaryTree = new ThreadedBinaryTree(root);
        root.setLeft(node2);
        root.setRight(node3);
        node2.setLeft(node4);
        node2.setRight(node5);
        node3.setLeft(node6);

        //进行中序线索化
        System.out.println("-----------------进行中序线索化----------------");
        threadedBinaryTree.threadedBinaryTreeMid(root);
        //测试 10 节点
        System.out.println(node5.getLeft()+" --> "+node5.getLeftType());
        System.out.println(node5.getRight()+" --> "+node5.getRightType());
    }
}

/*
ThreadedBinaryTree 线索化二叉树
 */
class ThreadedBinaryTree{

    private HeroNode3 root;

    //为了实现线索化二叉树，需要创建一个指向当前节点的前驱结点的指针
    private HeroNode3 per;

    public ThreadedBinaryTree(HeroNode3 root) {
        this.root = root;
    }

    /**
     * 中序线索化二叉树
     * @param node 需要线索化的节点
     */
    public void threadedBinaryTreeMid(HeroNode3 node){
        if (node == null){
            return;
        }
        //进行中序线索化
        //线索化左子树
        if (node.getLeft() != null) {
            threadedBinaryTreeMid(node.getLeft());
        }
        //线索化当前节点
        //处理当前节点的前驱结点
        if (node.getLeft() == null){
            //让当前节点的左指针指向前驱结点
            node.setLeft(per);
            //设置左指针的类型为前驱结点
            node.setLeftType(1);
        }
        //处理当前节点的后继节点
        if (per != null && per.getRight() == null){
            per.setRight(node);
            per.setRightType(1);
        }

        per = node;

        if (node.getRight() != null){
            //线索化右子树
            threadedBinaryTreeMid(node.getRight());
        }
    }
}

//HeroNode3
class HeroNode3{

    private int no;

    private String name;

    private HeroNode3 left;

    private HeroNode3 right;

    //说明 如果 leftType == 0 表示leftType指向的是左子树，leftType == 1，表示指向的是 前驱结点
    private int leftType;
    //说明 如果 rightType == 0 表示rightType指向的是右子树，rightType == 0，表示指向的是 后继节点
    private int rightType;

    public HeroNode3(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 HeroNode3 getLeft() {
        return left;
    }

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

    public HeroNode3 getRight() {
        return right;
    }

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

    public int getLeftType() {
        return leftType;
    }

    public void setLeftType(int leftType) {
        this.leftType = leftType;
    }

    public int getRightType() {
        return rightType;
    }

    public void setRightType(int rightType) {
        this.rightType = rightType;
    }

    @Override
    public String toString() {
        return "HeroNode3{" +
                "no=" + no +
                ", name='" + name + '\'' +
                '}';
    }
}
2.2 中序线索化二叉树遍历实现

中序二叉树遍历主要分为两步：

① 获取中序遍历的首节点。
② 获取中序线索化二叉树中当前节点的后继节点。

只要完成这两步就可以遍历中序线索化二叉树。

如何获取中序遍历的首节点：从根节点开始沿着左指针不断向左下搜索，直到找到最左的节点。最左的节点指该节点左指针为空。

获取中序线索化二叉树中当前节点的后继节点：有两种情况

①当前节点存在右子树：则从该右子树根节点开始不断向左下搜索，找到找到最左的节点。该节点即当前节点的后继。
②当前节点不存在右子树：则其后继节点即为其右指针域中后继线索所指节点。

思路分析：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

💻 代码实现

/**
     * 遍历中序线索化二叉树
     * @param node 根节点
     */
    public void threadedBinaryTreeMidList(HeroNode3 node){
        if (node == null){
            return;
        }
        HeroNode3 temp = node.getLeft();

        if (temp == null){
            return;
        }
        //1、寻找中序遍历的第一个节点
        while (temp.getLeft() != null && temp.getLeftType() == 0){
            temp = temp.getLeft();
        }

        //2、获取中序线索化二叉树中当前节点的后继节点
        while (temp != null){
            System.out.println(temp);
            //2.1 如果当前节点存在右子树，就一直向左下递归，找到最左的节点，就是当前节点的后继节点
            if (temp.getRightType() == 0 && temp.getRight() != null){
                temp = temp.getRight();
                while (temp.getLeft() != null && temp.getLeftType() == 0){
                    temp = temp.getLeft();
                }
            }else{
                //2.2 如果当前节点不存在右子树，就直接输出后继节点
                temp = temp.getRight();
            }
        }
    }

3、先序线索化二叉树

先序线索化二叉树例子
在这里插入图片描述

3.1 先序线索化二叉树实现

线索化：和中序线索化实现一样(把中序遍历改为先序遍历)。
因为遍历的顺序不一样，所以需要注意的先序和中序有个地方不一样，先序我们要判断是否是左子树/右子树在进行递归，不然会出现死递归。

  • 判断是否是左子树(即不是前驱节点)：先序的遍历顺序是"根左右"，在对"左"节点进行遍历的时候当"左"节点没有左子树时，“左"节点的前驱节点就设置为"根"节点，此时在遍历”左“节点的"左"节点，就又会遍历"根节点”，就会形成死循环。

如上图中的 D.getLeft() 是前驱节点不是左子树，如果不判断就会在像B和D节点这种节点上死循环根左根左根左…，一直输出BDBDBD…。

  • 判断是否是右子树(即不是后继节点)：同理如果不判断就会进入死递归

💻 代码实现

package com.yao.tree;

/**
 * @Author: Yao
 * @Date: 2021/10/20 15:06
 */
public class ThreadedBinaryTreeDemo {
    public static void main(String[] args) {

        //测试
        HeroNode3 root = new HeroNode3(1, "tom");
        HeroNode3 node2 = new HeroNode3(3, "jack");
        HeroNode3 node3 = new HeroNode3(6, "mary");
        HeroNode3 node4 = new HeroNode3(8, "jon");
        HeroNode3 node5 = new HeroNode3(10, "mali");
        HeroNode3 node6 = new HeroNode3(14, "hh");

        ThreadedBinaryTree threadedBinaryTree = new ThreadedBinaryTree(root);
        root.setLeft(node2);
        root.setRight(node3);
        node2.setLeft(node4);
        node2.setRight(node5);
        node3.setLeft(node6);



        //进行先序线索化
        System.out.println("-----------------进行先序线索化----------------");
        threadedBinaryTree.threadedBinaryTreePre(root);
        //测试 10 节点
        System.out.println(node5.getLeft()+" --> "+node5.getLeftType());
        System.out.println(node5.getRight()+" --> "+node5.getRightType());

    }
}

/*
ThreadedBinaryTree 线索化二叉树
 */
class ThreadedBinaryTree{

    private HeroNode3 root;

    //为了实现线索化二叉树，需要创建一个指向当前节点的前驱结点的指针
    private HeroNode3 per;

    public ThreadedBinaryTree(HeroNode3 root) {
        this.root = root;
    }

    /**
     * 先序线索化二叉树
     * @param node 需要线索化的节点
     */
    public void threadedBinaryTreePre(HeroNode3 node){
        if (node == null){
            return;
        }
        //线索化当前节点
        if (node.getLeft() == null){
            node.setLeft(per);
            node.setLeftType(1);
        }

        if (per != null && per.getRight() == null){
            per.setRight(node);
            per.setRightType(1);
        }

        per = node;

        if (node.getLeftType() == 0){  //如果不进行判断，就会进入死递归
            //线索化左子树
            threadedBinaryTreePre(node.getLeft());
        }

        if (node.getRightType() == 0){
            //线索化右子树
            threadedBinaryTreePre(node.getRight());
        }
    }
}

//HeroNode3
class HeroNode3{

    private int no;

    private String name;

    private HeroNode3 left;

    private HeroNode3 right;

    //说明 如果 leftType == 0 表示leftType指向的是左子树，leftType == 1，表示指向的是 前驱结点
    private int leftType;
    //说明 如果 rightType == 0 表示rightType指向的是右子树，rightType == 0，表示指向的是 后继节点
    private int rightType;

    public HeroNode3(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 HeroNode3 getLeft() {
        return left;
    }

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

    public HeroNode3 getRight() {
        return right;
    }

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

    public int getLeftType() {
        return leftType;
    }

    public void setLeftType(int leftType) {
        this.leftType = leftType;
    }

    public int getRightType() {
        return rightType;
    }

    public void setRightType(int rightType) {
        this.rightType = rightType;
    }

    @Override
    public String toString() {
        return "HeroNode3{" +
                "no=" + no +
                ", name='" + name + '\'' +
                '}';
    }
}
3.2 先序线索化二叉树遍历实现

从根节点一直遍历到最左节点(根节点没有左节点的话，根节点就是"最左节点")，最左节点的右节点(右子树或后继节点)就是下一个要遍历的节点，一直重复这个步骤，先序线索二叉树的遍历就完成了。

思路分析：

在这里插入图片描述
在这里插入图片描述

💻 代码实现

/**
     * 遍历先序线索化二叉树
     * @param node 根节点
     */
    public void threadedBinaryTreePreList(HeroNode3 node){
        if (node == null){
            return;
        }
        //遍历前序线索化二叉树比较简单，从根节点一直遍历到最左节点，当前节点的后继节点就是下一个要遍历的节点
        while (node != null){
            System.out.println(node);
            if (node.getLeft() != null && node.getLeftType() == 0){
                node = node.getLeft();
            }else {
                node = node.getRight();
            }
        }
    }

4、后序线索化二叉树

后序线索化二叉树例子
在这里插入图片描述

4.1 后序线索化二叉树实现

线索化：和中序线索化实现一样(把中序遍历改为后序遍历)。

💻 代码实现

package com.yao.tree;

/**
 * @Author: Yao
 * @Date: 2021/10/20 15:06
 */
public class ThreadedBinaryTreeDemo {
    public static void main(String[] args) {

        //测试
        HeroNode3 root = new HeroNode3(1, "tom");
        HeroNode3 node2 = new HeroNode3(3, "jack");
        HeroNode3 node3 = new HeroNode3(6, "mary");
        HeroNode3 node4 = new HeroNode3(8, "jon");
        HeroNode3 node5 = new HeroNode3(10, "mali");
        HeroNode3 node6 = new HeroNode3(14, "hh");

        ThreadedBinaryTree threadedBinaryTree = new ThreadedBinaryTree(root);
        root.setLeft(node2);
        root.setRight(node3);
        node2.setLeft(node4);
        node2.setRight(node5);
        node3.setLeft(node6);

        //进行后序线索化
        System.out.println("-----------------进行后序线索化----------------");
        threadedBinaryTree.threadedBinaryTreePost(root);
        //测试 10 节点
        System.out.println(node5.getLeft()+" --> "+node5.getLeftType());
        System.out.println(node5.getRight()+" --> "+node5.getRightType());

    }
}

/*
ThreadedBinaryTree 线索化二叉树
 */
class ThreadedBinaryTree{

    private HeroNode3 root;

    //为了实现线索化二叉树，需要创建一个指向当前节点的前驱结点的指针
    private HeroNode3 per;

    public ThreadedBinaryTree(HeroNode3 root) {
        this.root = root;
    }
    
    /**
     * 后序线索化二叉树
     * @param node 需要线索化的节点
     */
    public void threadedBinaryTreePost(HeroNode3 node){
        if (node == null){
            return;
        }
        //线索化左子树
        threadedBinaryTreePost(node.getLeft());
        //线索化右子树
        threadedBinaryTreePost(node.getRight());
        //线索化当前节点

        if (node.getLeft() == null){
            node.setLeft(per);
            node.setLeftType(1);
        }

        if (per != null && per.getRight() == null){
            per.setRight(node);
            per.setRightType(1);
        }
        per = node;
    }

}

//HeroNode3
class HeroNode3{

    private int no;

    private String name;

    private HeroNode3 left;

    private HeroNode3 right;

    //说明 如果 leftType == 0 表示leftType指向的是左子树，leftType == 1，表示指向的是 前驱结点
    private int leftType;
    //说明 如果 rightType == 0 表示rightType指向的是右子树，rightType == 0，表示指向的是 后继节点
    private int rightType;

    public HeroNode3(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 HeroNode3 getLeft() {
        return left;
    }

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

    public HeroNode3 getRight() {
        return right;
    }

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

    public int getLeftType() {
        return leftType;
    }

    public void setLeftType(int leftType) {
        this.leftType = leftType;
    }

    public int getRightType() {
        return rightType;
    }

    public void setRightType(int rightType) {
        this.rightType = rightType;
    }

    @Override
    public String toString() {
        return "HeroNode3{" +
                "no=" + no +
                ", name='" + name + '\'' +
                '}';
    }
}
4.2 后序线索化二叉树遍历实现

  • 遍历的起点：根节点左子树最左边的节点。该节点不一定是第一个打印数据的节点，该节点可能存在右子树，存在右子树要遍历右子树。

  • 后继：一直遍历该节点的后继节点，没有后继节点就判断是不是根节点(根节点没有右子树时就会出现这种情况)。如果不是根节点，那就找到节点的父亲，一直到找到根节点，继续判断根节点是不是存在右子树。

思路分析：

在这里插入图片描述
在这里插入图片描述
💻 代码实现

package com.yao.tree;

/**
 * @Author: Yao
 * @Date: 2021/10/20 15:06
 */
public class ThreadedBinaryTreeDemo {
    public static void main(String[] args) {

        //测试
        HeroNode3 root = new HeroNode3(1, "tom");
        HeroNode3 node2 = new HeroNode3(3, "jack");
        HeroNode3 node3 = new HeroNode3(6, "mary");
        HeroNode3 node4 = new HeroNode3(8, "jon");
        HeroNode3 node5 = new HeroNode3(10, "mali");
        HeroNode3 node6 = new HeroNode3(14, "hh");

        ThreadedBinaryTree threadedBinaryTree = new ThreadedBinaryTree(root);
        root.setLeft(node2);
        root.setRight(node3);
        node2.setLeft(node4);
        node2.setRight(node5);
        node2.setParent(root);
        node3.setLeft(node6);
        node3.setParent(root);
        node4.setParent(node2);
        node5.setParent(node2);
        node6.setParent(node3);


        //进行后序线索化
        System.out.println("-----------------进行后序线索化----------------");
        threadedBinaryTree.threadedBinaryTreePost(root);
        //测试 10 节点
        System.out.println(node5.getLeft()+" --> "+node5.getLeftType());
        System.out.println(node5.getRight()+" --> "+node5.getRightType());
        System.out.println("后序线索化二叉树遍历.........");
        threadedBinaryTree.threadedBinaryTreePostList(root);

    }
}

/*
ThreadedBinaryTree 线索化二叉树
 */
class ThreadedBinaryTree{

    private HeroNode3 root;

    //为了实现线索化二叉树，需要创建一个指向当前节点的前驱结点的指针
    private HeroNode3 per;

    public ThreadedBinaryTree(HeroNode3 root) {
        this.root = root;
    }

    /**
     * 后序线索化二叉树
     * @param node 需要线索化的节点
     */
    public void threadedBinaryTreePost(HeroNode3 node){
        if (node == null){
            return;
        }
        //线索化左子树
        threadedBinaryTreePost(node.getLeft());
        //线索化右子树
        threadedBinaryTreePost(node.getRight());
        //线索化当前节点

        if (node.getLeft() == null){
            node.setLeft(per);
            node.setLeftType(1);
        }

        if (per != null && per.getRight() == null){
            per.setRight(node);
            per.setRightType(1);
        }
        per = node;
    }


    /**
     * 遍历后序线索化二叉树
     * @param node 根节点
     */
    public void threadedBinaryTreePostList(HeroNode3 node){

        if (node == null){
            return;
        }

        HeroNode3 temp = node;
        //定义一个辅助指针
        HeroNode3 pre = null;


        while (temp != null){

            //从根节点的左子树开始找到最左边的节点
            while (temp.getLeft() != null && temp.getLeftType() == 0){
                temp = temp.getLeft();
            }

            while (temp != null && temp.getRightType() == 1){  //最左节点含有后继节点
                System.out.println(temp);
                pre = temp;
                temp = temp.getRight();
            }

            if (temp == node){
                System.out.println(temp);
                return;
            }

            while (temp != null && temp.getRight() == pre){
                System.out.println(temp);
                pre = temp;
                temp = temp.getParent();
            }

            if (temp != null && temp.getRightType() == 0){
                temp = temp.getRight();
            }

        }
    }


}

//HeroNode3
class HeroNode3{

    private int no;

    private String name;

    //添加父节点
    private HeroNode3 parent;

    private HeroNode3 left;

    private HeroNode3 right;

    //说明 如果 leftType == 0 表示leftType指向的是左子树，leftType == 1，表示指向的是 前驱结点
    private int leftType;
    //说明 如果 rightType == 0 表示rightType指向的是右子树，rightType == 0，表示指向的是 后继节点
    private int rightType;

    public HeroNode3(int no, String name) {
        this.no = no;
        this.name = name;
    }

    public HeroNode3 getParent() {
        return parent;
    }

    public void setParent(HeroNode3 parent) {
        this.parent = parent;
    }

    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 HeroNode3 getLeft() {
        return left;
    }

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

    public HeroNode3 getRight() {
        return right;
    }

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

    public int getLeftType() {
        return leftType;
    }

    public void setLeftType(int leftType) {
        this.leftType = leftType;
    }

    public int getRightType() {
        return rightType;
    }

    public void setRightType(int rightType) {
        this.rightType = rightType;
    }

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

🎃 完结

_子栖_
关注
  • 15
    点赞
  • 踩
  • 65
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
线索化二叉树C实现代码
02-24
包含两种线索化二叉树方法，具体如下： 1.利用结点中的空指针域，使其指向后继结点； 2.利用线性表保存二叉树的遍历顺序。
线索二叉树
weixin_45863060的博客
05-18 1万+
线索二叉树 线索二叉树的概念： 1.线索： 线索是一种对二叉树的操作，意思是对二叉树进行线索化，其目的是使线索化后的二叉树具有方便被遍历的特点，被线索化后的二叉树实际上是一个双向链表。 2.基于中序遍历的线索二叉树： 中序遍历，即先遍历节点的左孩子，再遍历节点本身，最后遍历节点的右孩子。 3.前驱与后继： 基于这样的顺序得到的对所有节点的遍历顺序中，在某一节点前一个被遍历的节点称之为该节点的前驱，而在该节点后一个被遍历的节点称之为该节点的后继。 4.线索化节点的标记： 线索二叉树的节点定义有所改变，需要两个
B树与B+树区别
最新发布
Hubery_sky的博客
05-26 1464
总之,B+树相比B树有更好的空间利用率和查询性能,更适合用作大型数据库的索引结构。近日总结：做了一个梦，去实习了，实习场景忒吓人了，吓得我在梦里连夜跑了。
数据结构——二叉树线索化
m0_74222411的博客
08-13 2129
根据某种遍历序列（前、中后序遍历），先确定下来每个节点的前驱和后继。对于每个节点来说，他的左右指针可能没有指向节点（值为NULL），这时候我们可以运用这些“空闲”的指针。比如：左指针如果有空闲，就用这个指针指向这个节点对应遍历序列的前驱，右指针如果有空闲，就用这个指针指向这个节点对应遍历序列的后继。（注意：遍历序列中一头一尾是没有前驱或者后继的，所以如果指针有空闲，我们还是当它指向的是孩子，而不是前驱或者后继）对于每个节点都实现了步骤2后，线索化完成。
【考研】数据结构——线索二叉树
qq_34438969的博客
09-20 4312
本文内容源于对《数据结构（C语言版）》（第2版）、王道讲解学习所得心得、笔记整理和总结。本文针对线索二叉树，在最后的练习中，以举例子说明该排序方法，配以图文，讲解详细（含408真题）。【考研】《数据结构》知识点总结.pdf_考研-其它文档类资源-CSDN下载【2023考研】数据结构常考应用典型例题（含真题）_住在阳光的心里的博客-CSDN博客//二叉树的二又线索存储表示以这种结点结构构成的二叉链表作为二叉树的存储结构，叫做线索链表，其中指向结点前驱和后继的指针，叫做线索。
线索化二叉树的作用
学Java，找哪吒
08-16 1万+
一、先看一个问题 将数列{1,3,6,8,10,14}构建成一颗二叉树。 问题分析： 当我们对上面的二叉树进行中序遍历时，数列为{8,3,10,1,6,14}。 但是6,8,10,14这几个节点的左右指针，并没有完全的利用上。 如果我们希望充分的利用各个节点的左右指针，让各个节点可以指向自己的前后节点，要怎么办？ 解决方案 --> 线索化二叉树 二、线索化二叉树 1、n个节点的二叉树链表总含有n+1（公式2n-(n-1)=n+1）个空指针域。...
数据结构之线索二叉树详细解释
热门推荐
m0_61886762的博客
05-02 2万+
1.1 线索二叉树的原理 我们现在倡导节约型社会，一切都应该以节约为本。但当我们创建二叉树时我们会发现其中一共有两个指针域，有的指针域指向的结构为空，这也就浪费了很多空间
线索二叉树(线索链表遍历，二叉树线索化)
m0_63223213的博客
07-27 4984
特别的是，对于D和F，D是中序遍历的开头结点，它没有前驱节点；F是中序遍历的结尾的结点，它没有后继节点，那么这时，寻找的规则是，如果结点的Ltag==1代表可以直接找到前驱节点；由下图可见，有的左右指针是连接的子树，没有链接左右子树的指针现在就通过红色的虚线指向了该结点的前驱或者后继。可以发现，相较于原来的二叉链表，这里在数据结构里添加了两个int类型，来规定左右指针的作用。再通过以下步骤创建一个线索二叉树（下图是中序线索二叉树的结构示意）线索二叉树，即在二叉链表的基础上，将二叉链表的。...
数据结构--二叉树--线索化二叉树
04-19
线索化二叉树的实现和应用是数据结构课程中的一个经典课题，它要求程序员对二叉树的遍历算法有深入的理解。通过学习和实践这个主题，不仅可以提高对二叉树操作的熟练度，还能为理解其他高级数据结构和算法打下坚实的...
数据结构——二叉树 线索化二叉树 C语言
03-16
中序线索二叉树，反方向进行中序遍历(要求非递归，顺前驱进行)。 （1）建立二叉树； (2) 按先序、中序、后序输出二叉树; （3）复制二叉树； （4）在字符模式下画出无缺陷的二叉树
数据结构之线索二叉树-C语言实现.pdf
01-15
总的来说，线索二叉树是一种优化二叉树遍历的数据结构，通过在二叉链表中添加线索，可以避免在遍历时反复查找前驱和后继结点，提高了遍历效率。在C语言中实现线索二叉树需要理解二叉树的结构，并正确处理各种插入和...
C语言数据结构之线索二叉树及其遍历
08-29
线索二叉树是一种特殊的二叉树结构，它的设计目的是为了在非递归方式下更高效地查找二叉树中节点的前驱和后继。在普通的二叉链表中，节点仅通过...理解线索二叉树的原理和实现，对于深入学习数据结构和算法至关重要。
二叉树的线索化
weixin_55504695的博客
10-28 1732
在二叉树中，假设有n个叶子节点，那会产生n+1个空节点，而线索化二叉树就是将这些空节点利用起来，建立指向该节点的前驱后者后继节点的指针。 虽然说可以有三种遍历的方式来线索化二叉树，但是在实际应用中一般都是使用中序线索化，具体原因在后面说 在线索化二叉树中， 因为要分清左右节点是前驱/后继还是左右子树，所以需要对节点做一些修改，添加上一个标记来表示具体的节点， 下面来看一个具体的例子来了解如何进行中序线索化 首先是可以写出这棵树的中序遍历，BCAED,然后按照该顺序一个节点一个节点地判断。 .
数据结构——二叉树、线索化二叉树
m0_52861211的博客
04-12 411
树，二叉树，线索化二叉树，二叉树遍历，二叉树删除节点，线索化二叉树，遍历线索化二叉树
关于线索二叉树的详解
kcy的博客
11-16 1万+
线索二叉树的详解 目录线索二叉树的详解前言一、线索二叉树是什么？三种二叉树线索化实例图二、实现线索二叉树1.二叉树的线索化2.线索二叉树的遍历中序线索二叉树寻找遍历的首节点中序线索二叉树寻找节点的直接后继遍历中序线索二叉树总结 前言 学了二叉树，我们发现，对二叉树的遍历是一个比较复杂的问题，需要用到递归或者栈才可以进行遍历，这样子的遍历实质上就是将二叉树化为一个有序的线性序列，在这个序列中，每一个节点有且只有一个前继节点（第一个节点除外），和一个后继节点（最后一个节点除外），但是这些节点不能直接的找到当
【尚硅谷】数据结构与算法——线索化二叉树
weixin_54533016的博客
04-21 372
跟着B站的尚硅谷学习数据结构与算法，语言为java，目前是第十四个代码内容——线索化二叉树尚硅谷——线索化二叉树1）n 个结点的二叉链表中含有 n+1 [ 公式：2n - ( n - 1) = n + 1 ] 个空指针域。利用二叉链表中的空指针域，存放指向结点在某种遍历次序下的前驱和后继结点的指针（这种附加的指针称为“ 线索 ”）2）这种加上了线索的二叉链表称为线索链表，相应的二叉树称为线索二叉树（Threaded BinaryTree）。根据线索性质的不同，线索二叉树可分为前序线索二叉树。
【数据结构】-树-先序线索二叉树，中序线索二叉树，后序线索二叉树
vector的博客
06-14 5367
先序线索二叉树，中序线索二叉树，后序线索二叉树之间的对比 结论： 1.先序线索二叉树找前驱节点困难，找后继节点简单 后序线索二叉树找后继节点困难，找前驱节点简单 中序线索二叉树找前驱节点，后继节点都很简单 2.遍历中序和先序线索二叉树，不需要栈，直接通过线索就可以实现 遍历后序线索二叉树，要用栈 注： 1.三种线索二叉树的叶子节点数都能通过线索直接找到前驱和后继，因此分析能否直接遍历，只需要看前非叶子节点是否能找到自己的前驱和后继就好了。 2.三种遍历前驱和后继的位置 ...
数据结构中的线索化二叉树
05-26
在普通的二叉树中，如果要遍历整个二叉树，需要使用递归或者栈等数据结构来实现，而线索化二叉树可以直接通过线索来遍历整个二叉树，从而避免了使用递归或者栈的开销。 线索化二叉树分为前序线索化二叉树、中序线索...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

_子栖_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值