将二叉搜索树转换成链表

二叉搜索树与双向链表的相同点是：
二叉搜索树右左右指针域，而双向链表也有前去与后继，这样只要按照中序遍历的方法，将二叉树遍历一遍，改变原来的左右指针域的指向，就能变成双向链表。

首先将搜索二叉树写成迭代器，迭代器的本质就是指针，用指针++或–的方式，依次获得链表的节点。

template<class K, class V>
struct BSTNode
{
    BSTNode(const K& key = K(), const V& value = V())
        :_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;
};

class BSTIterator
{
    typedef BSTNode<K, V> Node;
    typedef BSTIterator<K, V, Ref, Ptr> Self;
public:
    BSTIterator()
        :_pNode(NULL)
    {}
    BSTIterator(Node* pNode)
        :_pNode(_pNode)
    {}
    BSTIterator(const Self& s)
        :_pNode(s._pNode)
    {}
    Self& operator++()
    {
        Increment();
        return *this;
    }
    Self operator++(int)
    {
        Self pCur(*this);
        Increment();
        return pCur;
    }
    Self& operator--()
    {
        Decrement();
        return *this;
    }
    Self operator--(int)
    {
        Self pCur(*this);
        Decrement();
        return pCur;
    }
    Ref operator*()
    {
        return _pNode->_key;
    }
    Ptr operator->()
    {
        return &(operator*());
    }
    bool operator!=(const Self& s)
    {
        return _pNode != s._pNode;
    }
    bool operator==(const Self& s)
    {
        return _pNode == s._pNode;
    }
protected:
    // 取当前结点的下一个结点
    void Increment()
    {
        //如果右孩子存在，取右孩子中的最小节点
        if(_pNode->_pRight)
        {
            _pNode = _pNode->_pRight;
            while(_pNode->_pRight)
                _pNode = _pNode->_pLeft;
        }
        else
        {
            Node* pParent = _pNode->_pParent;
            while(pParent->_pRight == _pNode)
            {
                _pNode = pParent;
                pParent = pParent->_pParent;
            }
            if(_pNode->_pRight != pParent)
                _pNode = pParent;
        }
    }

    // --取前一个小的结点，在left子树中
    void Decrement()
    {
        if(_pNode->_pLeft)
        {
            _pNode = _pNode->_pLeft;
            while(_pNode->_pRight)
                _pNode = _pNode->_pRight;
        }
        else
        {
            Node* pParent = _pNode->_pParent;
            while(pParent->_pLeft == _pNode)
            {
                _pNode = pParent;
                pParent = pParent->_pParent;
            }
            _pNode = pParent;
        }
    }
protected:
    Node* _pNode;
};

在该类中需要重载许多运算符。
因为迭代器的begin()函数与end()函数是前闭后开的，表明end()的位置是取不到的，所以为了方便起见，需要定义一个头节点来表明这个位置。

所以他的插入与删除函数就与一般搜索二叉树有点不同了。

template <class K, class V>
class BSTree
{
    typedef BSTNode<K, V> Node;
public:
    typedef BSTIterator<K, V, K&, K*> Iterator;
    BSTree()
    {
        _pHead = new Node();
        _pHead->_pLeft = _pHead;
        _pHead->_pRight = _pHead;
        _pHead->_pParent = NULL;
    }
    BSTree(const BSTree& bst)
    {
        Node* pRoot = GetRoot();
        pRoot = _CopyBSTree(bst.pRoot);
    }
    BSTree<K, V>& operator=(const BSTree<K, V>& bst)
    {
        Node* pRoot = GetRoot();
        if(&bst != this)
        {
            _Destroy(pRoot);
            pRoot = _CopyBSTree(bst.pRoot);
        }
        return *this;
    }
    Iterator Begin()
    {
        return _pHead->_pLeft;
    }
    Iterator End()
    {
        return _pHead;
    }
    bool Insert(const K& key, const V& value)
    {
        Node*& pRoot = _pHead->_pParent;
        if(pRoot == NULL)
        {
            pRoot = new Node(key, value);
            pRoot->_pParent = _pHead;
        }
        else
        {
            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(pParent->_key > key)
            pParent->_pLeft = pCur;
            else
                pParent->_pRight = pCur;
            pCur->_pParent = pParent;
        }
        _pHead->_pLeft = GetMinKey();
        _pHead->_pRight = GetMaxKey();
        return true;
    }
    Node* Find(const K& key)
    {
        Node* pRoot = GetRoot();
        if(pRoot)
        {
            Node* pCur = _pHead->_pParent;
            while(pCur)
            {
                if(pCur->_key == key)
                    return pCur;
                else if(pCur->_key > key)
                    pCur = pCur->_pLeft;
                else
                    pCur = pCur->_pRight;
            }
        }
        return NULL;
    }
    bool Remove(const K& key)
    {
        Node*& pRoot = GetRoot();
        if(pRoot == NULL)
            return false;
        if(pRoot->_pLeft == NULL && pRoot->_pRight == NULL && pRoot->_key == key)
        {
            delete pRoot;
            _pHead->_pParent = NULL;
        }
        else
        {
            Node* pCur = pRoot;
            Node* pParent = NULL;
            //先找到要删除的节点
            while(pCur)
            {
                if(pCur->_key > key)
                {
                    pParent = pCur;
                    pCur = pCur->_pLeft;
                }
                else if(pCur->_key < key)
                {
                    pParent = pCur;
                    pCur = pCur->_pRight;
                }
                else
                    break;
            }
            if(pCur == NULL)
                return false;
            else
            {
                //左孩子为空,右孩子可能为空
                if(pCur->_pLeft == NULL)
                {
                    //当前节点不是根节点
                    if(pCur != pRoot)
                    {
                        //判断当前节点是其双亲的左孩子还是右孩子
                        if(pCur == pParent->_pLeft)
                            pParent->_pLeft = pCur->_pRight;
                        else
                            pParent->_pRight = pCur->_pRight;
                    }
                    else
                        pRoot = pCur->_pRight;
                }
                //右孩子为空，左孩子不为空
                else if(pCur->_pRight == NULL)
                {
                    if(pCur != pRoot)
                    {
                        if(pCur == pParent->_pLeft)
                            pParent->_pLeft = pCur->_pLeft;
                        else
                            pParent->_pRight = pCur->_pLeft;
                    }
                    else
                        pRoot = pCur->_pLeft;
                }
                //左右孩子都不为空
                else
                {
                    //先找到右子树的最左结点
                    Node* MinNodeInRightTree = pCur->_pRight;
                    pParent = pCur;
                    while(MinNodeInRightTree->_pLeft)
                    {
                        pParent = MinNodeInRightTree;
                        MinNodeInRightTree = MinNodeInRightTree->_pLeft;
                    }
                    //将最左结点与当前节点值交换
                    pCur->_key = MinNodeInRightTree->_key;
                    pCur->_value = MinNodeInRightTree->_value;
                    //问题转化成左孩子为空
                    if(MinNodeInRightTree == pParent->_pLeft)
                        pParent->_pLeft = MinNodeInRightTree->_pRight;
                    else
                        pParent->_pRight = MinNodeInRightTree->_pRight;
                    pCur = MinNodeInRightTree;
                }
                delete pCur;
            }
        }
        _pHead->_pLeft = GetMinKey();
        _pHead->_pRight = GetMaxKey();
        return true;
    }
    Node* GetMaxKey()
    {
        return _GetMaxKey(GetRoot());
    }
    Node* GetMinKey()
    {
        return _GetMinKey(GetRoot());
    }
    Node*& GetRoot()
    {
        return _pHead->_pParent;
    }
    void InOrder()
    {
        cout<<"InOrder: ";
        _InOrder(GetRoot());
        cout<<endl;
    }
    Node* ToList()
    {
        //链表的头结点就是最左结点
        Node* pHead = GetRoot();
        Node* pPre = NULL;
        while(pHead->_pLeft)
            pHead = pHead->_pLeft;
        _ToList(GetRoot(), pPre);
        return pHead;
    }
private:
    void _ToList(Node* pRoot, Node*& pPre)
    {
        if(pRoot)
        {
            _ToList(pRoot->_pLeft, pPre);

            pRoot->_pLeft = pPre;
            if(pPre)
                pPre->_pRight = pRoot;
            pPre = pRoot;
            _ToList(pRoot->_pRight, pPre);
        }
    }
    void _Destroy(Node*& pRoot)
    {
        if(pRoot)
        {
            _Destroy(pRoot->_pLeft);
            _Destroy(pRoot->_pRight);
            delete pRoot;
            pRoot = NULL;
        }
    }
    Node* _CopyBSTree(Node* pRoot)
    {
        Node* pCur = NULL;
        if(pRoot)
        {
            pCur = new Node(pRoot->_key, pRoot->_value);
            pCur->_pLeft = _CopyBSTree(pRoot->_pLeft);
            pCur->_pRight = _CopyBSTree(pRoot->_pRight);
        }
        return pCur;
    }
    void _InOrder(Node* pRoot)
    {
        if(pRoot)
        {
            _InOrder(pRoot->_pLeft);
            cout<<pRoot->_key<<" ";
            _InOrder(pRoot->_pRight);
        }
    }
    Node* _GetMaxKey(Node* pRoot)
    {
        while(pRoot->_pRight)
            pRoot = pRoot->_pRight;
        return pRoot;
    }
    Node* _GetMinKey(Node* pRoot)
    {
        while(pRoot->_pLeft)
            pRoot = pRoot->_pLeft;
        return pRoot;
    }
private:
    Node* _pHead;
};

调用方式：

#include "BSTIterator.h"


int main()
{
    int arr[] = {5,3,4,1,7,8,2,6,0,9};
    BSTree<int, int> bt;
    for(int i=0; i<sizeof(arr)/sizeof(arr[0]); ++i)
    {
        bt.Insert(arr[i], i);
    }
    bt.InOrder();
    BSTNode<int, int>* pos = bt.ToList();
    while(pos)
    {
        cout<<pos->_key<<" ";
        pos = pos->_pRight;
    }
    /*BSTree<int, int> ::Iterator it = bt.Begin();
    while(it != bt.End())
    {
        cout<<*it<<" ";
        it++;
    }
    cout<<endl;*/
    system("pause");
    return 0;
}