java前序遍历_Java实现线索化二叉树并遍历（前序，中序，后序）

/**

* 线索化二叉树的节点

*/

public class IndexNode {

public int id;

public String name;

public IndexNode left;

public IndexNode right;

public IndexNode parent = null; // 后序线索化的时候需要使用

public boolean isLeftIndexed; // 0 表示left指针指向左子树， 1 表示left指针指向前驱节点

public boolean isRightIndexed; // 0 表示right指针指向右子树， 1 表示right指针指向后继节点

public IndexNode(int id, String name) {

this.id = id;

this.name = name;

}

@Override

public String toString() {

return "[" + id + "," + name + "]";

}

// 前序遍历

public void preOrder() {

System.out.println(this);

if (left != null) left.preOrder();

if (right != null) right.preOrder();

}

// 中序遍历

public void infixOrder() {

if (left != null) left.infixOrder();

System.out.println(this);

if (right != null) right.infixOrder();

}

// 后序遍历

public void postOrder() {

if (left != null) left.postOrder();

if (right != null) right.postOrder();

System.out.println(this);

}

}

/**

* 实现线索化功能的二叉树

*/

public class IndexBinaryTree {

IndexNode root;

// 为了实现线索化，需要一个pre指针，指向当前节点的前驱

// 进行线索化的时候，pre总是指向前一个节点

IndexNode pre = null;

/** 前序遍历 */

public void preOrder() {

if (root == null) {

System.out.println("空树，无法遍历");

return;

}

root.preOrder();

}

/** 中序遍历 */

public void infixOrder() {

if (root == null) {

System.out.println("空树，无法遍历");

return;

}

root.infixOrder();

}

/** 后序遍历 */

public void postOrder() {

if (root == null) {

System.out.println("空树，无法遍历");

return;

}

root.postOrder();

}

/** 对二叉树进行中序线索化 */

public void infixOrderIndexTree() {

if (root == null) return;

infixOrderIndexTree(root);

}

/** 对二叉树进行前序线索化 */

public void preOrderIndexTree() {

if (root == null) return;

preOrderIndexTree(root);

}

/** 对二叉树进行后序线索化 */

public void postOrderIndexTree() {

if (root == null) return;

postOrderIndexTree(root);

}

/** 遍历经过中序线索化后的二叉树 */

public void showInfixOrderIndexedTree() {

IndexNode cur = root;

while (cur != null) {

// cur一直循环向下找，找到 leftType = 1 的节点

while (!cur.isLeftIndexed) cur = cur.left;

// 打印cur

System.out.println(cur);

// 若cur的右指针指向的是后继节点，就一直更新，然后输出

while (cur.isRightIndexed) {

cur = cur.right;

System.out.println(cur);

}

// 更新cur节点

cur = cur.right;

}

}

/** 遍历经过前序线索化后的二叉树 */

public void showPreOrderIndexedTree() {

IndexNode cur = root;

while (cur != null) {

while (cur.left != null && !cur.isLeftIndexed) {

System.out.println(cur);

cur = cur.left;

}

System.out.println(cur);

if (cur.isLeftIndexed) cur = cur.right;

while (cur != null && cur.isRightIndexed) {

System.out.println(cur);

cur = cur.right;

}

}

}

/** 遍历经过后序线索化后的二叉树 */

public void showPostOrderIndexedTree() {

IndexNode cur = root;

while (cur != null) {

while (!cur.isLeftIndexed) cur = cur.left;

while (cur != null && cur.isRightIndexed) {

System.out.println(cur);

pre = cur;

cur = cur.right;

}

if (cur == root) {

System.out.println(cur);

return;

}

while (cur != null && cur.right == pre) {

System.out.println(cur);

pre = cur;

cur = cur.parent;

}

if (cur != null && !cur.isRightIndexed) {

cur = cur.right;

}

}

}

// 中序线索化的过程，node是当前需要线索化的节点

private void infixOrderIndexTree(IndexNode node) {

// 1.递归向左线索化

if (node.left != null && !node.isLeftIndexed) infixOrderIndexTree(node.left);

// 2.对当前节点进行线索化

indexCurrentNode(node);

// 3.递归向右线索化

if (node.right != null && !node.isRightIndexed) infixOrderIndexTree(node.right);

}

// 前序线索化的过程

private void preOrderIndexTree(IndexNode node) {

// 1.对当前节点进行线索化

indexCurrentNode(node);

// 2.递归向左线索化

if (node.left != null && !node.isLeftIndexed) preOrderIndexTree(node.left);

// 3.递归向右线索化

if (node.right != null && !node.isRightIndexed) preOrderIndexTree(node.right);

}

// 后序线索化的过程

private void postOrderIndexTree(IndexNode node) {

// 1. 递归向左线索化

if (node.left != null && !node.isLeftIndexed) postOrderIndexTree(node.left);

// 2. 递归向右线索化

if (node.right != null && !node.isRightIndexed) postOrderIndexTree(node.right);

// 3. 对当前节点线索化

indexCurrentNode(node);

}

// 对当前节点进行线索化

private void indexCurrentNode(IndexNode current) {

if (current.left == null) {

// 让当前节点的左指针指向前驱(左指针为空，才可以进行，不空则说明已经指向左子树)

current.left = pre;

current.isLeftIndexed = true; // type 置为1,标记为指向的是前驱节点

}

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

// 让前驱的右指针，指向当前节点(前驱的右指针为空，才可进行，不空则说明已经指向右子树)

pre.right = current;

pre.isRightIndexed = true; // type 置为1,标记为指向的是后继节点

}

// 处理完成后，要更新pre 为 当前节点，(让当前节点称为下一个节点的前驱)

pre = current;

}

}

/**

* 测试

* 1. 二叉树的中序遍历，先序遍历，后序遍历

* 2. 二叉树的中序索引化，先序索引化，后序索引化

* 3. 二叉树的中序索引化遍历，先序索引化遍历，后序索引化遍历

*/

public class IndexBinaryTreeDemo {

private static IndexBinaryTree tree;

private static IndexNode node5;

public static void main(String[] args) {

testInfix();

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

testPrefix();

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

testPost();

}

private static void testPost() {

IndexBinaryTreeDemo app = new IndexBinaryTreeDemo();

app.resetTree(); // 重置测试数据

System.out.println("后序遍历结果:");

tree.postOrder(); // 打印先序遍历结果

tree.postOrderIndexTree(); // 对二叉树进行先序索引化

// 测试节点[10, King]的前驱和后继

System.out.println("\n[10,King]的前驱和后继: ");

System.out.println("前驱: " + node5.left); // [8,Mary]

System.out.println("后继: " + node5.right);// [6,Smith]

// 测试经过中序线索华后的遍历结果

System.out.println("\n经过后序线索化后的遍历结果:");

tree.showPostOrderIndexedTree();

}

private static void testPrefix() {

IndexBinaryTreeDemo app = new IndexBinaryTreeDemo();

app.resetTree(); // 重置测试数据

System.out.println("先序遍历结果:");

tree.preOrder(); // 打印先序遍历结果

tree.preOrderIndexTree(); // 对二叉树进行先序索引化

// 测试节点[10, King]的前驱和后继

System.out.println("\n[10,King]的前驱和后继: ");

System.out.println("前驱: " + node5.left); // [8,Mary]

System.out.println("后继: " + node5.right);// [6,Smith]

// 测试经过中序线索华后的遍历结果

System.out.println("\n经过前序线索化后的遍历结果:");

tree.showPreOrderIndexedTree();

}

private static void testInfix() {

IndexBinaryTreeDemo app = new IndexBinaryTreeDemo();

app.resetTree(); //重置测试数据

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

tree.infixOrder(); //打印中序遍历结果

tree.infixOrderIndexTree(); // 对二叉树进行中序遍历索引化

// 测试节点[10, King]的前驱和后继

System.out.println("\n[10,King]的前驱和后继: ");

System.out.println("前驱: " + node5.left); // [3, Jack]

System.out.println("后继: " + node5.right);// [1, Tom]

// 测试经过中序线索化后的遍历结果

System.out.println("\n经过中序线索化后的遍历结果:");

tree.showInfixOrderIndexedTree();

}

private void resetTree() {

IndexNode root = new IndexNode(1, "Tom");

IndexNode node2 = new IndexNode(3, "Jack");

IndexNode node3 = new IndexNode(6, "Smith");

IndexNode node4 = new IndexNode(8, "Mary");

IndexNode node5 = new IndexNode(10, "King");

IndexNode node6 = new IndexNode(14, "Dim");

IndexBinaryTreeDemo.node5 = node5; // 供测试用

// 手动创建二叉树, parent指针用来辅助后序线索化

root.left = node2; node2.parent = root;

root.right = node3; node3.parent = root;

node2.left = node4; node4.parent = node2;

node2.right = node5; node5.parent = node2;

node3.left = node6; node6.parent = node3;

tree = new IndexBinaryTree();

tree.root = root;

}

}