二元查找树转双向链表

public class A01 {
	/**
	 * 输入一棵二元查找树，将该二元查找树转换成一个排序的双向链表。要求不能创建任何新的结点，只调整指针的指向。
	 * */
 
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Tree tree = new Tree();
		Node node = Tree2List(tree.getRootNode(),true);
		System.out.println();
	}
	
	/**
	 * 将该二元查找树转换成一个排序的双向链表
	 * 算法说明：采用递归的调用的方法
	 * 递归的结束条件：
	 * 如果这个树是左子树，并且已经转换完成，返回的是最右的孩子
	 * 如果这个树是右子树，并且已经转化完成，返回的是最左的节点
	 * 如果为叶子节点，直接返回叶子节点
	 * 递归的条件：
	 * 首先排序左子树
	 * 然后排序右子树
	 */
	private static Node Tree2List(Node rootNode, boolean isRight) {
		// TODO Auto-generated method stub
		if(rootNode == null){
			return null;
		}else{
			//要求不能创建任何新的结点
			//左右节点不为空的时候，就递归的调用左右节点
		      Node leftNode = rootNode.getLeft();  
		      Node rightNode = rootNode.getRight();  
		          
		         
		        if (leftNode != null) {  
		        	//如果左节点不为空，那么则去调用左子树
		            Node leftResultNode = Tree2List(leftNode, false);  
		            if (leftResultNode != null) {  
		                rootNode.setLeft(leftResultNode);  
		                leftResultNode.setRight(rootNode);  
		            }  
		        }  
		          
		        if (rightNode != null) { 
		        	//如果右节点不为空，那么则去调用有姿势
		            Node rightResultNode = Tree2List(rightNode, true);  
		            if (rightResultNode != null) {  
		                rightResultNode.setLeft(rootNode);  
		                rootNode.setRight(rightResultNode);  
		            }  
		        }  
		          
		          
		        Node tempNode = rootNode;  
		          
		        if (isRight) { 
		        	//如果是右子树，那么返回的则左节点
		            if (leftNode != null) {  
		                return lastLeftnode(leftNode);  
		            }  
		        } else {  
		        	//如果是左子树，那么返回的则是右节点
		            if (rightNode != null) {  
		                return lastRightNode(rightNode);  
		            }  
		        }  
		          
		        return tempNode; 
			
		}
	}

	/**
	 * @param rightNode
	 * @return
	 */
	private static Node lastRightNode(Node rightNode) {
		while(rightNode.getRight() != null){
			rightNode = rightNode.getRight();
		}
		return rightNode;
	}

	/**
	 * @param leftNode
	 * @return
	 */
	private static Node lastLeftnode(Node leftNode) {
		while(leftNode.getLeft() != null){
			leftNode = leftNode.getLeft();
		}
		return leftNode;
	}

	/**
	 * 代表树中的单个结点
	 * @zhailzh
	 */
	static class Node {
		
		public Node(int str) {
			setContent(str);
		};
		private int content;//节点内容
		
		private Node left;//左节点
		
		private Node right;//右节点

		public int getContent() {
			return content;
		}

		public void setContent(int content) {
			this.content = content;
		}

		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;
		}

		/**
		 * 测试的树
		 * */
		static  class Tree {		
			public final Node rootNode = new Node(10);	
			public Node getRootNode () {
				Node node6 = new Node(6);
				
				Node node3 = new Node(3);
				Node node4 = new Node(4);
				Node node5 = new Node(5);
				
				Node node7 = new Node(7);
				Node node8 = new Node(8);
				Node node9 = new Node(9);
				
				Node node14 = new Node(14);
				Node node12 = new Node(12);
				Node node16 = new Node(16);
				rootNode.setLeft(node6);
				rootNode.setRight(node14);
				node6.setLeft(node4);
				node4.setLeft(node3);
				node4.setRight(node5);
				node6.setRight(node8);
				node8.setLeft(node7);
				node8.setRight(node9);
				node14.setLeft(node12);
				node14.setRight(node16);
				return rootNode;
			}
		}
		
	}
}