Java数据结构_11.线索二叉树

中序线索化二叉树

线索化二叉树时，一个节点的前一个节点，叫前驱节点
线索化二叉树时，一个节点的后一个节点，叫后继节点

package com.demo3;

public class ThreadedBinaryTree {
	ThreadedTreeNode root;// 根节点
	// 用于临时存储前驱节点
	ThreadedTreeNode pre = null;

	// 遍历线索二叉树
	public void threadIterate() {
		// 用于临时存储当前遍历节点
		ThreadedTreeNode node = root;
		while (node != null) {
			// 循环找到最开始的节点
			while (node.leftType == 0) {
				node = node.leftNode;
			}
			System.out.print(node.value + " ");
			// 如果当前节点的右指针指向的是后继节点，有可能后继节点还有后继节点
			while (node.rightType == 1) {
				node = node.rightNode;
				System.out.print(node.value + " ");
			}
			node = node.rightNode;
		}
	}

	public void setRoot(ThreadedTreeNode root) {
		this.root = root;
	}

	// 中序线索化二叉树
	public void threadedNodes() {
		threadedNodes(root);
	}

	public void threadedNodes(ThreadedTreeNode node) {
		// 当前节点如果为null，直接返回
		if (node == null) {
			return;
		}
		// 处理左子树
		threadedNodes(node.leftNode);
		// 处理前驱节点
		if (node.leftNode == null) {
			// 当前节点左指针指向前驱节点
			node.leftNode = null;
			// 改变当前节点左指针类型
			node.leftType = 1;
		}
		// 处理前驱节点的右指针，如果前驱节点的右指针是null(没有指向右子树)，让前驱节点的右指针指向当前节点
		if (pre != null && pre.rightNode == null) {
			pre.rightNode = node;
			// 改变前驱节点的右指针类型
			pre.rightType = 1;
		}
		// 每处理一个当前节点，当前节点是下一节点的前驱节点
		pre = node;
		// 处理右子树
		threadedNodes(node.rightNode);
	}

	public ThreadedTreeNode getRoot() {
		return root;
	}

	public void frontShow() {
		if (root != null) {
			root.frontShow();
		}
	}

	public void midShow() {
		if (root != null) {
			root.midShow();
		}

	}

	public void afterShow() {
		if (root != null) {
			root.afterShow();
		}

	}

	public ThreadedTreeNode frontSearch(int i) {
		return root.frontSearch(i);
	}

	public void delete(int i) {
		if (root.value == i) {
			root = null;
		} else {
			root.delete(i);
		}
	}
}

package com.demo3;

public class ThreadedTreeNode {
	// 节点的权
	int value;
	// 左节点
	ThreadedTreeNode leftNode;
	// 右节点
	ThreadedTreeNode rightNode;
	// 标识左指针类型
	int leftType;
	// 标识左指针类型
	int rightType;

	public ThreadedTreeNode(int value) {
		this.value = value;
	}

	public void setLeftNode(ThreadedTreeNode lNode) {
		this.leftNode = lNode;
	}

	public void setRightNode(ThreadedTreeNode rNode) {
		this.rightNode = rNode;
	}

	// 前序遍历
	public void frontShow() {
		// 遍历当前节点
		System.out.print(value + " ");
		// 左节点
		if (leftNode != null) {
			leftNode.frontShow();
		}
		// 右节点
		if (rightNode != null) {
			rightNode.frontShow();
		}
	}

	// 中序遍历
	public void midShow() {
		// 左子节点
		if (leftNode != null) {
			leftNode.midShow();
		}
		// 当前节点
		System.out.print(value + " ");
		// 右子节点
		if (rightNode != null) {
			rightNode.midShow();
		}
	}

	public void afterShow() {
		// 左子节点
		if (leftNode != null) {
			leftNode.afterShow();
		}
		// 右子节点
		if (rightNode != null) {
			rightNode.afterShow();
		}
		// 当前节点
		System.out.print(value + " ");

	}

	// 前序查找
	public ThreadedTreeNode frontSearch(int i) {
		ThreadedTreeNode target = null;
		if (this.value == i) {
			return this;
		} else {
			if (leftNode != null) {
				target = leftNode.frontSearch(i);
			}
			if (target != null) {
				return target;
			}
			if (rightNode != null) {
				target = rightNode.frontSearch(i);
			}
		}
		return target;
	}

	// 删除子树
	public void delete(int i) {
		ThreadedTreeNode parent = this;
		if (parent.leftNode != null && parent.leftNode.value == i) {
			parent.leftNode = null;
			return;
		}
		if (parent.rightNode != null && parent.rightNode.value == i) {
			parent.rightNode = null;
			return;
		}
		parent = leftNode;
		if (parent != null) {
			parent.delete(i);
		}
		parent = rightNode;
		if (parent != null) {
			parent.delete(i);
		}
	}

}

package com.demo3;

public class TestThreadedBinaryTree {

	public static void main(String[] args) {
		// 创建一棵树
		ThreadedBinaryTree binTree = new ThreadedBinaryTree();
		// 创建一个根节点
		ThreadedTreeNode root = new ThreadedTreeNode(1);
		// 把根节点赋给树
		binTree.setRoot(root);
		// 创建左节点
		ThreadedTreeNode rootL1 = new ThreadedTreeNode(2);
		// 把新创建的节点设置为根节点的子节点
		root.setLeftNode(rootL1);
		// 创建右节点
		ThreadedTreeNode rootR1 = new ThreadedTreeNode(3);
		// 把新创建的节点设置为根节点的子节点
		root.setRightNode(rootR1);
		// 为第二层的左节点创建子节点
		rootL1.setLeftNode(new ThreadedTreeNode(4));
		ThreadedTreeNode fiveNode = new ThreadedTreeNode(5);
		rootL1.setRightNode(fiveNode);
		// 为第二层的右节点创建子节点
		rootR1.setLeftNode(new ThreadedTreeNode(6));
		rootR1.setRightNode(new ThreadedTreeNode(7));

		// 中序遍历
		binTree.midShow();// 4 2 5 1 6 3 7
		System.out.println();

		// 中序线索化二叉树
		binTree.threadedNodes();
		// 查找5节点
		// 获取5节点 的后继节点
		ThreadedTreeNode afterFive = fiveNode.rightNode;
		System.out.println(afterFive.value);
		// 中序线索化遍历
		binTree.threadIterate();
	}

}