剑指offer(15)-二叉搜索树与双向链表

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

struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};

class Solution {
public:
    TreeNode* Convert(TreeNode* pRootOfTree)
    {
        TreeNode *pLastNodeInList = NULL;
        ConvertNode(pRootOfTree,&pLastNodeInList);
        TreeNode *pHeadOfList = pLastNodeInList;
        while (pHeadOfList != NULL && pHeadOfList->left != NULL)
            pHeadOfList = pHeadOfList->left;

        return pHeadOfList;

    }

    void ConvertNode(TreeNode* pNode,TreeNode **pLastNodeInList)
        {
        if (pNode == NULL)
            return;
        TreeNode *pCurrent = pNode;

        if (pCurrent->left != NULL)
            ConvertNode(pCurrent->left,pLastNodeInList);

        pCurrent->left = *pLastNodeInList;
        if (*pLastNodeInList != NULL)
            (*pLastNodeInList)->right = pCurrent;

        *pLastNodeInList = pCurrent;

        if (pCurrent->right != NULL)
            ConvertNode(pCurrent->right,pLastNodeInList);
    }
};

另外Crack Coding interview上有一道相关的BST题目，在这里贴一下:

对于一个元素各不相同且按升序排列的有序序列，请编写一个算法，创建一棵高度最小的二叉查找树。
给定一个有序序列int[] vals,请返回创建的二叉查找树的高度。

import java.util.*;
/*
class TreeNode 
{
    int val;
    TreeNode left;
    TreeNode right;
    public TreeNode(int data)
    {
        left = null;
        right = null;
        val = data;
    }
}
*/

public class MinimalBST {

    TreeNode buildBST(int [] vals,int left,int right)
    {

        if (left > right)
            return null;
        int middle = left + (right - left) / 2;
        TreeNode root = new TreeNode(vals[middle]);
        root.left = buildBST(vals,left,middle - 1);
        root.right = buildBST(vals,middle + 1,right);
        return root;
    }

    int highBST(TreeNode root)
    {
        if (root == null)
            return 0;
        int left = highBST(root.left);
        int right = highBST(root.right);
        if (left > right)
            return left + 1;
        else
            return right + 1;
    }

    int buildMinimalBST(int [] vals)
    {
        int length = vals.length;
        if (length <= 0)
            return 0;
        TreeNode root = buildBST(vals,0,length - 1);
        return highBST(root);
    }
}