将二叉查找树变为有序的双向链表

递归实现将二叉查找树变为有序的双向链表,要求不能创建新节点，只调整指针

（1）如果一个节点是空树或者节点不存在左子树和右子树，则返回该节点
（2）定义临时变量，用来接收递归出口得到的结果
（3）如果返回的是左子树的左节点，中序遍历找到临时节点的最右边的节点，然后让临时变量的节点的右孩子指向树根，树根的左孩子指向临时节点
（4）如果返回的是右子树的右节点，中序遍历找到临时节点的最左边的节点，然后让临时变量的节点的左孩子指向树根，树根的右孩子指向临时节点
（5）这样完成二叉查找树变为有序的双向链表

可以使用二叉树的中序非递归遍历来实现
（1）如果一个节点是空树则返回空节点
（2）定义三个树节点，分别是头节点、当前节点和前一个节点
（3）使用二叉树的非递归，先让每个节点左子树进栈，知道不满足条件
（4）出栈，赋值给当前节点，如果头节点是空的，只指向第一次出栈的节点
（5）如果前一个节点是空的，则指向第一个出栈的节点，如果不为空，让前一个节点的右孩子指向当前节点
（6）前一个节点向前移动，最后当前节点的右孩子

package cn.edu.nwu.tree;

import java.util.Stack;
/**
 * @author jcm
 *
 *时间 2016年9月17日
 */
public class ConvertBinaryTreeToDoubleLinkedList {
	public static void main(String[] args) {
		TreeNode root = CreateBinaryTree.createBalanceTreeNode();
		GetTreeNodeInOrderTraver.inOrder(root);
		System.out.println();
//		System.out.println("递归实现将二叉查找树转化为双向链表");
//		TreeNode doubleLinkedListRecursion  = findHead(root);
//		TreeNode current = doubleLinkedListRecursion;
//		while(current != null){
//			System.out.print(current.data+" ");
//			current = current.rightRight;
//		}
		System.out.println("非递归实现将二叉查找树转化为双向链表");
		TreeNode doubleLinkedList = convertBalanceTreeToDoubleList(root);
		while(doubleLinkedList != null){
			System.out.print(doubleLinkedList.data+" ");
			doubleLinkedList = doubleLinkedList.rightRight;
		}
	}
	/**
	 * @author jcm
	 * 将转化后的二叉查找树的有序双向链表树根移到链表的头部
	 * @param root
	 * @return
	 */
	public static TreeNode findHead(TreeNode root){
		//将二叉查找树变为有序的双向链表
		TreeNode current = convertBalanceTreeToDoubleListRecursion(root);
		//将转换后的有序双向链表的树根转移到头指针，找链表的头节点
		while(current.leftChild != null){
			current = current.leftChild;
		}
		return current;
	}
	/**
	 * @author jcm
	 *  递归实现将二叉查找树变为有序的双向链表,要求不能创建新节点，只调整指针
	 * （1）如果一个节点是空树或者节点不存在左子树和右子树，则返回该节点
	 * （2）定义临时变量，用来接收递归出口得到的结果
	 * （3）如果返回的是左子树的左节点，中序遍历找到临时节点的最右边的节点，然后让临时变量的节点的右孩子指向树根，树根的左孩子指向临时节点
	 * （4）如果返回的是右子树的右节点，中序遍历找到临时节点的最左边的节点，然后让临时变量的节点的左孩子指向树根，树根的右孩子指向临时节点
	 * （5）这样完成二叉查找树变为有序的双向链表
	 * @param root
	 * @return
	 */
	public static TreeNode convertBalanceTreeToDoubleListRecursion(TreeNode root){
		if(root==null || (root.leftChild == null && root.rightRight == null)){
			return root;
		}
		TreeNode temp = null;
		if(root.leftChild != null){
			//递归到最左边的树节点
			temp = convertBalanceTreeToDoubleListRecursion(root.leftChild);
			//找到临时节点的最右边的节点
			while(temp.rightRight != null){
				temp = temp.rightRight;
			}
			//改变指向方向，变成双向链表
			temp.rightRight = root;
			root.leftChild = temp;
		}
		if(root.rightRight != null){
			temp = convertBalanceTreeToDoubleListRecursion(root.rightRight);
			//找到临时节点的最左边的节点
			while(temp.leftChild != null){
				temp = temp.leftChild;
			}
			//改变指向方向，变成双向链表
			temp.leftChild = root;
			root.rightRight = temp;
		}
		return root;
	}
	/**
	 * @author jcm
	 *   实现将二叉查找树变为有序的双向链表,要求不能创建新节点，只调整指针
	 *   可以使用二叉树的中序非递归遍历来实现
	 *  （1）如果一个节点是空树则返回空节点
	 *  （2）定义三个树节点，分别是头节点、当前节点和前一个节点
	 *  （3）使用二叉树的非递归，先让每个节点左子树进栈，知道不满足条件
	 *  （4）出栈，赋值给当前节点，如果头节点是空的，只指向第一次出栈的节点
	 *  （5）如果前一个节点是空的，则指向第一个出栈的节点，如果不为空，让前一个节点的右孩子指向当前节点
	 *  （6）前一个节点向前移动，最后当前节点的右孩子
	 * @param root
	 * @return
	 */
	public static TreeNode convertBalanceTreeToDoubleList(TreeNode root){
		if(root == null){
			return null;
		}
		TreeNode head = null;
		TreeNode current = root;
		TreeNode preTreeNode = null;
		Stack<TreeNode> stack = new Stack<TreeNode>();
		while(!stack.isEmpty() || current != null){
			while(current != null){
				stack.push(current);
				current = current.leftChild;
			}
			if(!stack.isEmpty()){
				current = stack.pop();
				if(head == null){
					//头节点指向第一个出栈的节点
					head = current;
				}
				//前一个节点，如果不为空，让他的有节点指向当前节点
				if(preTreeNode != null){
					preTreeNode.rightRight = current;
				}
				//指向最前面的
				preTreeNode = current;
				//当前节点的右孩子节点
				current = current.rightRight;
			}
		}
		return head;
	}
}