将二叉搜索树转换成一个排序的双向链表

题目：将二叉搜索树转换成一个排序的双向链表。提示：要求不能创建任何新的结点，只能调整树中结点指针的指向，也就是left当prev，right当next。–中序线索化的变型。

1、由于要求链表是有序的，可以借助二叉树中序遍历，因为中序遍历算法的特点就是从小到大访问结点。当遍历访问到根结点时，假设根结点的左侧已经处理好，只需将根结点与上次访问的最近结点（左子树中最大值结点）的指针连接好即可。进而更新当前链表的最后一个结点指针。
2、由于中序遍历过程正好是转换成链表的过程，即可采用递归处理。
中序遍历该二叉树的结果：


把二叉搜索树看成三部分：根节点，左子树和右子树。在把左，右子树都转换成排序的双向链表之后再和根节点链接起来，整棵二叉搜索也就转换成了排序的双向链表。
二叉搜索树的结点：

template<class K, class V>          //键值队
struct BSTNode
{
    BSTNode(const K& key, const V& value)
        : _pLeft(NULL)
        , _pRight(NULL)
        ,_pParent(NULL)
        , _key(key)
        , _value(value)
    {}

    BSTNode<K, V>* _pLeft;
    BSTNode<K, V>* _pRight;
    BSTNode<K, V>* _pParent;
    K _key;
    V _value;
};

template<class K, class V>
class BinarySearchTree
{
    typedef BSTNode<K, V> Node;
    typedef BinarySearchTree<K, V> Self;
public:
    BinarySearchTree()
        : _pRoot(NULL)
    {}
    //拷贝构造函数
    //BinarySearchTree(const Self& bst);
    //赋值运算符重载
    //Self& operator=(const Self& bst);
    //析构函数
    ~BinarySearchTree()
    {
         _DestroyTree(_pRoot);
    }

     // 查找--非递归
    bool Find_Nor(const K& key)
    {
        Node* pCur = _pRoot;
        while (pCur)  //二叉树存在
        {
            if (pCur->_key == key)
                return true;
            else if (key < pCur->_key)
                return pCur = pCur->_pLeft;
            else 
                pCur = pCur->_pRight;
        }
        return false;
    }
    //递归查找
    bool Find(const K& key)
   {
       return _Find(_pRoot, key);
   }

    // 插入--非递归
    bool Insert_Nor(const K& key, const V& value)  //插入某元素
    {
        if (NULL == _pRoot)
        {
            _pRoot = new Node(key, value);
            return true;
        }
        //找元素插入位置
        Node* pCur = _pRoot;
        Node* pParent = NULL;  //标记
        while (pCur)
        {
            if (key < pCur->_key)
            {
                pParent = pCur;
                pCur = pCur->_pLeft ;  //新插入的结点保存在左子树
            }
            else if (key > pCur->_key)
            {
                pParent = pCur;
                pCur = pCur->_pRight;   //新插入的结点保存在右子树
            }
            else 
                return false;
        }
        pCur = new Node(key, value);
        if (key < pParent->_key)
            //pParent = pParent->_pLeft ;
            pParent->_pLeft = pCur;
        else if (key > pParent->_key)
            //pParent = pParent->_pRight;
             pParent->_pRight = pCur;
        else 
            return false;

    }
//  递归--插入
    bool Insert(const K& key, const V& value)
    {
         return _Insert(_pRoot, key, value);  //
    }
    void InOrder()
    {
        cout << "InOrder(): " << endl;
        _InOrder(_pRoot);
        cout << endl;
    }
    //二叉搜索树与双向链表
    Node* Convert()  //_pRoot
    {
        Node* pLastNodeInList = NULL;
        ConvertNode(_pRoot, &pLastNodeInList);   //pLastNodeInList-->双向链表的尾结点
        //返回头结点
        Node* pHeadOfList = pLastNodeInList;
        while (pHeadOfList != NULL && pHeadOfList->_pLeft != NULL)
            pHeadOfList =  pHeadOfList->_pLeft;
        return pHeadOfList;
    }
    private:
        bool _Find(Node* pRoot, const K& key)
        {
            if (pRoot)  //二叉树存在
            {
                if (key == pRoot->_key)  //查找的值在左子树中
                    return true;
                else if (key < pRoot->_key)
                    return  _Find(pRoot->_pLeft, key); // 查找的值在左子树中
                else
                    return _Find(pRoot->_pRight, key);  //查找的值在右子树中

            }
            return false; //树不存在
        }

        bool _Insert(Node* &pRoot, const K& key, const V& value)  //--- 
        {
            if (NULL == pRoot)  //1）、树为空，插入结点作为根结点
            {
                pRoot = new Node(key, value);
                return true;
            }
            else  //二叉树存在--插入的结点在左右子树中
            {
                if (key < pRoot->_key)
                    return _Insert(pRoot->_pLeft, key, value);  //
                else if (key > pRoot->_key)
                    return _Insert(pRoot->_pRight, key, value);  //
                else
                    return false;
            }
        }


        void _InOrder(Node* pRoot)  //Node* pRoot--中序遍历
        {
            if(pRoot)
            {
                //遍历左子树
                _InOrder(pRoot->_pLeft);
                cout<<pRoot->_key<<" ";
                _InOrder(pRoot->_pRight);  //遍历右子树
            }
        }

        //二叉搜索树与双向链表
        void ConvertNode(Node* pRoot, Node** pLastNodeInList)
        {
            if (NULL == pRoot)
                return;
            Node* pCur = pRoot;
            if (NULL != pCur->_pLeft)  //递归处理左子树
                ConvertNode(pCur->_pLeft, pLastNodeInList);
            //pCur--处理当前结点，将当前结点的左指针指向链表的尾结点
            pCur->_pLeft = *pLastNodeInList;  //pLastNodeInList-->双向链表的尾结点
            if (NULL != *pLastNodeInList)
                (*pLastNodeInList)->_pRight = pCur;
            //更新已经转换好的链表的尾结点
            *pLastNodeInList = pCur;

            //递归处理右子树
            if (NULL != pCur->_pRight)
                ConvertNode(pCur->_pRight, pLastNodeInList);
        }
    void _DestroyTree(Node*& pRoot)
    {
        if (pRoot)
        {
            _DestroyTree(pRoot->_pLeft);
            _DestroyTree(pRoot->_pRight);
            delete pRoot;
            pRoot = NULL;
        }
    }
private:
    Node* _pRoot;
};