第 10 章树结构的基础部分（二）-阿里云开发者社区

2、顺序存储二叉树

2.1、顺序存储二叉树的概念

2.1.1、顺序存储二叉树与数组的转换

基本说明：从数据存储来看，数组存储方式和树的存储方式可以相互转换，即数组可

以转换成树，树也可以转换成数组。

要求：

右图的二叉树的结点，要求以数组的方式来存放 arr : [1, 2, 3, 4, 5, 6, 6]

要求在遍历数组 arr时，仍然可以用前序遍历，中序遍历和后序遍历的方式完成结点的遍历

2.1.2、顺序存储二叉树的特点

顺序存储二叉树特点

顺序二叉树通常只考虑完全二叉树

顺序存储二叉树中第 n 个元素的左子节点对应的数组下标为 2 * n + 1

顺序存储二叉树中第 n 个元素的右子节点对应的数组下标为 2 * n + 2

顺序存储二叉树中第 n 个元素的父节点对应的数组下标为 (n-1) / 2

n 的含义：表示二叉树中的第几个元素（按0开始编号，如图所示）

下标怎么来的？

顺序存储二叉树通常只考虑完全二叉树，完全二叉树的节点个数规律为：1, 2, 4, 8, 12 , … 即 2 的 n 次方
每个父节点都会延伸出两个子节点，假设当前节点编号为 n （索引从 0 开始），设当前节点在第 x 层（索引从 1 开始），可得如下数据：

1~(x-1) 层所拥有的的节点个数：2n-1 -1

1~x 层所拥有的节点个数：2n - 1

在第 x 层，节点 n 后面有多少个节点：

back = 2n - 1 - n - 1 = 2n -n - 2

在第 x 层，节点 n 前面有多少个节点：

front = n - (2n-1 -1) = n - 2n-1 + 1

在第 x+1 层，节点 n 左节点前面有多少个节点：

frontDouble = 2 * (n - 2n-1 + 1) = 2n - 2n + 2

所以节点 n 左节点的索引为：

index = n + back + frontDouble + 1 = n + (2n -n - 2) + (2n - 2n + 2) + 1 = 2*n + 1

2.2、顺序存储二叉树的遍历

2.2.1、代码思路

和之前链表二叉树一样，之前用 left 指针和 right 指针寻找左右子节点，实现递归，只不过顺序存储二叉树使用数组下标寻找左右子节点
何时结束递归？当数组下标越界时，说明当前节点已经没有左节点或右节点，已经递归至最深处，此时就应该停止递归，开始回溯

2.2.2、前中后序遍历

编写顺序存储二叉树的前序、中序、后序遍历

//编写一个ArrayBinaryTree, 实现顺序存储二叉树遍历
class ArrBinaryTree {
  private int[] arr;// 存储数据结点的数组
  public ArrBinaryTree(int[] arr) {
    this.arr = arr;
  }
  // 重载preOrder
  public void preOrder() {
    this.preOrder(0);
  }
  // 顺序存储二叉树的前序遍历
  // index ：数组下标
  public void preOrder(int index) {
    // 如果数组为空，或者 arr.length = 0
    if (arr == null || arr.length == 0) {
      System.out.println("数组为空，不能执行二叉树的前序遍历");
    }
    // 输出当前这个元素
    System.out.println(arr[index]);
    // 向左递归遍历
    if ((index * 2 + 1) < arr.length) {
      preOrder(2 * index + 1);
    }
    // 向右递归遍历
    if ((index * 2 + 2) < arr.length) {
      preOrder(2 * index + 2);
    }
  }
  public void infixOrder() {
    this.infixOrder(0);
  }
  // 顺序存储二叉树的中序遍历
  public void infixOrder(int index) {
    // 如果数组为空，或者 arr.length = 0
    if (arr == null || arr.length == 0) {
      System.out.println("数组为空，不能执行二叉树的前序遍历");
    }
    // 向左递归遍历
    if ((index * 2 + 1) < arr.length) {
      infixOrder(2 * index + 1);
    }
    // 输出当前这个元素
    System.out.println(arr[index]);
    // 向右递归遍历
    if ((index * 2 + 2) < arr.length) {
      infixOrder(2 * index + 2);
    }
  }
  public void postOrder() {
    this.postOrder(0);
  }
  // 顺序存储二叉树的中序遍历
  public void postOrder(int index) {
    // 如果数组为空，或者 arr.length = 0
    if (arr == null || arr.length == 0) {
      System.out.println("数组为空，不能执行二叉树的前序遍历");
    }
    // 向左递归遍历
    if ((index * 2 + 1) < arr.length) {
      postOrder(2 * index + 1);
    }
    // 向右递归遍历
    if ((index * 2 + 2) < arr.length) {
      postOrder(2 * index + 2);
    }
    // 输出当前这个元素
    System.out.println(arr[index]);
  }
}

2.2.3、测试代码

• 代码

public static void main(String[] args) {
    int[] arr = { 1, 2, 3, 4, 5, 6, 7 };
    // 创建一个 ArrBinaryTree
    ArrBinaryTree arrBinaryTree = new ArrBinaryTree(arr);
    arrBinaryTree.preOrder(); // 1,2,4,5,3,6,7
    System.out.println();
    arrBinaryTree.infixOrder(); // 4,2,5,1,6,3,7
    System.out.println();
    arrBinaryTree.postOrder(); // 4,5,2,6,7,3,1
}

程序运行结果

2.3、顺序存储二叉树应用实例

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

3、线索化二叉树

3.1、引出问题

将数列 {1, 3, 6, 8, 10, 14 } 构建成一颗二叉树，当我们对这颗二叉树进行中序遍历时，输出数列为 {8, 3, 10, 1, 6, 14 }

但是 6, 8, 10, 14 这几个节点的左右指针，并没有完全的利用上，如果我们希望充分的利用各个节点的左右指针，让各个节点可以指向自己的前后节点，怎么办?

解决方案：线索二叉树

3.2、线索二叉树基本介绍

n 个结点的二叉链表中含有 n+1 【公式 2n-(n-1)=n+1】个空指针域。利用二叉链表中的空指针域，存放指向该结点在某种遍历次序下的前驱和后继结点的指针（这种附加的指针称为"线索"）
这种加上了线索的二叉链表称为线索链表，相应的二叉树称为线索二叉树(Threaded BinaryTree)。
根据线索性质的不同，线索二叉树可分为前序线索二叉树、中序线索二叉树和后序线索二叉树三种
前驱结点和后继节点：

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

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

当我们对二叉树进行中序遍历时，得到的数列为 {8, 3, 10, 1, 6, 14 }

那么 8 节点的前驱结点为 null ，8 和后驱节点为 3

那么 3 节点的前驱结点为 8 ，3 和后驱节点为 10

以此类推…

3.3、线索二叉树的生成

3.3.1、代码思路

如何实现线索二叉树？以中序线索化为例，按照上面的步骤操作即可
怎么知道当前节点的前驱结点和后继节点？

想想单链表的删除是怎么做的？我们记录当前节点的前一个节点，在程序中使用 pre 指针记录当前正在遍历的节点 curNode ，以及其前驱结点 preNode

如果条件满足，preNode 就是 curNode 的前驱结点：curNode.left = pre;

如果条件满足，curNode 节点就是 preNode 的后继节点：pre.right = curNode;

何时递归完毕？当前递归至最深层，curNode 为空时开始回溯：curNode == null
举例说明：

我们进行中序遍历时，先执行左递归至最深层

对于图例来说，就是递归到节点 8 左节点，满足 node.left == null ，开始执行回溯

于是我们回到节点8 ，该节点并没有前驱结点，即前驱结点为 null ，恰好此时 pre 也为 null

设置节点 8 的前驱结点：node.left = pre;

操作完成后，pre 和 node 指针向后移动一步

回溯到节点 3 ，节点 3 的 pre 节点是节点 8
设置节点 8 的后继节点：pre.right = node;
操作完成后，pre 和 node 指针向后移动一步

继续执行右递归，节点 10 的前驱结点为 3
设置节点 10 的前驱结点：node.left = pre;
操作完成后，pre 和 node 指针向后移动一步

以此类推，递归至最后，所有线索都已设置完毕
操作完成后，pre 和 node 指针向后移动一步，此时 node == null ，递归完毕，节点 6 的 right 指针的类型为真正的子节点，并非

大致流程：

递归结束条件：node == null
执行左递归
设置前驱结点、后继节点，并后移 pre 和 node 指针（pre 指针需手动移动，node 指针其实是通过递归来移动的）
执行右递归

关于线索化之后的二叉树：只有一个右节点的 right 域为 null ，这个右节点是整棵树最深层的右节点，遍历到该右节点时，表示整棵树遍历完成

3.3.2、代码实现

由于将原有的指针域（left 和 right 指针）指向了前驱节点和后继节点，所以代码里面需要表示当前指针到底是指向了真正的子节点还是前驱节点或后继节点
leftType 、rightType：0 表示指向真正的子节点，1 表示指向前驱节点或后继节点

//先创建HeroNode 结点
class HeroNode {
  private int no;
  private String name;
  private HeroNode left; // 默认null
  private HeroNode right; // 默认null
  // 说明
  // 1. 如果leftType == 0 表示指向的是左子树, 如果 1 则表示指向前驱结点
  // 2. 如果rightType == 0 表示指向是右子树, 如果 1表示指向后继结点
  private int leftType;
  private int rightType;
  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 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 + "]";
  }
}

线索二叉树的定义：

//定义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);
  }
  // 编写对二叉树进行中序线索化的方法
  // node 就是当前需要线索化的结点
  public void threadedNodes(HeroNode node) {
    // 如果node==null, 不能线索化
    if (node == null) {
      return;
    }
    // (一)先线索化左子树
    threadedNodes(node.getLeft());
    // (二)线索化当前结点[有难度]
    // 处理当前结点的前驱结点
    // 以8结点来理解
    // 8结点的.left = null , 8结点的.leftType = 1
    if (node.getLeft() == null) {
      // 让当前结点的左指针指向前驱结点
      node.setLeft(pre);
      // 修改当前结点的左指针的类型,指向前驱结点
      node.setLeftType(1);
    }
    // 处理后继结点
    if (pre != null && pre.getRight() == null) {
      // 让前驱结点的右指针指向当前结点
      pre.setRight(node);
      // 修改前驱结点的右指针类型
      pre.setRightType(1);
    }
    // !!! 每处理一个结点后，让当前结点是下一个结点的前驱结点
    pre = node;
    // (三)在线索化右子树
    threadedNodes(node.getRight());
  }
}

3.3.3、测试代码

代码

public static void main(String[] args) {
    // 测试一把中序线索二叉树的功能
    HeroNode root = new HeroNode(1, "tom");
    HeroNode node2 = new HeroNode(3, "jack");
    HeroNode node3 = new HeroNode(6, "smith");
    HeroNode node4 = new HeroNode(8, "mary");
    HeroNode node5 = new HeroNode(10, "king");
    HeroNode node6 = new HeroNode(14, "dim");
    // 二叉树，后面我们要递归创建, 现在简单处理使用手动创建
    root.setLeft(node2);
    root.setRight(node3);
    node2.setLeft(node4);
    node2.setRight(node5);
    node3.setLeft(node6);
    // 测试中序线索化
    ThreadedBinaryTree threadedBinaryTree = new ThreadedBinaryTree();
    threadedBinaryTree.setRoot(root);
    threadedBinaryTree.threadedNodes();
    // 测试: 以10号节点测试
    HeroNode leftNode = node5.getLeft();
    HeroNode rightNode = node5.getRight();
    System.out.println("10号结点的前驱结点是 =" + leftNode); // 3
    System.out.println("10号结点的后继结点是=" + rightNode); // 1
}

程序运行结果

10号结点的前驱结点是 =HeroNode [no=3, name=jack]
10号结点的后继结点是=HeroNode [no=1, name=tom]

3.4、线索二叉树的遍历

3.4.1、代码思路

为什么我们要做线索化？

因为线索化后，各个结点指向有变化，因此原来的遍历方式不能使用，这时需要使用新的方式遍历线索化二叉树，各个节点可以通过线性方式遍历，因此无需使用递归方式，这样也提高了遍历的效率。遍历的次序应当和中序遍历保持一致。

以中序遍历为例，线索化可以让每个具有前驱结点的左节点的 right 指针都能指向其下一个要遍历的节点（后继节点）

我们先找到第一个具有前驱结点的左节点（整棵树最深层的左叶子节点），我们沿着该左叶子节点的后继节点遍历，可以中序遍历的结果

如果遍历到的节点没有后继节点，那么说明该节点 left 和 right 都有节点，直接输出其右节点，并以该右节点根节点，继续执行上一步操作，往最深处寻找第一个具有前驱结点的左节点（当前步骤最深层的左叶子节点），我们继续沿着左叶子节点的后继节点遍历

如此往复，直到最后得到的右节点为 null，上面有讲过，线索二叉树有且只有一个为 null 的 right 指针，该值为 null 时代表整棵树的结束

举例说明：

因为执行的中序遍历：左 --> 中 --> 后，先执行深度搜索，找到第一个有前驱结点的节点，第一次搜索找到节点 8 ，其前驱结点为 null ，从节点 8 的后继节点为节点 3

节点 3 并没有后继节点，只有右节点 10 ，我们拿到节点 10

寻找节点 10 下第一个具有前驱结点的节点，恰好就是它本身，然后寻找其后继节点

以此类推…

大致思路：

寻找最深层的具有前驱结点的左节点
沿着左节点遍历其后继节点
如果没有后继节点，则直接输出其右节点，并以该右节点根节点，继续寻找最深层的具有前驱结点的左节点
如此往复，直到最后得到的右节点值为 null

3.4.2、代码实现

HeroNode 节点的定义与之前一样

//先创建HeroNode 结点
class HeroNode {
  private int no;
  private String name;
  private HeroNode left; // 默认null
  private HeroNode right; // 默认null
  // 说明
  // 1. 如果leftType == 0 表示指向的是左子树, 如果 1 则表示指向前驱结点
  // 2. 如果rightType == 0 表示指向是右子树, 如果 1表示指向后继结点
  private int leftType;
  private int rightType;
  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 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 + "]";
  }
}

在 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);
  }
  // 编写对二叉树进行中序线索化的方法
  // node 就是当前需要线索化的结点
  public void threadedNodes(HeroNode node) {
    // 如果node==null, 不能线索化
    if (node == null) {
      return;
    }
    // (一)先线索化左子树
    threadedNodes(node.getLeft());
    // (二)线索化当前结点[有难度]
    // 处理当前结点的前驱结点
    // 以8结点来理解
    // 8结点的.left = null , 8结点的.leftType = 1
    if (node.getLeft() == null) {
      // 让当前结点的左指针指向前驱结点
      node.setLeft(pre);
      // 修改当前结点的左指针的类型,指向前驱结点
      node.setLeftType(1);
    }
    // 处理后继结点
    if (pre != null && pre.getRight() == null) {
      // 让前驱结点的右指针指向当前结点
      pre.setRight(node);
      // 修改前驱结点的右指针类型
      pre.setRightType(1);
    }
    // !!! 每处理一个结点后，让当前结点是下一个结点的前驱结点
    pre = node;
    // (三)在线索化右子树
    threadedNodes(node.getRight());
  }
  // 遍历线索化二叉树的方法
  public void threadedList() {
    // 定义一个变量，存储当前遍历的结点，从root开始
    HeroNode node = root;
    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();
    }
  }
}

3.4.3、测试代码

代码

public static void main(String[] args) {
    // 测试一把中序线索二叉树的功能
    HeroNode root = new HeroNode(1, "tom");
    HeroNode node2 = new HeroNode(3, "jack");
    HeroNode node3 = new HeroNode(6, "smith");
    HeroNode node4 = new HeroNode(8, "mary");
    HeroNode node5 = new HeroNode(10, "king");
    HeroNode node6 = new HeroNode(14, "dim");
    // 二叉树，后面我们要递归创建, 现在简单处理使用手动创建
    root.setLeft(node2);
    root.setRight(node3);
    node2.setLeft(node4);
    node2.setRight(node5);
    node3.setLeft(node6);
    // 测试中序线索化
    ThreadedBinaryTree threadedBinaryTree = new ThreadedBinaryTree();
    threadedBinaryTree.setRoot(root);
    threadedBinaryTree.threadedNodes();
    // 测试: 以10号节点测试
    HeroNode leftNode = node5.getLeft();
    HeroNode rightNode = node5.getRight();
    System.out.println("10号结点的前驱结点是 =" + leftNode); // 3
    System.out.println("10号结点的后继结点是=" + rightNode); // 1
    // 当线索化二叉树后，不能再使用原来的遍历方法
    System.out.println("使用线索化的方式遍历 线索化二叉树");
    threadedBinaryTree.threadedList(); // 8, 3, 10, 1, 14, 6
}

程序运行结果

使用线索化的方式遍历 线索化二叉树
HeroNode [no=8, name=mary]
HeroNode [no=3, name=jack]
HeroNode [no=10, name=king]
HeroNode [no=1, name=tom]
HeroNode [no=14, name=dim]
HeroNode [no=6, name=smith]

3.4.4、课后作业

这里讲解了中序线索化二叉树，前序线索化二叉树和后序线索化二叉树的分析思路类似，同学们作为课后作业完成

3.5、线索二叉树全部代码

public class ThreadedBinaryTreeDemo {
  public static void main(String[] args) {
    // 测试一把中序线索二叉树的功能
    HeroNode root = new HeroNode(1, "tom");
    HeroNode node2 = new HeroNode(3, "jack");
    HeroNode node3 = new HeroNode(6, "smith");
    HeroNode node4 = new HeroNode(8, "mary");
    HeroNode node5 = new HeroNode(10, "king");
    HeroNode node6 = new HeroNode(14, "dim");
    // 二叉树，后面我们要递归创建, 现在简单处理使用手动创建
    root.setLeft(node2);
    root.setRight(node3);
    node2.setLeft(node4);
    node2.setRight(node5);
    node3.setLeft(node6);
    // 测试中序线索化
    ThreadedBinaryTree threadedBinaryTree = new ThreadedBinaryTree();
    threadedBinaryTree.setRoot(root);
    threadedBinaryTree.threadedNodes();
    // 测试: 以10号节点测试
    HeroNode leftNode = node5.getLeft();
    HeroNode rightNode = node5.getRight();
    System.out.println("10号结点的前驱结点是 =" + leftNode); // 3
    System.out.println("10号结点的后继结点是=" + rightNode); // 1
    // 当线索化二叉树后，不能再使用原来的遍历方法
    System.out.println("使用线索化的方式遍历 线索化二叉树");
    threadedBinaryTree.threadedList(); // 8, 3, 10, 1, 14, 6
  }
}
//定义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);
  }
  // 编写对二叉树进行中序线索化的方法
  // node 就是当前需要线索化的结点
  public void threadedNodes(HeroNode node) {
    // 如果node==null, 不能线索化
    if (node == null) {
      return;
    }
    // (一)先线索化左子树
    threadedNodes(node.getLeft());
    // (二)线索化当前结点[有难度]
    // 处理当前结点的前驱结点
    // 以8结点来理解
    // 8结点的.left = null , 8结点的.leftType = 1
    if (node.getLeft() == null) {
      // 让当前结点的左指针指向前驱结点
      node.setLeft(pre);
      // 修改当前结点的左指针的类型,指向前驱结点
      node.setLeftType(1);
    }
    // 处理后继结点
    if (pre != null && pre.getRight() == null) {
      // 让前驱结点的右指针指向当前结点
      pre.setRight(node);
      // 修改前驱结点的右指针类型
      pre.setRightType(1);
    }
    // !!! 每处理一个结点后，让当前结点是下一个结点的前驱结点
    pre = node;
    // (三)在线索化右子树
    threadedNodes(node.getRight());
  }
  // 遍历线索化二叉树的方法
  public void threadedList() {
    // 定义一个变量，存储当前遍历的结点，从root开始
    HeroNode node = root;
    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();
    }
  }
}
//先创建HeroNode 结点
class HeroNode {
  private int no;
  private String name;
  private HeroNode left; // 默认null
  private HeroNode right; // 默认null
  // 说明
  // 1. 如果leftType == 0 表示指向的是左子树, 如果 1 则表示指向前驱结点
  // 2. 如果rightType == 0 表示指向是右子树, 如果 1表示指向后继结点
  private int leftType;
  private int rightType;
  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 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 + "]";
  }
}

第 10 章树结构的基础部分（二）

2、顺序存储二叉树

2.1、顺序存储二叉树的概念

2.1.1、顺序存储二叉树与数组的转换

2.1.2、顺序存储二叉树的特点

2.2、顺序存储二叉树的遍历

2.2.1、代码思路

2.2.2、前中后序遍历

2.3、顺序存储二叉树应用实例

3、线索化二叉树

3.1、引出问题

3.2、线索二叉树基本介绍

3.3、线索二叉树的生成

3.3.1、代码思路

3.3.2、代码实现

3.3.3、测试代码

3.4、线索二叉树的遍历

3.4.1、代码思路

3.4.2、代码实现

3.4.3、测试代码

3.4.4、课后作业

3.5、线索二叉树全部代码

热门文章

最新文章

相关课程

相关电子书

第 10 章 树结构的基础部分（二）

2、顺序存储二叉树

2.1、顺序存储二叉树的概念

2.1.1、顺序存储二叉树与数组的转换

2.1.2、顺序存储二叉树的特点

2.2、顺序存储二叉树的遍历

2.2.1、代码思路

2.2.2、前 中 后序遍历

2.3、顺序存储二叉树应用实例

3、线索化二叉树

3.1、引出问题

3.2、线索二叉树基本介绍

3.3、线索二叉树的生成

3.3.1、代码思路

3.3.2、代码实现

3.3.3、测试代码

3.4、线索二叉树的遍历

3.4.1、代码思路

3.4.2、代码实现

3.4.3、测试代码

3.4.4、课后作业

3.5、线索二叉树全部代码

热门文章

最新文章

相关课程

相关电子书

第 10 章树结构的基础部分（二）

2.2.2、前中后序遍历