剑指Offer27：二叉树转双向链表问题

二叉树转双向链表问题

问题描述

* 问题描述
 *      输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。“要求不能创建任何新的结点”，只能调整树中结点指针的指向。例如输入前序遍历为
 *      10、6、4、8、14、12、16的二叉搜索树，其输出的转换后排序双向链表为：4、6、8、10、12、14、16

问题分析

* 问题分析：
 *      在二叉树中，每个结点都有两个指向子结点的指针。在双向链表中，每个结点也有两个指针，它们分别是指向前一个结点和后一个结点。由于这两个结点的
 *      结构相似，同时二叉搜索树也是一种排序的数据结构，因此在理论上有可能实现二叉搜索树和排序的双向链表的转换。在二叉搜索树中，左子结点的值总是小于父结点
 *      的值，有子结点的值总是大于父结点的值。因此在转换成排序的双向链表时，原先指向左子结点的指针调整为链表中指向前一个结点的指针，原先指向右子结点
 *      的指针调整为链表中指向后一个结点指针。
 *      由于要求转换后的链表是排序好的，因此可以用中序遍历来操作，对于二叉查找树而言，其中序遍历序列就是从小到大排序的。当遍历到根结点的时候，我们把
 *      树看成三个部分：值为10的根结点，根结点值为6的左子树，根结点值为14的右子树。根据排序链表的定义，值为10的结点将和它的左子树的最大一个结点（值为8的结点）
 *      链接起来，同时它将和右子树最小的结点（即值为12的结点）链接起来。

public class Code027 {
    public static void main(String[] args){
        BinaryTreeNode node1=new BinaryTreeNode(10);
        BinaryTreeNode node2=new BinaryTreeNode(6);
        BinaryTreeNode node3=new BinaryTreeNode(14);
        BinaryTreeNode node4=new BinaryTreeNode(4);
        BinaryTreeNode node5=new BinaryTreeNode(8);
        BinaryTreeNode node6=new BinaryTreeNode(12);
        BinaryTreeNode node7=new BinaryTreeNode(16);
        BinaryTreeNode pRoot1=node1;
        node1.pLeft=node2;node1.pRight=node3;
        node2.pLeft=node4;node2.pRight=node5;
        node3.pLeft=node6;node3.pRight=node7;

//        BinaryTreeNode pNowRoot=Convert(pRoot1);
        BinaryTreeNode pNowRoot=ConvertBSTToBiList(pRoot1);
        while (pNowRoot!=null){
            System.out.print(pNowRoot.value+" ");
            pNowRoot=pNowRoot.pRight;
        }
    }

    //定义双向链表的左边头结点和右边头结点，初始化为null
    static BinaryTreeNode leftHead=null;
    static BinaryTreeNode rightHead=null;
    private  static BinaryTreeNode Convert(BinaryTreeNode pRootOfTree){
        //递归调用叶子结点的左右结点返回null
        if(pRootOfTree==null){
            return null;
        }
        //第一次运行时，它会使最左边的叶子结点为链表的第一个节点
        Convert(pRootOfTree.pLeft);
        if(rightHead==null){
            leftHead=pRootOfTree;
            rightHead=pRootOfTree;
        }else {
            //把根结点插入到双向链表右边，rightHead向后移动
            rightHead.pRight=pRootOfTree;
            pRootOfTree.pLeft=rightHead;
            rightHead=pRootOfTree;
        }
        //把右叶子结点也插入到双向链表（rightHead已确定，直接插入）
        Convert(pRootOfTree.pRight);
        //返回左边头结点，也可以返回右边头结点
        return leftHead;
    }
    //非递归法：借助栈来存储中序遍历的结果顺序
    private static BinaryTreeNode ConvertBSTToBiList(BinaryTreeNode pRoot){
        if(pRoot==null){
            return null;
        }
        //定义栈用于存储中序遍历的结点顺序
        Stack<BinaryTreeNode> stack=new Stack<>();
        BinaryTreeNode p=pRoot;
        BinaryTreeNode pre=null;//用于保存中序遍历的上一个结点
        boolean isFirst=true;
        while (p!=null|| !stack.isEmpty()){
            while (p!=null){
                stack.push(p);
                p=p.pLeft;
            }
            //找到左子树的最左叶子结点，即为中序遍历的第一个结点
            p=stack.pop();
            if(isFirst){
                pRoot=p;//将中序遍历列中的第一个节点记为pRoot
                pre=pRoot;
                isFirst=false;
            }else {
                pre.pRight=p;
                p.pLeft=pre;
                pre=p;
            }
            p=p.pRight;
        }
        return pRoot;
    }

    //定义二叉树的结点类
    private static class BinaryTreeNode{
        int value;
        BinaryTreeNode pLeft;
        BinaryTreeNode pRight;
        public BinaryTreeNode() {
        }
        public BinaryTreeNode(int value) {
            this.value = value;
        }
    }
}