二叉树的线索化与线索二叉树的遍历（Java实现）
这里是我对线索二叉树的个人总结，第一次写博客，如果在一些定义方面有表达不清的地方，大家可以结合着专业书籍来看，这样更容易理解。
线索二叉树定义：
在二叉树的结点上加上线索的二叉树称为线索二叉树，对二叉树以某种遍历方式（如先序、中序、后序等）进行遍历，使其变为线索二叉树的过程称为对二叉树进行线索化。
这里的二叉树使用链表形式创建，每一个节点除了自己的权之外还存储着左右两个子节点的引用，后面会简称为左指针与右指针。
以此二叉树为例：
这里先介绍几个概念：
**1.二叉树的中序遍历：**先遍历左子节点（左子树），再遍历自己，再遍历右子节点（右子树）。称为中序遍历。上方二叉树中序遍历后的结果：8，7，3，9，10，1，14，6。
**2.二叉树的先序（前序）遍历：**先遍历自己，再遍历左子节点（左子树），再遍历右子节点（右子树）。上方二叉树前序遍历结果为：1，3，8，7，10，9，6，14。
**3.二叉树的后序遍历：**先遍历左子节点（左子树），再遍历右子节点（右子树），最后遍历自己。上方二叉树的后序遍历结果为：7，8，9，10，3，14，6，1。
**总结：**实际上三种遍历方式的名字都是以“当前节点”为基准来起名的，中序就是当前节点在遍历顺序的中间（左-自己-右），前序就是在遍历顺序的开头（自己-左-由），后序就是在遍历顺序的结尾（左-右-自己）。
还需要了解的概念：
**前驱节点：**在三种遍历方式中，按照遍历的顺序，在一个节点之前被遍历的节点成为前驱节点。
**后继节点：**在三种遍历方式中，按照遍历的顺序，在一个节点之后被遍历的节点成为后继节点。
**前序线索化二叉树：**以前序遍历的顺序来线索化二叉树。
**中序线索化二叉树：**以中序遍历的顺序来线索化二叉树。
**后序线索化二叉树：**以后序遍历的顺序来线索化二叉树。
二叉树线索化的核心思想：
如果一个节点的左指针为空，那么就把其前驱节点的引用赋值到这个节点的左指针中。同理，如果一个节点的右指针为空，那么就把其后继节点的引用赋值到这个节点的右指针中。
这样操作之后，每个节点的左指针与右指针就都存储了引用。但这样也带来了一些问题：我们如何区分左指针和右指针指向的到底是左节点和右节点，还是前驱节点与后继节点？
所以，我们需要定义一个int类型的标记，如果存储的是子节点，我们就用标记的默认值0，如果存储的是前驱、后继节点，我们就更改标记值为1。这样就可以区分指针的具体类型了。
Java实现的基本流程：
**1.定义一个节点类：**ThreadNode，其中包括节点对应的属性和方法。
**2.定义一个二叉树类：**ThreadBinaryTree，其中包括树对应的属性和方法。
**3.定义一个测试类：**Test，用于最终结果的测试。
对应的方法名称（忽略我的chinglish起名方式）：
front(); //二叉树的前序遍历
mid(); //二叉树的中序遍历
after(); //二叉树的后序遍历
frontThread(); //前序线索化二叉树
midThread(); //中序线索化二叉树
afterThread(); //后序线索化二叉树
frontIterate(); //遍历前序线索化二叉树
midIterate(); //遍历中序线索化二叉树
afterIterate(); //遍历后序线索化二叉树
在进入代码阶段之前，我们还要思考两个问题。
**1.**二叉树的子节点是不能直接找到父节点的，因为在各个节点中只存储了子节点的引用，并没有存储父节点的引用。但是在后序遍历线索化二叉树的方法中，我们需要获取父节点，所以在节点类中还定义了存储父节点的属性。在创建节点时我们需要手动给这个属性赋值。
**2.**在线索化二叉树的方法中，我们还需要存储当前节点的前驱节点，所以在节点类中，我们还需要一个存储前驱节点的静态属性，这个属性也会在后序遍历线索二叉树中使用到。之所以是静态的属性，是因为在每次递归时都要更改这个值，静态属性从属于类，这样更改后的值就可以被存储下来，以供下次使用。
这两点问题现在看可能有些不知所云，但是建议先了解一下，在看了接下来的代码之后反过来再看，就会有更深的理解。
废话了这么多，我们开始正式进入代码阶段。
**
首先是ThreadBinaryTree类：
**
import static com.ssh.test.ThreadNode.pre;
public class ThreadBinaryTree {
//树的根节点
private ThreadNode root;
public ThreadNode getRoot() {
return root;
}
public void setRoot(ThreadNode root) {
this.root = root;
}
//中序线索化方法的重载
public void midThread(){
root.midThread();
}
//前序线索化方法的重载
public void frontThread(){
root.frontThread();
}
//后序线索化方法的重载
public void afterThread(){
root.afterThread();
}
//中序线索遍历
public void midIterate(){
//定义一个变量，用于储存当前节点
ThreadNode node = root;
while(node!=null){
//循环找到左节点类型为0的节点
while(node.getLeftNode()!=null&&node.getLeftType()==0){
node = node.getLeftNode();
}
//打印当前节点
System.out.println(node.getValue());
//判断，如果右节点类型为1，说明右节点为后继节点，替换并直接打印
while(node.getRightNode()!=null&&node.getRightType()==1){
node = node.getRightNode();
System.out.println(node.getValue());
}
//如果右节点类型为0，说明右节点为子节点，直接替换node为右节点，进行下一次的循环判断
node = node.getRightNode();
}
}
//前序线索遍历
public void frontIterate(){
//定义一个变量，用于存储当前节点
ThreadNode node = root;
while(node!=null){
//当前节点的左子节点类型为0时，循环打印当前节点信息，并替换node为当前节点的下一个节点
while(node!=null){
System.out.println(node.getValue());
if(node.getLeftType()==0){
node = node.getLeftNode();
}else { //如果当前节点的左指针类型不为0，则跳出循环
break;
}
}
//找到并打印完最左边的节点以后，开始处理右节点
node = node.getRightNode();
}
}
//前序线索化遍历的优化方法
public void test(){
//定义一个变量，存储当前遍历的节点，从root开始
ThreadNode node = root;
while ( node != null ) {
while ( node.getLeftType() == 0 ) {
//如果是叶子节点，非前驱节点，打印当前这个结点
System.out.print(node + ",");
node = node.getLeftNode();
}
System.out.print(node + ",");
//找到并打印完最左边的节点以后，开始处理右节点
node = node.getRightNode();
}
}
//后序线索化遍历
public void afterIterate(){
//先把ThreadNode中的静态变量pre赋值为空
ThreadNode.pre = null;
//定义一个变量，存储当前遍历的节点，从root开始
ThreadNode node = root;
//找到最左边的点
while(node!=null&&node.getLeftType()==0){
node = node.getLeftNode();
}
while(node!=null){
//如果右节点类型为1
if(node.getRightType()==1){
System.out.println(node.getValue());
pre = node;
node = node.getRightNode();
}else{
//如果上一个打印的节点是当前节点的右节点
if(pre == node.getRightNode()){
System.out.println(node.getValue());
pre = node;
node = node.getParent();
}else{
//如果从左节点进入或者一开始就是右节点，找到最左边的节点
node = node.getRightNode();
while(node!=null&&node.getLeftType()==0&&node.getLeftNode()!=null){
node = node.getLeftNode();
}
}
}
}
}
//中序遍历的重载方法
public void mid(){
root.mid();
}
//前序遍历的重载方法
public void front(){
root.front();
}
//后序遍历的重载方法
public void after(){
root.after();
}
}
其次是ThreadNode类：
public class ThreadNode {
private int value;//节点的权
private ThreadNode leftNode;//左节点
private ThreadNode rightNode;//右节点
private int leftType;//左指针（节点）类型
private int rightType;//右指针（节点）类型
public static ThreadNode pre;//节点的前驱节点
private ThreadNode parent;//节点的父节点
public ThreadNode getParent() {
return parent;
}
public void setParent(ThreadNode parent) {
this.parent = parent;
}
@Override
public String toString() {
return "ThreadNode{" +
"value=" + value +
'}';
}
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 ThreadNode(int value){
this.value = value;
}
public int getValue() {
return value;
}
public void setValue(int value) {
this.value = value;
}
public ThreadNode getLeftNode() {
return leftNode;
}
public void setLeftNode(ThreadNode leftNode) {
this.leftNode = leftNode;
}
public ThreadNode getRightNode() {
return rightNode;
}
public void setRightNode(ThreadNode rightNode) {
this.rightNode = rightNode;
}
//中序线索化二叉树
public void midThread() {
//处理左子树
if(leftNode!=null){
leftNode.midThread();
}
if(pre!=null)
//System.out.println(pre.value+"kkk");
//处理前驱节点
if(pre!=null&&pre.rightNode==null){
pre.rightNode = this;
pre.rightType = 1;
}
//处理自己
if(pre!=null&&this.leftNode==null){
this.leftNode = pre;
this.leftType = 1;
}
pre = this;
//System.out.println(pre.value);
//处理右子树
if(rightNode!=null){
rightNode.midThread();
}
}
//前序线索化二叉树
public void frontThread() {
//处理自己
if(pre!=null&&this.leftNode==null){
this.leftNode = pre;
this.leftType = 1;
}
if(pre!=null&&pre.rightNode == null){
pre.rightNode = this;
pre.rightType = 1;
}
pre = this;
//处理左节点
if(this.leftNode!=null&&leftType==0){
leftNode.frontThread();
}
//处理右节点
if(this.rightNode!=null&&rightType==0){
rightNode.frontThread();
}
}
//后序线索化二叉树
public void afterThread() {
//处理左子树
if(this.leftNode!=null){
leftNode.afterThread();
}
//处理右子树
if(this.rightNode!=null){
rightNode.afterThread();
}
//处理自己
if(pre!=null&&this.leftNode == null){
this.leftNode = pre;
this.leftType = 1;
}
if(pre!=null&&pre.rightNode==null){
pre.rightNode = this;
pre.rightType = 1;
}
pre = this;
}
//中序遍历二叉树
public void mid() {
//先处理左边
if(this.leftNode!=null){
leftNode.mid();
}
//再处理中间
System.out.println(this.getValue());
//再处理右边
if(this.rightNode!=null){
rightNode.mid();
}
}
//前序遍历二叉树
public void front() {
//先处理自己
System.out.println(this.getValue());
//处理左边
if(this.leftNode!=null){
leftNode.front();
}
//处理右边
if(this.rightNode!=null){
rightNode.front();
}
}
//后序遍历二叉树
public void after() {
//处理左边
if(this.getLeftNode()!=null){
leftNode.after();
}
//处理右边
if(this.getRightNode()!=null){
rightNode.after();
}
//处理自己
System.out.println(this.getValue());
}
}
最后是Test类以及运行的结果：
public class Test {
public static void main(String[] args) {
ThreadBinaryTree tree = new ThreadBinaryTree();
//创建根节点
ThreadNode root = new ThreadNode(1);
tree.setRoot(root);
//创建一些子节点，这里节点起名的方式为：n+节点的权
ThreadNode n3 = new ThreadNode(3);
ThreadNode n6 = new ThreadNode(6);
ThreadNode n8 = new ThreadNode(8);
ThreadNode n10 = new ThreadNode(10);
ThreadNode n14 = new ThreadNode(14);
ThreadNode n7 = new ThreadNode(7);
ThreadNode n9 = new ThreadNode(9);
//追加子节点
root.setLeftNode(n3);
root.setRightNode(n6);
n3.setLeftNode(n8);
n3.setRightNode(n10);
n8.setRightNode(n7);
n10.setLeftNode(n9);
n6.setLeftNode(n14);
//给节点追加父节点
n3.setParent(root);
n6.setParent(root);
n8.setParent(n3);
n10.setParent(n3);
n7.setParent(n8);
n9.setParent(n10);
n14.setParent(n6);
//测试中序线索化
tree.mid(); //8，7，3，9，10，1，14，6。
tree.midThread();
tree.midIterate();//8，7，3，9，10，1，14，6。
//测试前序线索化
tree.front();//1，3，8，7，10，9，6，14。
tree.frontThread();
tree.frontIterate();//1，3，8，7，10，9，6，14。
tree.test();//1，3，8，7，10，9，6，14。
//测试后序线索化
tree.after();//7，8，9，10，3，14，6，1。
tree.afterThread();
tree.afterIterate();//7，8，9，10，3，14，6，1。
}
}
二叉树的前、中、后序遍历没有什么好说的。但是在二叉树的线索化中，由于用到了递归，所以要注意递归的结束条件，还有在线索化二叉树时，每一次要处理当前节点的左节点与上一个节点的右节点，这点并不容易理解，需要细心的留意，可以用debug一步一步的观察。
在遍历线索化二叉树时，前序、中序遍历相对好理解，但是在后序遍历时，之所以同时用到了存储前驱节点的属性pre以及存储父节点的属性parent，是因为后序遍历的特殊性，在遍历右节点（右子树）时需要分成两种情况：第一种是当前节点的前驱节点刚好是右节点；一种是从左子树来到了当前节点，再遍历右节点。
这就是个人在学习线索二叉树之后的总结，如果有不对的或者有争议的地方，还请大家指出，我们共同进步！