1、中序线索化二叉树

  创建如上的二叉树，线索化二叉树时，根据指定的遍历方式得到的节点的访问顺序，一个节点前面的节点，叫做前驱节点，一个节点后面的节点，叫做后继节点。

  线索化二叉树的规则：

  按照某一遍历规则。记录当前节点(cur)，上次访问的节点(pre)。

   ① 如果当前节点的左孩子为空 (cur.leftNode == null)，就让当前节点的左指针指向它的前驱节点 ，并把当前节点左指针的模式修改为线索类型 (cur.leftNode = pre ，cur.leftType = 1)。

   ② 如果当前节点的前驱节点的右孩子为空 (pre.rightNode == null)，就让当前节点的前驱节点的右指针指向当前节点，并把前驱节点的右指针修改为线索类型 (pre.rightNode = cur ,pre.rightType = 1)。

代码实现：

/**

* 线索二叉树节点

*/

public class ThreadedNode {

//节点的权

int value;

//节点的左右孩子节点

ThreadedNode leftNode;

ThreadedNode rightNode;

//表示指针的类型

int leftType;

int rightType;

//设置节点的权值

public ThreadedNode(int value) {

this.value = value;

}

//设置节点的左右孩子节点

public void setLeftNode(ThreadedNode leftNode) {

this.leftNode = leftNode;

}

public void setRightNode(ThreadedNode rightNode) {

this.rightNode = rightNode;

}

//获取节点的左右孩子节点

public ThreadedNode getLeftNode() {

return this.leftNode;

}

public ThreadedNode getRightNode() {

return this.rightNode;

}

public void midShow() {

//先遍历左子树

if (this.leftNode != null){

leftNode.midShow();

}

//打印当前节点的权值

System.out.println(this.value);

if (this.rightNode != null){

rightNode.midShow();

}

}

}

/**

* 线索二叉树

*/

public class ThreadedBinaryTree {

//树的根节点

ThreadedNode rootNode;

//用于临时存储前驱节点

ThreadedNode pre = null;

//设置二叉树的根节点

public void setRootNode(ThreadedNode rootNode) {

this.rootNode = rootNode;

}

//获取二叉树的根节点

public ThreadedNode getRootNode() {

return this.rootNode;

}

//中序线索化二叉树

public void threadNode() {

threadNodes(rootNode);

}

private void threadNodes(ThreadedNode node) {

//当前节点为空，直接返回

if (node == null) {

return;

}

//处理左子树

threadNodes(node.leftNode);

//处理前驱节点

if (pre != null && node.leftNode == null) {

//当前节点的左指针指向前驱节点

node.leftNode = pre;

//修改节点为线索模式

node.leftType = 1;

}

//处理前驱节点的右指针

if (pre != null && pre.rightNode == null) {

pre.rightNode = node;

pre.rightType = 1;

}

//当前节点就是下一个节点的前驱节点

pre = node;

//处理右子树

threadNodes(node.rightNode);

}

//中序遍历二叉树

public void midShow() {

if (this.rootNode == null) {

return;

} else {

rootNode.midShow();

}

}

}

/**

* 测试类

*/

public class TestThreadedBinaryTree {

public static void main(String[] args) {

//1、创建二叉树

ThreadedBinaryTree binaryTree = new ThreadedBinaryTree();

ThreadedNode rootNode = new ThreadedNode(1);

binaryTree.setRootNode(rootNode);

ThreadedNode leftNode = new ThreadedNode(2);

ThreadedNode rightNode = new ThreadedNode(3);

rootNode.setLeftNode(leftNode);

rootNode.setRightNode(rightNode);

leftNode.setLeftNode(new ThreadedNode(4));

ThreadedNode five = new ThreadedNode(5);

leftNode.setRightNode(five);

rightNode.setLeftNode(new ThreadedNode(6));

rightNode.setRightNode(new ThreadedNode(7));

//2、中序遍历二叉树

System.out.println("中序遍历结果：");

binaryTree.midShow();

System.out.println("------------------------");

binaryTree.threadNode();

ThreadedNode beforeNode = five.leftNode;

System.out.println("节点5的前驱节点："+beforeNode.value);

ThreadedNode afterNode = five.rightNode;

System.out.println("节点5的后继节点："+afterNode.value);

}

}