线索二叉树：

    把结点中指向前驱结点和后继结点的指针称为线索。在二叉树的结点上加上线索的二叉树称作线索二叉树。对二叉树以某种方法（如前序、中序或后序方法）遍历使其变为线索二叉树的过程称作按该方法对二叉树进行的线索化。 

在节点类上加了一个flag标识，表示这侧是根节点还是线索节点。

线索二叉树结点类

//线索二叉树的结点类
public class MyBiTreeNode {

	private MyBiTreeNode leftNode;//左孩子结点
	private MyBiTreeNode rightNode;//右孩子结点
	private boolean leftFlag; //是否是左线索
	private boolean rightFlag;//是否是右线索
	private Object data;
	
	public MyBiTreeNode()
	{
		this.leftNode = null;
		this.rightNode = null;
		this.leftFlag = false;
		this.rightFlag = false;
	}
	
	public MyBiTreeNode(Object data)
	{
		this();
		this.data = data;
	}

	public MyBiTreeNode getLeftNode() {
		return leftNode;
	}

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

	public MyBiTreeNode getRightNode() {
		return rightNode;
	}

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

	public boolean getLeftFlag() {
		return leftFlag;
	}

	public void setLeftFlag(boolean leftFlag) {
		this.leftFlag = leftFlag;
	}

	public boolean getRightFlag() {
		return rightFlag;
	}

	public void setRightFlag(boolean rightFlag) {
		this.rightFlag = rightFlag;
	}

	public Object getData() {
		return data;
	}

	public void setData(Object data) {
		this.data = data;
	}
}

中序线索二叉树类

//中序线索二叉树类
public class MyInThreadBiTree extends MyThreadBiTree {
  
	public MyInThreadBiTree()
	{
		super();
	}

	@Override
	public void initMyBiTree() {
		// TODO Auto-generated method stub
		super.initMyBiTree();
	}
    
	@Override
	public void createMyThreadBiTree() {
		
	    create(head,null);	
	}
	
	//中序线索化二叉树
	//该方法返回的是该子串的最右侧的子节点
	private MyBiTreeNode create(MyBiTreeNode curNode,MyBiTreeNode preNode)
	{
		if (curNode != null) 
		{
			MyBiTreeNode tempNode = create(curNode.getLeftNode(), preNode);

			//如当前节点的左节点为空，则记录prenode
			if ((!curNode.getLeftFlag()) && (curNode.getLeftNode() == null)) 
			{
				curNode.setLeftFlag(true);
				curNode.setLeftNode(preNode);
			} // end of if

		      //当下一层左节点不为空时，这里得到的是下一层左节点分支的最右侧节点
			preNode = tempNode;

			//这里是把下一大层的左节点的最右子节点赋值为当前节点
			if ((preNode != null) && (preNode.getRightNode() == null)) 
			{
				preNode.setRightFlag(true);
				preNode.setRightNode(curNode);
			} // end of if

			//这里是找右侧节点情况
			preNode = curNode;
			preNode = create(curNode.getRightNode(), preNode);
			//返回的是右侧节点的最右侧节点
			return preNode;
		} // end of if

		return preNode;
	}
	
	//中序线索遍历算法
	//找到最左侧的，从最左侧开始即可，因为每个点会记录下个点的位置，如果右侧有节点，则遍历这个点，找其左侧点，再反复即可。
	@Override
	public void traversal() {
		MyBiTreeNode walker = this.head;

		if (this.head != null) {
		        //1为索引，0为有节点
			while (!walker.getLeftFlag())
				walker = walker.getLeftNode();

			System.out.print(walker.getData() + " ");

			//这里如果右侧不为空
			while (walker.getRightNode() != null) {
			        //如果是索引，则继续
				if (walker.getRightFlag())
					walker = walker.getRightNode();
				else {
				//如果不是索引，则遍历该子树。
					walker = walker.getRightNode();
					while ((walker.getLeftNode() != null)
							&& (!walker.getLeftFlag()))
						walker = walker.getLeftNode();
				} // end of else

				System.out.print(walker.getData() + " ");
			} // end of while
		} // end of if
	}
	
	
}

线索二叉树

//线索二叉树类
public class MyThreadBiTree {
   
	protected MyBiTreeNode head;
	protected final static String ENDFLAG = "null"; 
	
	public MyThreadBiTree()
	{
		this.head = null;
	}
	
	//初始化二叉树的根节点
	public void initMyBiTree()
	{
		String item;
		Scanner in = new Scanner(System.in);
		System.out.println("请输入二叉树的树根结点（输入null表示该结点为空）：");
	    item = in.next();
	    if(!item.equalsIgnoreCase(ENDFLAG))
	    {
	      head = new MyBiTreeNode(item);
	      init(head);
	    }
	}
	
	//初始化二叉树
	private void init(MyBiTreeNode head)
	{
	   String item;
	   Scanner in = new Scanner(System.in);
	   System.out.println("请输入"+head.getData()+"结点的左孩子结点：");
	   item = in.next();
	   if(!item.equalsIgnoreCase(ENDFLAG))
	   {
		  head.setLeftNode(new MyBiTreeNode(item));
		  init(head.getLeftNode()); //递归
	   }
	   System.out.println("请输入"+head.getData()+"结点的右孩子结点：");
	   item = in.next();
	   if(!item.equalsIgnoreCase(ENDFLAG))
	   {
		  head.setRightNode(new MyBiTreeNode(item));
		  init(head.getRightNode()); //递归
	   }
	}
	
	//创建线索二叉树
	public void createMyThreadBiTree()
	{
		
	}
	
	//线索遍历算法
	public void traversal()
	{
		
	}
	
    	
}

测试类：

public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
        
		MyThreadBiTree tree = new MyInThreadBiTree();
		tree.initMyBiTree();
		tree.createMyThreadBiTree();
		System.out.println("中序遍历序列是：");
		tree.traversal();
	
	}

}


翻转二叉树：

    翻转二叉树,就是把二叉树所有非叶节点的左右子树位置交换.用递归很容易就可以实现,非递归时,只要利用栈,也不难实现。

递归方法实现：

//翻转二叉树的算法
	public static void reverse(BiTreeNode root)
	{
		BiTreeNode tempNode;
		tempNode = root.getLeftChild();
		root.setLeftChild(root.getRightChild());
		root.setRightChild(tempNode);
		
		if(root.getLeftChild()!=null)
		{
			reverse(root.getLeftChild());
		}
		
		if(root.getRightChild()!=null)
		{
			reverse(root.getRightChild());
		}
	}