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

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

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