搜索二叉树含迭代器

来源：互联网发布：抽奖活动算法编辑：程序博客网时间：2024/05/20 12:47
搜索二叉树含迭代器
vs2013下编写的项目工程见
我的
github: https://github.com/excelentone/DataStruct
#include<iostream>#include<cassert>using namespace std;template<class K, class V>struct BSTNode{    BSTNode(const K& key=0, const V& value=0)    : _pLeft(NULL)    , _pRight(NULL)    , _pParent(NULL)    , _key(key)    , _value(value)    {}    BSTNode<K, V>* _pParent;    BSTNode<K, V>* _pLeft;    BSTNode<K, V>* _pRight;    K _key;    V _value;};//template<typename K, typename V>class BinaryIterator{private:    typedef BSTNode<K, V> Node;    typedef BinaryIterator<K, V/*, K&, V&*/> Iterator;public:    BinaryIterator(Node *pNode = nullptr) :_pNode(pNode)    {}    Iterator &operator++()    {        _Increase(_pNode);        return *this;    }    Iterator &operator--()    {        _Decrease(_pNode);        return *this;    }    Iterator operator++(int)    {        Iterator temp(*this);        ++(*this);        return temp;    }    Iterator operator--(int)    {        Iterator temp(*this);        --(*this);        return temp;    }    bool operator==(Iterator &it)    {        return _pNode == it._pNode;    }    bool operator!=(Iterator &it)    {        return !(*this == it);    }private:    Node *FindMax(Node *pCur)    {        assert(pCur);        while (pCur->_pRight)            pCur = pCur->_pRight;        return pCur;    }    Node *FindMin(Node *pCur)    {        assert(pCur);        while (pCur->_pLeft)            pCur = pCur->_pLeft;        return pCur;    }    void _Increase(Node *pNode)    {        if (pNode->_pRight)        {            pNode = FindMin(pNode->_pRight);        }        else        {            Node *pParent = pNode->_pParent;            while (pParent->_pRight == pNode)            {                pNode = pParent;                pParent = pNode->_pParent;            }            if (pParent->_pRight != pNode)                pNode = pParent;        }        _pNode = pNode;    }    void _Decrease(Node *pNode)    {        if (pNode->_pLeft)        {            pNode = FindMax(pNode->_pLeft);        }        else        {            Node *pParent = pNode->_pParent;            while (pParent->_pLeft == pNode)            {                pNode = pParent;                pParent = pNode->_pParent;            }            pNode = pParent;        }        _pNode = pNode;    }public:    Node *_pNode;};template<class K, class V>class BinarySearchTree{    typedef BSTNode<K, V> Node;    typedef BinarySearchTree<K, V> Self;public:    BinarySearchTree()        : _pRoot(NULL), _pHead(new Node())    {}    BinarySearchTree(const Self& bst)    {               _pRoot=_Init(bst._pRoot);    }    Self& operator=(const Self& bst)    {        if (this != &bst)        {            if (_pRoot)            {                _DestroyTree(_pRoot);            }            _pRoot=_Init(bst._pRoot);        }        return *this;    }    ~BinarySearchTree()    {        _DestroyTree(_pRoot);    }    // 查找递归和非递归    Node * Find_Nor(const K& key)    {        return _Find_Nor(_pRoot,key);    }    Node * 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;        }        return _Insert_Nor(_pRoot, key,value);    }    bool Insert(const K& key, const V& value)    {        bool flag=_Insert(_pRoot,NULL,key, value);        _pHead->_pParent = _pRoot;        _pRoot->_pParent = _pHead;        _pHead->_pLeft = FindMin(_pRoot);        _pHead->_pRight = FindMax(_pRoot);        return flag;    }    // 删除递归和非递归    bool Remove_Nor(const K& key)    {        return _Remove_Nor(_pRoot,key/*,false*/);    }    bool Remove(const K& key)    {        bool flag= _Remove(_pRoot, key);        _pHead->_pParent = _pRoot;        _pRoot->_pParent = _pHead;        _pHead->_pLeft = FindMin(_pRoot);        _pHead->_pRight = FindMax(_pRoot);        return flag;    }    void InOrder()    {        cout << "InOrder:";        _InOrder(_pRoot);        cout << endl;    }    Node * ToList()    {        Node *pre = NULL;        _ToList(_pRoot, pre);        return FindMin(_pRoot);    }    BinaryIterator<K, V> end()    {        return BinaryIterator<K, V> (_pHead);    }    BinaryIterator<K, V> begin()    {        return BinaryIterator<K, V>(FindMin(_pRoot));    }private:    Node * _Find_Nor(Node *pRoot, const K &key)    {        Node *pCur = pRoot;        while (pCur)        {            if (key < pCur->_key)            {                pCur = pCur->_pLeft;            }            else if (key>pCur->_key)            {                pCur = pCur->_pRight;            }            else            {                return pRoot;            }        }        return NULL;    }    Node *FindMin(Node *pCur)    {        assert(pCur);        while (pCur->_pLeft)            pCur = pCur->_pLeft;        return pCur;    }    Node *FindMax(Node *pCur)    {        assert(pCur);        while (pCur->_pRight)            pCur = pCur->_pRight;        return pCur;    }    Node* _Find(Node* pRoot, const K& key)    {        if (NULL == pRoot)        {            return false;        }        if (key < pRoot->_key)        {            _Find(pRoot->_pLeft, key);        }        else if (key>pRoot->_key)        {            _Find(pRoot->_pRight, key);        }        else        {            return pRoot;        }    }    bool _Insert_Nor(Node* pRoot, const K &key, const V &value)    {        while (pRoot)        {            if (key < pRoot->_key)            {                if (NULL == pRoot->_pLeft)                {                    pRoot->_pLeft = new Node(key, value);                    return true;                }                else                    pRoot = pRoot->_pLeft;            }            else if (key>pRoot->_key)            {                if (NULL == pRoot->_pRight)                {                    pRoot->_pRight = new Node(key, value);                    return true;                }                else                    pRoot = pRoot->_pRight;            }            else            {                return false;            }        }        return true;    }    bool _Insert(Node* &pRoot, Node *pParent,const K& key, const V& value)    {        if (NULL == pRoot)        {            pRoot = new Node(key, value);            pRoot->_pParent = pParent;            return true;        }        if (key < pRoot->_key)        {            pParent = pRoot;            _Insert(pRoot->_pLeft,pParent, key, value);        }        else if (key>pRoot->_key)        {            pParent = pRoot;            _Insert(pRoot->_pRight, pParent, key, value);        }        else        {            return false;        }        return true;    }    bool _Remove(Node*& pRoot, const K& key)    {        if (NULL == pRoot)        {            return false;        }        if (pRoot->_key > key)        {            _Remove(pRoot->_pLeft, key);        }        else if (pRoot->_key < key)        {            _Remove(pRoot->_pRight, key);        }        else        {            if (NULL != pRoot->_pLeft&&NULL != pRoot->_pRight)            {                Node *pDel = pRoot;                pRoot->_key = FindMin(pRoot->_pRight)->_key;                _Remove(pRoot->_pRight, pRoot->_key);            }            else            {                Node *pDel = pRoot;                if (pRoot->_pLeft != NULL)                {                    pRoot = pRoot->_pLeft;                }                else                {                    pRoot = pRoot->_pRight;                }                delete pDel;            }        }        return false;    }    bool _Remove_Nor(Node *&pRoot, const K &key/*,bool flag*/)    {        Node *pCur = pRoot;        Node *pParent = pCur;        /*if (flag == true)        {            pCur = pCur->_pRight;        }*/        while (pCur)        {            if (key < pCur->_key)            {                pParent = pCur;                pCur = pCur->_pLeft;            }            else if (key>pCur->_key)            {                pParent = pCur;                pCur = pCur->_pRight;            }            else            {                if (pCur->_pLeft&&NULL==pCur->_pRight)                {                    if (pCur = pParent->_pLeft)                    {                        Node *pTemp = pCur;                        pParent->_pLeft = pCur->_pLeft;                        delete pTemp;                    }                    else if (pCur = pParent->_pRight)                    {                        Node *pTemp = pCur;                        pParent->_pRight = pCur->_pLeft;                        delete pTemp;                    }                    return true;                }                else if (pCur->_pLeft&&pCur->_pRight)                {                    Node *pTempPre = pCur;                    Node *pTemp = FindMin(pCur->_pRight);                    pCur->_key = pTemp->_key;                    _Remove_Nor(pCur->_pRight, pCur->_key);                    return true;                }                else                 {                    if (pCur ==pParent->_pLeft)                    {                        Node *pTemp = pCur;                        pParent->_pLeft = pCur->_pRight;                        delete pTemp;                    }                    else if (pCur == pParent->_pRight)                    {                        Node *pTemp = pCur;                        pParent->_pRight = pCur->_pRight;                        delete pTemp;                    }                    return true;                }            }        }        return false;    }    void _InOrder(Node* pRoot)    {        if (pRoot)        {            _InOrder(pRoot->_pLeft);            cout << pRoot->_key << " ";            _InOrder(pRoot->_pRight);        }    }    Node *_Init(Node *pRoot)    {           if (NULL != pRoot)        {            Node *pNewRoot = new Node(pRoot->_key, pRoot->_value);            pNewRoot->_pLeft = _Init(pRoot->_pLeft);            pNewRoot->_pRight = _Init(pRoot->_pRight);            return pNewRoot;        }        return NULL;    }    void _DestroyTree(Node *pRoot)    {        if (pRoot)        {            _DestroyTree(pRoot->_pLeft);            _DestroyTree(pRoot->_pRight);            delete(pRoot);            pRoot = NULL;           }    }    void _ToList(Node *pRoot, Node *&pre)    {        if (NULL==pRoot)            return;        Node *cur = pRoot;        _ToList(pRoot->_pLeft,pre);        if (pre)        {            pre->_pRight = cur;        }        cur->_pLeft = pre;        pre = cur;        _ToList(pRoot->_pRight,pre);    }public:    Node* _pRoot;    Node *_pHead;};// 测试非递归的三种情况void Test1(){    BinarySearchTree<int, int> bst;    int a[] = { 5, 3,4,1, 7, 8, 2, 6, 0, 9 };    for (int i = 0; i < sizeof(a) / sizeof(a[0]); i++)    {        bst.Insert(a[i],a[i]);    }    BinarySearchTree<int, int> bstcpy;    bstcpy = bst;    BSTNode<int, int> *list=bst.ToList();       bstcpy.InOrder();    bst.InOrder();    bst.Remove_Nor(6);    bst.InOrder();    cout << bst.Find(10) << endl;    cout << bst.Find_Nor(5) << endl;}// 测试递归的三种情况void Test2(){    BinarySearchTree<int, int> bst;    int a[] = { 5, 3,4, 1, 7, 8, 2, /*6,*/ 0, 9 };    for (int i = 0; i < sizeof(a) / sizeof(a[0]); i++)    {        bst.Insert(a[i], a[i]);    }    //BinaryIterator<int, int> it(bst._pRoot);    ////it = ++bst.end();    //BSTNode<int, int> *start = bst.Find(3);    //for (it=start; it != bst.end(); it++)    //{    //  cout << it._pNode->_key << " ";    //}    cout << endl;    bst.InOrder();    bst.Remove(5);    bst.InOrder();    cout << bst.Find(10) << endl;    cout << bst.Find_Nor(5) << endl;}int main(){    Test1();    //Test2();    system("pause");}
阅读全文
0 0