数据结构与算法学习十七：顺序储存二叉树、线索化二叉树

最新推荐文章于 2022-11-23 15:37:52 发布
最新推荐文章于 2022-11-23 15:37:52 发布
阅读量273 收藏 3
点赞数
分类专栏： 数据结构与算法 文章标签： 二叉树 算法 链表 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40036754/article/details/106175282
版权

文章目录

一、顺序储存二叉树

1.1 概念

从数据存储来看，数组存储方式和树的存储方式可以相互转换，即数组可以转换成树，树也可以转换成数组，
看下面的示意图。
在这里插入图片描述

1.2 特点

  • 顺序二叉树通常只考虑 完全二叉树:
  1. 第n个元素的左子节点为 2 * n + 1
  2. 第n个元素的右子节点为 2 * n + 2
  3. 第n个元素的父节点为 (n-1) / 2
  • n : 表示二叉树中的第几个元素(按0开始编号如图所示,同时对应的也是数组的顺序)
    在这里插入图片描述

复习一下完全二叉树：如果该二叉树的所有叶子节点都在最后一层或者倒数第二层，而且最后一层的叶子节点在左边连续，倒数第二层的叶子节点在右边连续，我们称为 完全二叉树。

1.3 关系

树的存储方式可以与数组的方式可以互换，我看出来的一个规律，二叉树的层次遍历就是数组的储存方式。

如果要将二叉树转为数组存储，既可以层次遍历然后储存到数组中即可。

1.4 案例

  1. 上图的二叉树的结点，要求以数组的方式来存放 array : [1, 2, 3, 4, 5, 6, 7]
  2. 要求在遍历数组 array 时，仍然可以以 前序遍历，中序遍历和后序遍历 的方式完成结点的遍历。
  3. 手写三种遍历，与代码进行比较
    前序遍历：1 2 4 5 3 6 7
    中序遍历：4 2 5 1 6 3 7
    后序遍历：4 5 2 6 7 3 1

1.5 代码实现

1.5.1 ArrayBinaryTree 二叉树类

package com.feng.ch12_tree.t2_arraybinarytree;

/*
 * 编写一个 ArrayBinaryTree， 实现顺序存储二叉树遍历
 * 数组 和 二叉树的 对应规律
 * */
class ArrayBinaryTree {

    private int[] array; // 存储数据结点的数组

    public ArrayBinaryTree(int[] array) {
        this.array = array;
    }

    // 重载perOrder（）
    public void preOrder() {
        this.preOrder(0);
    }
    public void infixOrder() {
        this.infixOrder(0);
    }
    public void postOrder() {
        this.postOrder(0);
    }



    /*
     * 编写一个方法，完成顺序储存二叉树的一个前序遍历
     * @param index 数组的下标
     * */
    public void preOrder(int index) {
        // 如果数组为空，或者 array。length = 0
        if (array == null || array.length == 0) {
            System.out.println("数组为空，不能按照二叉树的前序遍历");
        }
        // 输出当前这个元素
        System.out.print(array[index] + " ");
        // 向左递归遍历
        if ((index * 2 + 1) < array.length) {
            preOrder(2 * index + 1);
        }

        // 向右递归遍历
        if ((index * 2 + 2) < array.length) {
            preOrder(2 * index + 2);
        }
    }

    /*
     * 方法，完成顺序储存二叉树的一个中序遍历
     * @param index 数组的下标
     * */
    public void infixOrder(int index){
        // 如果数组为空，或者 array。length = 0
        if (array == null || array.length == 0) {
            System.out.println("数组为空，不能按照二叉树的前序遍历");
        }
        // 向左递归遍历
        if ((index * 2 + 1) < array.length) {
            infixOrder(2 * index + 1);
        }
        // 输出当前这个元素
        System.out.print(array[index] + " ");
        // 向右递归遍历
        if ((index * 2 + 2) < array.length) {
            infixOrder(2 * index + 2);
        }

    }

    /*
     * 方法，完成顺序储存二叉树的一个后序遍历
     * @param index 数组的下标
     * */
    public void postOrder(int index){
        // 如果数组为空，或者 array。length = 0
        if (array == null || array.length == 0) {
            System.out.println("数组为空，不能按照二叉树的前序遍历");
        }
        // 向左递归遍历
        if ((index * 2 + 1) < array.length) {
            postOrder(2 * index + 1);
        }
        // 向右递归遍历
        if ((index * 2 + 2) < array.length) {
            postOrder(2 * index + 2);
        }
        // 输出当前这个元素
        System.out.print(array[index] + " ");
    }
}

1.5.2 T2_ArrayBinaryTreeMain 测试类

package com.feng.ch12_tree.t2_arraybinarytree;

/*
* 顺序储存二叉树
*
* 从数据存储来看，数组存储方式和树的存储方式可以相互转换，即数组可以转换成树，树也可以转换成数组
* 对应的规律为：
* 1、第n个元素的左子节点为  2 * n + 1
* 2、第n个元素的右子节点为  2 * n + 2
* 3、第n个元素的父节点为  (n-1) / 2
* 4、注意 上面的 n : 表示二叉树中的第几个元素(按0开始编号）比如 根节点 的索引 n = 0;
* 也是对应数组里的元素，下标正好也是从0开始的。
*
* 这里将使用数组 来 储存二叉树，进行前序、后序、中序的排列。
*
* 扩展、思考：
* 二叉树转化为数组储存，其实就是二叉树的 层次遍历 后的结果。
* */
public class T2_ArrayBinaryTreeMain {

    public static void main(String[] args) {
//        int array[] = {1, 3, 4, 6, 8, 9, 15};
        int array[] = {1, 3, 4, 6, 8, 9, 15};

        ArrayBinaryTree arrayBinaryTree = new ArrayBinaryTree(array);
        System.out.println("前序序遍历：");
        arrayBinaryTree.preOrder(); // 1 3 6 8   4 9 15
        System.out.println();

        System.out.println("中序遍历：");
        arrayBinaryTree.infixOrder(); // 6 3 8 1 9 4 15
        System.out.println();

        System.out.println("后序遍历：");
        arrayBinaryTree.postOrder(); // 6 8 3 9 15 4 1
    }
}

1.5.3 测试结果

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

1.6 ** 实际应用 **

八大排序算法中的堆排序，就会使用到顺序存储二叉树， 关于堆排序，我们放在<<树结构实际应用>> 章节讲解。

二、线索化二叉树（学的不太好，没深入）

2.1 先看一个问题

将数列 {1, 3, 6, 8, 10, 14 } 构建成一颗二叉树. n+1=7， 7个空指针域
在这里插入图片描述
问题分析:

  1. 当我们对上面的二叉树进行中序遍历时，数列为 {8, 3, 10, 1, 14, 6 }
  2. 但是 6, 8, 10, 14 这几个节点的 左右指针，并没有完全的利用上.
  3. 如果我们希望充分的利用 各个节点的左右指针， 让各个节点可以指向自己的前后节点,怎么办?
  4. 解决方案-线索二叉树

2.1 线索二叉树基本介绍

线索二叉树基本介绍

  1. n个结点的二叉链表中含有n+1 【公式 2n-(n-1)=n+1】 个空指针域。利用二叉链表中的空指针域，存放指向该结点在某种遍历次序下的前驱和后继结点的指针（这种附加的指针称为"线索"）

  2. 这种加上了线索的二叉链表称为线索链表，相应的二叉树称为线索二叉树(Threaded BinaryTree)。根据线索性质的不同，线索二叉树可分为前序线索二叉树、中序线索二叉树和后序线索二叉树三种

  3. 一个结点的前一个结点，称为 前驱结点

  4. 一个结点的后一个结点，称为 后继结点

2.2 案例

应用案例说明：将下面的二叉树，进行中序线索二叉树。中序遍历的数列为 {8, 3, 10, 1, 14, 6}
在这里插入图片描述
思路分析：中序遍历的结果：{8, 3, 10, 1, 14, 6}
在这里插入图片描述
说明: 当线索化二叉树后，Node节点的 属性 left 和 right ，有如下情况:

  1. left 指向的是左子树，也可能是指向的前驱节点. 比如 ① 节点 left 指向的左子树, 而 ⑩ 节点的 left 指向的就是 前驱节点.
  2. right指向的是右子树，也可能是指向后继节点，比如 ① 节点right 指向的是右子树，而⑩ 节点的right 指向的是 后继节点.

2.3 代码实现

2.3.1 HeroNode 结点类

package com.feng.ch12_tree.t3_threadedbinarytree;

/*
 * 创建 HeroNode 结点
 * */
class HeroNode {
    private int no;
    private String name;
    private HeroNode left;
    private HeroNode right;

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

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

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

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

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

2.3.2 ThreadedBinaryTree 线索化二叉树

package com.feng.ch12_tree.t3_threadedbinarytree;

/*
 * 定义 ThreadedBinaryTree 实现了线索化功能的二叉树
 * */
class ThreadedBinaryTree {
    private HeroNode root;

    // 为了实现线索化，需要创建要给指向当前结点的前驱结点的指针
    // 在递归进行线索化时，pre 总是要保留前一个结点
    private HeroNode pre = null;

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

    // 重载 threadedNodes
    public void threadedNodes() {
        this.threadedNodes(root);
    }

    /*
     * 编写对二叉树 进行中序线索化的方法
     *
     * @param node 就是当前需要线索化的结点
     * */
    public void threadedNodes(HeroNode node) {
        // node == null。不能线索化
        if (node == null) {
            return;
        }
        // (1) 先线索化左子树
        threadedNodes(node.getLeft());

        // (2) 再线索化当前结点
        // 2.1 先处理当前结点的前驱结点
        // 以8结点来理解: 8结点的.left = null , 8结点的.leftType = 1
        if (node.getLeft() == null) {
            // 让当前结点的左指针指向前驱结点
            node.setLeft(pre);
            // 修改当前结点的左指针的类型，指向前驱结点
            node.setLeftType(1);
        }
        // 2.2 处理后继节点
        if (pre != null && pre.getRight() == null) {
            // 前驱结点的右指针指向当前结点
            pre.setRight(node);
            // 修改前驱结点的右指针类型
            pre.setRightType(1);
        }
        // !!! 每处理一个结点后，让当前结点是下一个结点的前驱结点
        pre = node;

        // (3) 先线索化右子树
        threadedNodes(node.getRight());
    }

    /*
     * 中序遍历 线索化二叉树的方法
     * */
    public void threadedInfixList() {
        // 定义一个变量，储存当前遍历的节点，从root开始
        HeroNode node = root;
        if (root == null) {
            System.out.println("链表为空，无法遍历");
        }
        while (node != null) {
            // 循环的找到 leftType == 1 的结点，第一个找到就是 8 结点
            // 后面随着遍历而变化，因为当 leftType== 1 时。说明该结点是按照线索化
            // 处理后的有效节点
            while (node.getLeftType() == 0) {
                node = node.getLeft();
            }

            // 打印当前这个结点
            System.out.println(node);

            // 如果当前结点的右指针指向的是后继结点，就一直输出
            while (node.getRightType() == 1) {
                // 获取到当前结点的后继结点
                node = node.getRight();
                System.out.println(node);
            }
            // 替换这个遍历的节点
            node = node.getRight();
        }
    }

    /*
     * 前序遍历 线索化二叉树的方法
     * */
    public void threadedPreList() {
        // 定义一个变量，储存当前遍历的节点，从root开始
        HeroNode node = root;
        if (root == null) {
            System.out.println("链表为空，无法遍历");
        }

        while (node != null) {
            // 打印当前这个结点
            System.out.println(node);

            // 循环的找到 leftType == 1 的结点，第一个找到就是 8 结点
            // 后面随着遍历而变化，因为当 leftType == 1 时。说明该结点是按照线索化
            // 处理后的有效节点
            while (node.getLeftType() == 0) {
                node = node.getLeft();
                System.out.println(node);
            }

            // 如果当前结点的右指针指向的是后继结点，就一直输出
            while (node.getRightType() == 1) {
                // 获取到当前结点的后继结点
//                System.out.println(node);
                node = node.getRight();
            }
            // 替换这个遍历的节点
            node = node.getRight();
        }
    }

    /*
     * 后序遍历 线索化二叉树的方法
     * */
    public void threadedPostList() {
        // 定义一个变量，储存当前遍历的节点，从root开始
        HeroNode node = root;
        if (root == null) {
            System.out.println("链表为空，无法遍历");
        }

        while (node != null) {
            // 循环的找到 leftType == 1 的结点，第一个找到就是 8 结点
            // 后面随着遍历而变化，因为当 leftType == 1 时。说明该结点是按照线索化
            // 处理后的有效节点
            while (node.getLeftType() == 0) {
                node = node.getLeft();
            }

            // 如果当前结点的右指针指向的是后继结点，就一直输出
            while (node.getRightType() == 1) {
                // 获取到当前结点的后继结点
                System.out.println(node);
                node = node.getRight();
            }

            // 打印当前这个结点
            System.out.println(node);
            // 替换这个遍历的节点
            node = node.getRight();
        }
    }
}

2.3.3 T3_ThreadedBinaryTreeMain 测试类

package com.feng.ch12_tree.t3_threadedbinarytree;

/*
 * 线索二叉树
 *
 * 1、n个结点的二叉链表中含有n+1  【公式 2n-(n-1)=n+1】 个空指针域。利用二叉链表中的空指针域，
 * 存放指向该结点在某种遍历次序下的前驱和后继结点的指针（这种附加的指针称为"线索"）
 * 2、这种加上了线索的二叉链表称为线索链表，相应的二叉树称为线索二叉树(Threaded BinaryTree)。
 * 根据线索性质的不同，线索二叉树可分为前序线索二叉树、中序线索二叉树和后序线索二叉树三种
 * 3、一个结点的前一个（左子）结点，称为前驱结点；一个结点的后一个（右子）结点，称为后继结点
 *
 * 一旦线索化后，原来的遍历方式不能使用，从新编写 遍历方法，无需使用递归
 *
 * */
public class T3_ThreadedBinaryTreeMain {

    public static void main(String[] args) {
        // 测试 中序线索二叉树的功能
        HeroNode root = new HeroNode(1, "tom");
        HeroNode node02 = new HeroNode(3, "jack");
        HeroNode node03 = new HeroNode(6, "smith");
        HeroNode node04 = new HeroNode(8, "mary");
        HeroNode node05 = new HeroNode(10, "king");
        HeroNode node06 = new HeroNode(14, "dim");

        // 二叉树，后面我们要递归创建，现在简单处理，使用手动创建
        root.setLeft(node02);
        root.setRight(node03);
        node02.setLeft(node04);
        node02.setRight(node05);
        node03.setLeft(node06);

        // 测试线索化
        ThreadedBinaryTree tree = new ThreadedBinaryTree();
        tree.setRoot(root);
        tree.threadedNodes();

        // 测试 ： 以10号为结点
        HeroNode leftNode05 = node05.getLeft();

        HeroNode rightNode05 = node05.getRight();
        System.out.println("10号结点的前驱结点是=" + leftNode05);
        System.out.println("10号结点的后继结点是=" + rightNode05);

        /*
         * 测试遍历
         * 这里的遍历 不能使用 T1_BinaryTreeMain.java 类中遍历方法了。为什么的话 去看代码即可。重新写
         * */
        System.out.println("使用线索化的方法 中序遍历 线索化二叉树 ");
        tree.threadedInfixList(); //8, 3, 10, 1, 14, 6
        System.out.println();

        System.out.println("使用线索化的方法 前序遍历 线索化二叉树 ");
        tree.threadedPreList(); //1 3 8 10 6 14
        System.out.println();

        /*
         * 这里不对 有问题。
         * */
        System.out.println("使用线索化的方法 后序遍历 线索化二叉树 ");
        tree.threadedPostList(); //8 10 3 14 6 1
        System.out.println();

    }

}

2.3.4 测试结果

在这里插入图片描述
后序线索化有点问题。。。。

java冯坚持
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构与算法简记：按层次顺序遍历和存储二叉树
LiuHe
07-22 6581
前面曾经记录过，给出一个按层次顺序排放的存储数据，进而可以构建出一棵二叉树，今天就来简单记录一下，如何按层次顺序遍历二叉树，最后又如何根据二叉树生成层次存储数据，对于满二叉树来讲这十分必要。对与这棵二叉树来说，它的层次遍历顺序和层次存储顺序分别为： A B E C D F A B E C D # F 按层次遍历思路： 首先将根节点放入队列。 取出队首元素并访问该节点，然后探索其左子树，如果
数据结构与算法 学习笔记（7）：二叉树和树
LSayhi的博客
03-24 536
数据结构与算法 学习笔记（7）：二叉树和树 本次文章主要记录了最近在LeetCode上刷的有关与二叉树和树的题目，主要涉及深度优先、广度优先、递归与非递归，并给出了算法和算法分析，如有错漏或更好的解法，欢迎到文末github中提交RP。 注：题号与LeetCode对应 题目1：100. Same Tree Given two binary trees, write a function to ch...
二叉树相关代码（从数组生成二叉树、中序线索化、层序遍历）
ZM970307的博客
04-12 571
最近，我把二叉树树的几个相关代码敲了一遍，均运行成功，在此上传博客，与大家分享。 代码主要包含： - 从键盘生成二叉树 - 从数组(vector)生成二叉树 - 二叉树的中序遍历 - 二叉树的中序线索化 - 线索二叉树的中序遍历 - 二叉树的层序遍历 树图： 附上代码： #define _CRT_SECURE_NO_WARNINGS #include &lt;stdio...
将顺序二叉树存储序列转化为链式存储序列-c语言
阿牛哥的博客
05-16 2948
将顺序二叉树存储序列转化为链式存储序列 - 题目描述： 将给定顺序二叉树存储序列转换为链式二叉树存储序列显示 char data[13] = {‘0’,‘A’,‘B’,‘C’,‘0’,‘D’,‘E’,‘F’,‘0’,‘0’,‘G’,‘H’,‘0’,‘I’} 题解思路：首先理解二叉树的顺序存储结构原理，首先根节点的编号（下标）为1的是根节点，左孩子下标为2i，右孩子是2i+1。在二叉树的链式存储中是按照先序输出的序列输出的，那么 思路一：二叉树的先序输出序列（包括‘0’）就是链式的输入输入序列。 思路二
二叉树的存储方式【顺序储存（数组）、链式存储、邻接表存储等】
热门推荐
马小超
09-18 2万+
1.顺序存储结构 二叉树的顺序存储，就是用一组连续的存储单元存放二叉树中的结点。因此，必须把二叉树的所有结点安排成为一个恰当的序列，结点在这个序列中的相互位置能反映出结点之间的逻辑关系，用编号的方法从树根起，自上层至下层，每层自左至右地给所有结点编号,缺点是有可能对存储空间造成极大的浪费，在最坏的情况下，一个深度为k且只有k个结点的右单支树需要2k-1个结点存储空间。 依据二叉树的性质，完全二叉树和满二叉树采用顺序存储比较合适，树中结点的序号可以唯一地反映出结点之间的逻辑关系，这样既能够最大可能地节省存
13 二叉树：建立存储结构（前序输入次序） &&二叉树专题
Ultravioletrays的博客
04-19 3802
目录 首先讲讲指针的引用 *& 然后我们再复习一下typedef的用法。 然后我们来创建二叉树 二叉树的建立 首先二叉树的存储结构（实际用代码体现）分为顺序存储和链式存储两种，但一般情况我们都用链式存储结构。 部分内容转自指针的引用 *&_MAGDB的博客-CSDN博客_指针的引用 首先讲讲指针的引用 *& 以下代码 void shit(student *p) { p->data=0; p=p->next; } void shit.
按照输入顺序建立二叉树（C语言实现）
weixin_43222033的博客
02-02 5488
按照输入顺序建立二叉树 首先定义二叉树节点的结构体 typedef struct node{ int data; struct node* left; struct node* right; }Node;//一个结构体包含数据域，左右子树的指针 注意这里的左子树和右子树的数据类型要设为指针 主要思路： 1.按顺序建立二叉树的过程实际上也可以看成是递归建立的过程； 2.如果此时函数传入的参数...
“数据结构与算法”课程学习总结报告
12-29
《“数据结构与算法”课程学习总结报告》 在学习“数据结构与算法”这门课程时，我们深入了解了线性结构、树结构和图结构中的数据表示与处理方法。这些知识是计算机科学中的基石，对于高效编程和优化至关重要。课程...
数据结构与算法课程总结
03-04
二叉树的建立、遍历、线索化和表达式求值等算法是学习内容，哈夫曼编码、平衡二叉排序树和堆排序是应用实例，平衡二叉排序树的实现是难点。 第八章“树和森林及其应用”扩展了二叉树的概念，介绍了树和森林的数据...
117.20180224 数据结构3 特殊二叉树1
08-08
二叉树 最优二叉树，也称为哈夫曼树或最小带权路径长度树，是一种特殊的二叉树，主要用于数据的无损压缩编码。...理解和掌握这些特殊二叉树的概念和应用，对于深入学习数据结构和算法以及解决实际问题具有重要意义。
算法线索二叉树PPT学习教案.pptx
10-05
根据遍历顺序的不同，可以得到前序线索二叉树、中序线索二叉树和后序线索二叉树。中序线索二叉树是最常用的，因为它能够直接支持中序遍历，因此有时也被称为线索二叉树。 6.4.2 线索二叉树的遍历算法： 对于中序...
动态规划算法学习三：0-1背包问题
最新发布
冯安晨
11-23 2663
动态规划算法学习三：0-1背包问题
动态规划算法学习二：最长公共子序列
冯安晨
11-22 1583
动态规划算法学习二：最长公共子序列
北京化工大学历年真题整理：没考上，换了个学校，但还是在北京~哈哈（总结的算法题，有缘人自取之）
冯安晨
06-29 1136
北京化工大学历年真题整理：没考上，换了个学校~
数据结构与算法学习八：前缀（波兰）表达式、中缀表达式、后缀（逆波兰）表达式的学习，中缀转后缀的两个方法，逆波兰计算器的实现
冯安晨
04-23 1058
文章目录前言一、前缀(波兰)表达式学习1.1 前缀表达式介绍1.2 前缀表达式的计算机求值1.3 后话二、中缀表达式学习三、后缀(逆波兰)表达式学习3.1 后缀表达式介绍3.2 后缀表达式的计算机求值3.3 构成方法3.3.1 PolandNotation类3.3.2 测试结果3.4 后话四、中缀表达式 转 后缀表达式4.1 方法一【超级简单，用于做题】4.2 方法二 代码实现中缀转后缀4....
数据结构与算法学习三：单链表的增加（添加到链尾，按顺序添加）、删除、查询、修改。
冯安晨
12-25 990
文章目录前言一、稀疏数组二、数组队列 前言 一、稀疏数组 二、数组队列
动态规划算法学习一：DP的重要知识点、矩阵连乘算法
冯安晨
11-21 977
动态规划算法学习一：DP的重要知识点、矩阵连乘算法
数据结构与算法学习十五：常用查找算法介绍，线性排序、二分查找（折半查找）算法、差值查找算法、斐波那契（黄金分割法）查找算法
冯安晨
05-02 927
文章目录前言一、查找算法 前言 一、查找算法
树的存储结构与算法：二叉树、线索二叉树与哈夫曼编码
"这篇资料主要介绍了树和二叉树的数据结构，包括树的定义、基本术语，二叉树的类型定义、性质、存储结构、遍历方法，线索二叉树，以及哈夫曼树和哈夫曼编码。资料中特别强调了建树的存储结构的算法，即通过二元组...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

java冯坚持

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

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

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

打赏作者

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

抵扣说明：

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

余额充值