线索二叉树模型的建立与遍历

线索二叉树是在普通二叉树模型上建立线索后的树模型，再建立了线索后我们可以在O(n)的时间内遍历该树，并且很方便的找出某个节点的前驱节点和后继节点，我们的代码首先建立一棵普通的二叉树，然后利用递归的方式建立线索，并且提供一个遍历算法，其中有一些细节是需要我们多加注意的。不多说了，上代码

/**
 * @author pc
 * 线索二叉树模型
 */
public class ThreadTree {
	
	private Node root;
	private Node pre;
	
	 private class Node{  
	        private Node left;  
	        private Node right;  
	        private int  data;
	        private int  ltag;   //ltag=0表示指向左孩子节点，ltag=1表示指向线索即前驱节点
	        private int  rtag;   //rtag=0表示指向右孩子节点，rtag=1表示指向线索即后继节点
	        public Node(int data){  
	            this.left = null;  
	            this.right = null;  
	            this.data = data;
	            this.ltag =0;        
	            this.rtag =0;
	        }
			public Node getLeft() {
				return left;
			}
			public void setLeft(Node left) {
				this.left = left;
			}
			public Node getRight() {
				return right;
			}
			public void setRight(Node right) {
				this.right = right;
			}
			public int getData() {
				return data;
			}
			public void setData(int data) {
				this.data = data;
			}
			public int getLtag() {
				return ltag;
			}
			public void setLtag(int ltag) {
				this.ltag = ltag;
			}
			public int getRtag() {
				return rtag;
			}
			public void setRtag(int rtag) {
				this.rtag = rtag;
			} 
	    }
	 
	 public ThreadTree(){
		 root=null;
		 pre=null;
	 }
	 
	/**
	 * 首先根据一个数组来创建普通二叉树
	 * 
	 * @param a
	 * n+1个数据组成的数组，其中a[0]=-1不参与树的创建，a[1]~a[n]代表数的节点，a[2*i]是a[i]的左子结点，
	 * a[2*i+1]是右子节点
	 */
	private Node buildTreeByArray(int[] a, int n) {
		Node[] p = new Node[n + 1];
		p[0] = null;
		for (int i = 1; i <= n; i++) {
			if (a[i] == -1) {
				p[i] = null;
			} else {
				p[i] = new Node(a[i]);
			}
		}
		for (int i = 1; i <= n / 2; i++) {
			if (a[i] != -1) {
				if ((2 * i <= n) && a[2 * i] != -1) {
					p[i].setLeft(p[2 * i]);
				}
				if ((2 * i + 1 <= n) && (a[2 * i + 1] != -1)) {
					p[i].setRight(p[2 * i + 1]);
				}
			}
		}
		return p[1];
	}
	
	/**
	 * 递归的线索化过程
	 * pre指向前驱节点，p指向当前节点
	 */
	private void Thread(Node p){
		if(p!=null){
			Thread(p.left);
			if(p.left==null){
				p.ltag=1;
				p.left=pre;
			}
			else{
				p.ltag=0;
			}
			if(pre.right==null){
				pre.rtag=1;
				pre.right=p;
			}
			else{
				pre.rtag=0;
			}
			pre=p;
			Thread(p.right);
		}
	}
	
	/**
	 * 真正建立二叉线索树的函数
	 * 其中首先建立一棵普通二叉树，然后再对其进行线索化
	 * 最后返回一个root节点，left指向二叉树的根节点，right指向遍历时的最后一个节点
	 * @param a
	 * @param n
	 */
	public Node createThreadTree(int[] a, int n){
		Node bt=buildTreeByArray(a, n);
		root=new Node(0);
		root.ltag=0;
		root.rtag=1;
		root.right=bt;       //这一步不能少，否则线索化时会把root节点的右指针指向遍历时的第一个节点
		if(bt==null){
			root.left=root;
		}
		else{
			root.left=bt;
			pre=root;
			Thread(bt);
			pre.right=root;
			pre.rtag=1;
			root.right=pre;
		}
		return root;
	}
	
	/**
	 * 对中序线索二叉树进行遍历
	 * @param root
	 */
	public void ThInOrder(Node root){
		Node p=root.left;
		while(p!=root){             //注意现在空树的条件是p==root即root.left=root
			while(p.ltag==0)        //找出最左下方节点
				p=p.left;
			System.out.print(p.data+" ");
			while(p.rtag==1&&p.right!=root){   //当访问完最左下节点后顺着右线索访问即可
				p=p.right;
				System.out.print(p.data+" ");
			}
			p=p.right;
		}
	}
	
	public static void main(String args[]){
		 int[] a={-1,2,4,6,7,8,9,-1,12,13};
		 ThreadTree thread=new ThreadTree();
		 Node node=thread.createThreadTree(a, 9);
		 thread.ThInOrder(node);
	}

}