数据结构--带头尾结点的双链表

最近要考数据结构了，哎，这么大了还考试，真烦。既然自己干这行的，数据结构又是那么基础和必要的东西，所以决定把一些数据结构用C++重写一遍，也算是加深学习吧。

说实话，真是没怎么写过这么基础的数据结构，如果有什么缺陷请大家多多提意见。日后还会继续写其他的

今天，给List加入了迭代器，可能会在今后的使用中更通用化

 

 

  1#pragma once;
  2template<typename T>
  3struct mynode
  4{
  5    mynode()
  6        :pNext(NULL),
  7        pPrior(NULL){}
  8
  9    T data;
 10    mynode<T> * pNext;    
 11    mynode<T> * pPrior;
 12};
 13
 14template<typename T>
 15class mylist
 16{
 17public:
 18    struct Iterator
 19    {
 20        explicit Iterator(mynode<T>* p)
 21            :m_pCurrent(p)
 22        {}
 23        
 24
 25        Iterator& operator ++()
 26        {
 27            m_pCurrent = m_pCurrent->pNext;
 28            return *this;
 29        }
 30
 31        Iterator operator ++(int)
 32        {
 33            mynode<T>* p = m_pCurrent;
 34            m_pCurrent = m_pCurrent->pNext;
 35            return Iterator(p);
 36        }
 37
 38        Iterator& operator --()
 39        {
 40            m_pCurrent = m_pCurrent->pPrior;
 41            return *this;
 42        }
 43
 44        Iterator operator --(int)
 45        {
 46            mynode<T>* p = m_pCurrent;
 47            m_pCurrent = m_pCurrent->pPrior;
 48            return Iterator(p);
 49        }
 50
 51        bool operator == (const Iterator& it)
 52        {
 53            return m_pCurrent == it.m_pCurrent;
 54        }
 55
 56        bool operator != (const Iterator& it)
 57        {
 58            return !(*this == it);
 59        }
 60
 61        T& operator*()
 62        {
 63            return m_pCurrent->data;
 64        }
 65
 66        bool hasNext()
 67        {
 68            return m_pCurrent!= NULL && m_pCurrent->pNext != NULL;
 69        }
 70        friend class mylist;
 71    private:
 72        mynode<T>* m_pCurrent;
 73        Iterator(){};
 74    };    
 75    mylist()
 76    {
 77        m_pHead = new mynode<T>();
 78        m_pTail = new mynode<T>();
 79        
 80        m_pHead->pNext = m_pTail;
 81        m_pTail->pPrior = m_pHead;
 82        
 83    }
 84
 85    ~mylist()
 86    {
 87        _Destory();
 88    }
 89
 90    //向尾部插入新节点
 91    void push_back(const T & data)
 92    {
 93        _insert(m_pTail->pPrior, data);
 94    }
 95
 96
 97
 98    Iterator insert(Iterator pWhere, const T& data)
 99    {
        if(!isNode(pWhere.m_pCurrent))
        {
            return Iterator(NULL);
        }

        return Iterator(_insert(pWhere.m_pCurrent, data));
    }

    //向任意位置之后插入新节点
    
    //删除指定位置的节点
    bool remove(Iterator iWhere)
    {
        mynode<T>* pWhere = iWhere.m_pCurrent;
        if(pWhere == NULL)
        {
            return false;
        }

        if(empty())
        {
            return false;
        }

        if(isHead(pWhere) || isTail(pWhere))
        {
            return false;
        }
        

        if(!isNode(pWhere))
        {
            return false;
        }

        pWhere->pPrior->pNext = pWhere->pNext;
        pWhere->pNext->pPrior = pWhere->pPrior;
        


        delete pWhere;

        return true;
    }

    Iterator begin()
    {
        return Iterator(m_pHead->pNext);
    }

    Iterator end()
    {
        return Iterator(m_pTail);
    }
    

    //查找指定数据在链表中的位置
    Iterator find(const T &data)
    {
        if(empty())
        {
            return Iterator(m_pTail);
        }

        mynode<T>* p = m_pHead->pNext;

        while(!isTail(p))
        {
            if(p->data == data)
            {
                return Iterator(p);
            }
            p = p->pNext;
        }

        return Iterator(p);
    }

    bool empty()
    {
        return m_pHead->pNext == m_pTail;
    }

    size_t size()
    {
        size_t _size = 0;
        if(empty())
        {
            return 0;
        }
        mynode<T>* p = m_pHead->pNext;

        while(!isTail(p))
        {    
            _size ++;
            p = p->pNext;
        }
        return _size;
    }

    void clear()
    {
        Iterator it = begin();
        while(it != end())
        {
            remove(it++);

        }
    }
private:
    mynode<T>* createNewNode(const T& data)
    {
        mynode<T> * pNewNode = new mynode<T>;
        pNewNode->data = data;
        return pNewNode;
    }

    bool isHead(mynode<T>* pWhere)
    {
        return pWhere == m_pHead;
    }

    bool isTail(mynode<T>* pWhere)
    {
        return pWhere == m_pTail;
    }


    bool isNode(mynode<T>* pWhere)//判断给定指针是否为链表中的合法节点
    {
        mynode<T> *p = m_pHead;
        while(p)
        {
            if(p == pWhere)
            {
                return true;
            }
            p = p->pNext;
        }

        return false;
    }

    mynode<T>* _insert(mynode<T>* pWhere, const T& data)
    {
        if(pWhere == NULL)
        {
            return NULL;
        }
        mynode<T> * pNewNode = createNewNode(data);
        if(pNewNode == NULL)
        {
            return NULL;
        }

        if(isHead(pWhere))
        {
            pNewNode->pNext = m_pTail;
            m_pHead->pNext = pNewNode;
            m_pTail->pPrior = pNewNode;
            pNewNode->pPrior = m_pHead;
        }
        else
        {
            pNewNode->pNext = pWhere;
            pNewNode->pPrior = pWhere->pPrior;
            pNewNode->pPrior->pNext = pNewNode;
            pWhere->pPrior = pNewNode;
        }
        


        return pNewNode;
    }

    void _Destory()
    {
        mynode<T> * p = m_pHead;

        do
        {
            mynode<T> *q = p;
            p = p->pNext;
            free(q);
        }while(p);
    }

    mynode<T>* m_pHead;
    mynode<T>* m_pTail;
};