双向循环链表的c++模板类

 

#include  < iostream >
using   namespace  std;

template < class  T > class  DblList;

template  < class  T > class  DblNode ... {

    friend class DblList<T>;
    //链表结点数据
    T data;
    DblNode<T> *lLink,*rLink;
public:
    //全域的构造函数
    DblNode(T value,DblNode<T>*left,DblNode<T> *right);
    //只有数据域的构造函数,默认其他域为NULL
    DblNode(T value):data(value),lLink(NULL),rLink(NULL)...{
    }
    //返回数据域
    T getData()...{return data;}

} ;

template < class  T > class  DblList ... {

    DblNode<T> *first,*current;
public:
    DblList(T uniqueVal);//构造函数：建立双向链表的表头结点

    //须通过析构函数来手动释放DblNode对象占用的存储空间
    ~DblList();
    //在定义此成员函数的同时也要说明最后的"const"关键字

    
    int Length() const;

    //判断双向循环链表是否空
    int IsEmpty()...{
        return first->rLink==first;
    }

    int Find(const T& target);//在链表中寻找等于target值的结点,成功1,失败0;

    //初始化,将当前指针指到表头结点
    void Firster()...{current=first;}

    int First();//如链表为空则当前current指针NULL,返回0
    //如果非空则指向表头结点下一个的第一个结点

    int Next();
    //返回当前结点下一个结点,如果没有下一个结点则返回0并且当前指针不变
    int Prior();

    //判断当前指针是否为空,如果空则返回1,否则返回0
    int operator!()...{
    return current!=NULL;
    }

    void Insert(const T &value);//插入一个包含值value域的结点

    void Remove();//删除当前结点

} ;

template < class  T > DblList < T > ::DblList(T uniqueVal)
... {
    //给本类数据成员赋初值
    first=new DblNode<T>(uniqueVal);
    first->rLink=first->lLink=first;
    current=NULL;
}
template < class  T >   int  DblList < T > ::Length() const ... {
    DblNode<T> *p=first->rLink;
    int count=0;
    while(p!=first)...{
        p=p->rLink;
        count++;
    }
    return count;
}

template < class  T >   int  DblList < T > ::Find( const  T &  target)
... {
    DblNode<T> *p=first->rLink;
    while(p!=first&&p->data!=target)
        p=p->rLink;
    if(p!=first)...{current=p;return 1;}
    return 0;
}

template < class  T >   int  DblList < T > ::First()
... {
    if(!IsEmpty())
    ...{
        //若链表非空则将current转指向第一个非表头结点
        //否则令当前指针为NULL(不变)并且返回0;
        current=first->rLink;
        return 1;
    }
    return 0;
}

template < class  T >   int  DblList < T > ::Next()
... {
    if(current->rLink=first)...{
        current=NULL;
        return 0;
    }
        current=current->rLink;
        return 1;
}

template < class  T >   int  DblList < T > ::Prior()
... {
    if(current->lLink=frist)
    ...{
        current=NULL;
        return 0;
    }
    current=current->lLink;
    return 1;

}
// 插入
template < class  T >
void  DblList < T > ::Insert( const  T &  value)
... {
    if(current==NULL)
    ...{
        //如果链表为空
        //建立新结点
        //该结点前后指针域都指向表头指针
        current=first->rLink=new DblNode(value,first,first);
    }else
    ...{
        //非空表

        current->rLink=new DblNode(value,current,current->rLink);
        //将当前结点转指向新结点
        current=current->rLink;
    }
    current->rLink->lLink=current;
}


template < class  T >   void  DblList < T > ::Remove()
... {
    //如果顺序往下移的话
    //如果删去了最后一个结点那么自然first就成为了current指针
    //所以要再顺移一次


    //如果删除了之后是空表那么令当前指针current变为NULL

    //删除了之后成空表也包含current=first的情况,所以才有了后面的current=NULL

    if(current!=NULL)
    ...{
        //非空表的时候执行此函数操作
        DblNode *temp=current;
        current=current->rLink;
        current->lLink=temp->lLink;
        temp->lLink->rLink=current;
        delete temp;
        if(current==first)
        ...{
                if(IsEmpty())current=NULL;
                else
                    current=current->rLink;
            }

    }

}