十、顺序存储二叉树、线索化二叉树

1、二叉树顺序存储

1.1 特点

• 顺序二叉树通常只考虑完全二叉树
• 第n个元素的左子节点为2*n+1
• 第n个元素的右子节点为2*n+2
• 第n个元素的父节点为(n-1)/2
  n：表示二叉树中的第几个元素（按0开始编号），也可以理解为n为数组下标。
  

1.2、基本说明

从数据存储来看，数组存储方式和树的存储方式可以相互转换，即数组可以转换成树，树也可以转换成数组。

1.3、案例

上图二叉树的节点，要求以数组的方式来存放arr:[1,2,3,4,5,6,7]，在遍历数组时，以前序、中序、后序遍历的方式完成节点的遍历。

public class ArrBinaryTreeDemo {

	public static void main(String[] args) {
		int[] arr = {1,2,3,4,5,6,7};
		ArrBinaryTree arrBinaryTree = new ArrBinaryTree(arr);
		//arrBinaryTree.preOrder(0);
		//arrBinaryTree.infixOrder(0);
		arrBinaryTree.postOrder(0);
	}

}

class ArrBinaryTree{
	private int[] arr;

	public ArrBinaryTree(int[] arr) {
		this.arr = arr;
	}

	/**
	 * 前序遍历：1 2 4 5 3 6 7
	 * @param index
	 */
	public void preOrder(int index) {
		if (arr == null || arr.length == 0) {
			System.err.println("数组为空，不能进行二叉树遍历");
			return;
		}
		//输出当前元素
		System.out.println(arr[index]);
		//向左递归遍历
		if ((index * 2 + 1) < arr.length) {
			preOrder(index * 2 + 1);
		}
		//向右递归遍历
		if ((index * 2 + 2) < arr.length) {
			preOrder(index * 2 + 2);
		}
	}

	/**
	 * 中序遍历：2 4 5 1 3 6 7 
	 * @param index
	 */
	public void infixOrder(int index) {
		if (arr == null || arr.length == 0) {
			System.err.println("数组为空，不能进行二叉树遍历");
			return;
		}
		//向左递归遍历
		if ((index * 2 + 1) < arr.length) {
			infixOrder(index * 2 + 1);
		}
		//输出当前元素
		System.out.println(arr[index]);
		//向右递归遍历
		if ((index * 2 + 2) < arr.length) {
			infixOrder(index * 2 + 2);
		}
	}

	/**
	 * 后序遍历：2 4 5 3 6 7 1
	 * @param index
	 */
	public void postOrder(int index) {
		if (arr == null || arr.length == 0) {
			System.err.println("数组为空，不能进行二叉树遍历");
			return;
		}
		//向左递归遍历
		if ((index * 2 + 1) < arr.length) {
			postOrder(index * 2 + 1);
		}
		//向右递归遍历
		if ((index * 2 + 2) < arr.length) {
			postOrder(index * 2 + 2);
		}
		//输出当前元素
		System.out.println(arr[index]);
	}
}

2、线索化二叉树

2.1 问题

将数列{1,3,6,8，10,14}构建成一颗二叉树

问题分析：

• 当我们对上面的二叉树进行中序遍历时，数列为{8,3,10,1,14,6}
• 但是6,8,10,14这几个节点的左右指针，并没有完全的利用上
• 如果我们希望充分的利用各个节点的左右指针，让各个节点可以指向自己的前后节点，怎么办？
• 解决方案就是线索化二叉树

2.2 基本介绍

• n个节点的二叉链表中含有n+1个空指针域。利用二叉链表中的空指针域，存放指向该节点在某种遍历次序下的前驱和后继节点的指针（这种附加的指针称为线索）
• 这种加上了线索的二叉链表称为线索链表，相应的二叉树称为线索二叉树（Threaded BinaryTree）。根据线索性质的不同，线索二叉树可分为前序线索二叉树、中序线索二叉树和后序线索二叉树三种。
• 一个节点的前一个节点，称为前驱节点
• 一个节点的后一个节点，称为后继节点

2.3 应用案例

将上图的二叉树进行中序线索二叉树，中序遍历的数列为{8,3,10,1,14,6}

2.4 代码实现

public class ThreadedBinaryTreeDemo {

	public static void main(String[] args) {
		// 测试中序线索二叉树
		HeroNode root = new HeroNode(1, "tom");
		HeroNode node2 = new HeroNode(3, "jack");
		HeroNode node3 = new HeroNode(6, "smith");
		HeroNode node4 = new HeroNode(8, "mary");
		HeroNode node5 = new HeroNode(10, "king");
		HeroNode node6 = new HeroNode(14, "dim");

		// 二叉树
		root.setLeft(node2);
		root.setRight(node3);
		node2.setLeft(node4);
		node2.setRight(node5);
		node3.setLeft(node6);

		ThreadedBinaryTree threadedBinaryTree = new ThreadedBinaryTree();
		threadedBinaryTree.setRoot(root);
		HeroNode leftNode = node5.getLeft();
		HeroNode rightNode = node5.getRight();
		System.out.println("线索化前：10号结点的前驱结点为：" + leftNode);// 3
		System.out.println("线索化前：10号结点的后继结点为：" + rightNode);// 1
		threadedBinaryTree.threadedNodes(root);

		// 测试，以10号结点测试
		leftNode = node5.getLeft();
		rightNode = node5.getRight();
		System.out.println("10号结点的前驱结点为：" + leftNode);// 3
		System.out.println("10号结点的后继结点为：" + rightNode);// 1
	}

}

//定义线索化二叉树
class ThreadedBinaryTree {
	private HeroNode root;
	private HeroNode pre = null;

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

	/**
	 * 编写对二叉树进行中序线索化的方法
	 * 
	 * @param node 当前需要线索化的节点
	 */
	public void threadedNodes(HeroNode 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());

	}
}

class HeroNode {
	private int no;
	private String name;
	private HeroNode left;
	private HeroNode right;

	// 说明
	// 1.如果leftType==0 表示指向的是左子树，为1 表示指向前驱节点
	// 2.如果rightType==0 表示指向的是右子树，为1 表示指向后继节点
	private int leftType;
	private int rightType;

	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 HeroNode(int no, String name) {
		super();
		this.no = no;
		this.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 HeroNode getLeft() {
		return left;
	}

	public void setLeft(HeroNode left) {
		this.left = left;
	}

	public HeroNode getRight() {
		return right;
	}

	public void setRight(HeroNode right) {
		this.right = right;
	}

	@Override
	public String toString() {
		return "HeroNode [no=" + no + ", name=" + name + "]";
	}

}

输出结果：