二叉搜索树与双向链表（中序遍历 ****）

题目描述：输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。

public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;
    }
}

思路一：递归

1.将左子树构造成双链表，并返回链表头节点。 

2.定位至左子树双链表最后一个节点。

3.如果左子树链表不为空的话，将当前pRootOfTree追加到左子树链表。 

4.将右子树构造成双链表，并返回链表头节点。 

5.如果右子树链表不为空的话，将该链表追加到pRootOfTree节点之后。 

6.根据左子树链表是否为空确定返回的节点。

public class Solution {
    public TreeNode Convert(TreeNode pRootOfTree) {
        if (pRootOfTree == null) return null;

        if (pRootOfTree.left == null && pRootOfTree.right == null) return pRootOfTree;

        //将左子树构造成双链表，并返回链表头节点
        TreeNode left =  Convert(pRootOfTree.left);
        TreeNode p = left;

        //定义左子树双链表的最后一个节点
        while (p != null && p.right != null)
            p = p.right;

        //如果左子树链表不为空的话，将当前的pRootOfTree追加到左子树链表中
        if (left != null)
        {
            p.right = pRootOfTree;
            pRootOfTree.left = p;
        }

        //将右子树构造成双链表，并返回链表头节点
        TreeNode right = Convert(pRootOfTree.right);
        if (right != null)
        {
            right.left = pRootOfTree;
            pRootOfTree.right = right;
        }

        return left == null ? pRootOfTree:left;
    }
}

思路二：递归，仅对第2点中的定位作了修改，新增一个全局变量记录左子树的最后一个节点。

public class Solution {
    protected TreeNode leftLast = null;
    
    public TreeNode Convert(TreeNode pRootOfTree) {
        if (pRootOfTree == null) return null;
        if (pRootOfTree.left == null && pRootOfTree.right == null)
        {
            leftLast = pRootOfTree;
            return pRootOfTree;
        }

        TreeNode left = Convert(pRootOfTree.left);
        if (left != null)
        {
            leftLast.right = pRootOfTree;
            pRootOfTree.left = leftLast;
        }
        leftLast = pRootOfTree;

        TreeNode right = Convert(pRootOfTree.right);
        if (right != null)
        {
            right.left = pRootOfTree;
            pRootOfTree.right = right;
        }
        return left != null?left:pRootOfTree;
    }
}

思路三：中序遍历，递归

public class Solution {
    //双向链表的左边头结点和右边头节点
    TreeNode leftHead = null;
    TreeNode rightHead = null;
    public TreeNode Convert(TreeNode pRootOfTree) {
        if (pRootOfTree == null) return null;
        //第一次运行时，会使最左边叶子节点为链表第一个节点
        Convert(pRootOfTree.left);
        if (rightHead == null)
            leftHead = rightHead = pRootOfTree;
        else 
        {
            //把根节点插入到双向链表最右边，rightHead向右移动
            rightHead.right = pRootOfTree;
            pRootOfTree.left = rightHead;
            rightHead = pRootOfTree;
        }
        Convert(pRootOfTree.right);
        return leftHead;

    }
}

思路四：非递归

public class Solution {
    public TreeNode Convert(TreeNode pRootOfTree) {
       if (pRootOfTree == null) return null;

       Stack<TreeNode> stack = new Stack<>();
       TreeNode p = pRootOfTree;
       TreeNode pre = null;
       boolean isFirst = true;
       while (p != null || !stack.isEmpty())
       {
           while ( p != null)
           {
               stack.push(p);
               p = p.left;
           }
           if (!stack.isEmpty())
                p = stack.pop();
           if (isFirst)
           {
               pRootOfTree = p;
               pre = pRootOfTree;
               isFirst = false;
           }
           else
           {
               pre.right = p;
               p.left = pre;
               pre = p;
           }
           p = p.right;
       }
       return pRootOfTree;
    }
}