±---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------@TOC
一、基本概念
1、顺序存储二叉树
从数据存储来看，数组存储方式和树的存储方式可以互相转换，即数组可以转化为树，树也可以转化为数组。
顺序存储二叉树的特点：
- 二叉树顺序存储通常只考虑完全二叉树。
- 第n个元素的左子节点为2*n+1
- 第n个元素的右子节点为2*n+1
- 第n个元素的父节点为（n-1)/2
- n表示二叉树中的第几个元素或数组下标（从0开始编号）
如图所示：
2、线索化二叉树
对于n个结点的二叉树，在二叉链存储结构中有n+1【公式：2n-(n-1)=n+1】个空链域，利用这些空链域存放在某种遍历次序下该结点的前驱结点和后继结点的指针，这些指针称为线索，加上线索的二叉树称为线索二叉树。线索链表解决了无法直接找到该结点在某种遍历序列中的前驱和后继结点的问题，解决了二叉链表找左、右孩子困难的问题。
二、思路分析
1、顺序存储二叉树
对于给定的一个顺序存储的二叉树，实际上就是一个数组，只是对于普通的数组，我们在遍历时通常会按照由低索引向高索引依次遍历，而顺序存储的二叉树由于要考虑到它的原型是一个完全二叉树，所以在遍历时，需要先计算出对应节点左右子节点的索引，再按照树的前中后序遍历方法进行遍历。
2、线索化二叉树
如图所示二叉树进行中序线索化。
该二叉树的中序遍历序列为：[8,3,10,1,14,6]，将其进行线索化为：即叶子节点会生成一个指向中序遍历的前驱节点的索引
当线索化二叉树后，Node节点的属性left和right，会出现如下两种情况：
- left指向的是左子树，也可能指向的是前驱节点。如节点1的left指向的是左子树，而10节点的left指向的则是前驱节点。
- right指向的是右子树，也可能指向的是后继节点。如节点1的right指向的是右子树，而节点10的right则指向的是后继节点。
所以在实现时，我们需要来设置一个标记区分这两种情况。
注意：线索化二叉树的遍历和前面说到的二叉树的遍历有所不同，因为前面的二叉树遍历停止的条件的当左子树或右子树为空，而线索化二叉树多了指向前驱或者后继节点的指针，所以会出现死循环。所以对于线索化二叉树的遍历可以通过线性方式进行遍历，无需再使用递归遍历。
三、代码实现
1、顺序存储二叉树
创建树结构以及相关遍历方法
class ArrBinaryTree {
private int[] arr;
public ArrBinaryTree(int[] arr) {
this.arr = arr;
}
//封装前中后序遍历方法
public void preOrder() {
this.preOrder(0);
}
public void midOrder() {
this.midOrder(0);
}
public void postOrder() {
this.postOrder(0);
}
/**
* 前序遍历
* @param index 根节点索引
*/
private void preOrder(int index) {
if (arr == null || arr.length == 0) {
System.out.println("数组为空");
}
System.out.print(arr[index]);
if ((index * 2 + 1) < arr.length) {
preOrder(2 * index + 1);
}
if ((index * 2 + 2) < arr.length) {
preOrder(2 * index + 2);
}
}
/**
* 中序遍历
* @param index 根节点索引
*/
private void midOrder(int index) {
if (arr == null || arr.length == 0) {
System.out.println("数组为空");
}
if ((index * 2 + 1) < arr.length) {
midOrder(2 * index + 1);
}
System.out.print(arr[index]);
if ((index * 2 + 2) < arr.length) {
midOrder(2 * index + 2);
}
}
/**
* 后序遍历
* @param index 根节点索引
*/
private void postOrder(int index) {
if (arr == null || arr.length == 0) {
System.out.println("数组为空");
}
if ((index * 2 + 1) < arr.length) {
postOrder(index * 2 + 1);
}
if ((index * 2 + 2) < arr.length) {
postOrder(index * 2 + 2);
}
System.out.print(arr[index]);
}
}
写一个demo来进行测试
public class ArrBinaryTreeDemo {
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5, 6};
ArrBinaryTree tree = new ArrBinaryTree(arr);
System.out.println("前序遍历:");
tree.preOrder();
System.out.println("\n中序遍历:");
tree.midOrder();
System.out.println("\n后序遍历:");
tree.postOrder();
}
}
测试结果：
2、线索化二叉树
首先节点类
class Node {
private int no;
private String name;
private Node left;
private Node right;
private int leftType;//leftType==0,表示指向左子树，leftType==1表示指向前驱节点
private int rightType;//leftType==0,表示指向右子树，leftType==1表示指向后继节点
public Node(int no, String name) {
this.no = no;
this.name = name;
}
@Override
public String toString() {
return "Node{" +
"no=" + no +
", 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 Node getLeft() {
return left;
}
public void setLeft(Node left) {
this.left = left;
}
public Node getRight() {
return right;
}
public void setRight(Node 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;
}
}
然后创建一个线索化二叉树以及相关方法
class ThreadedBinaryTree {
private Node root;
//指向当前节点的前驱节点的指针
//在递归进行线索化时，pre总是保留前一个节点
private Node pre = null;
public void setRoot(Node root) {
this.root = root;
}
//编写线索化方法
public void threadedNodes() {
this.threadedNodes(root);
}
/**
*
* @param node 当前需要线索化的节点
*/
public void threadedNodes(Node node) {
//如果节点为空，则不能进行线索化
if (node == null) {
return;
}
//线索化左子树
threadedNodes(node.getLeft());
//线索化当前节点
//处理当前节点的前驱节点
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 midOrder() {
//定义一个遍历存储当前节点
Node node = root;
while (node != null) {
//循环找到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();
}
}
}
最后写一个demo来测试进行测试
public class ThreadedBinaryTreeDemo {
public static void main(String[] args) {
Node root = new Node(1, "Tom");
Node node2 = new Node(3, "Jack");
Node node3 = new Node(6, "smith");
Node node4 = new Node(8, "mary");
Node node5 = new Node(10, "king");
Node node6 = new Node(14, "dim");
root.setLeft(node2);
root.setRight(node3);
node2.setLeft(node4);
node2.setRight(node5);
node3.setLeft(node6);
ThreadedBinaryTree tree = new ThreadedBinaryTree();
tree.setRoot(root);
tree.threadedNodes();
//以节点10测试
Node leftNode = node5.getLeft();
Node rightNode = node5.getRight();
System.out.println("10号节点的前驱节点是：" + leftNode);
System.out.println("10号节点的后继节点是：" + rightNode);
System.out.println("中序遍历线索化二叉树：");
tree.midOrder();
}
}
测试结果
149
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
