数据结构第五篇——线性表的链式存储之循环链表

♥注：未经博主同意，不得转载。

　　链表是另一种形式的链式存储结构，它是线性链表的一种变形。在线性链表中，每个结点的指针都指向它的下一个结点，最后一个结点的指针域为空，表示链表的结束。若使最后一个结点的指针指向头结点，则链表呈环状，这样的链表称为循环链表。

循环链表当然也分为单链表和双向列表。

通常情况下，在循环链表中设立尾指针而不设头指针，可使某些操作简化。

循环链表的定义和操作与单链表类似，只是循环结束条件有所不同，下面只给出单循环链表的定义和部分操作，至于双向循环链表可能会在以后的项目中出现，到时再进一步探讨。

单循环链表定义如下：

typedef int Data;

struct Node
{
    Data data;            //数据 
    Node* next;        //指向后继的指针 
};

class CList
{
    Node* head;                //创建头结点
    public:
    CList()                    //构造函数
    {
        head = new Node;
        head->next = head;        //头尾相接 
    }
    ~CList();                        //析构函数
    
    Data GetElem(int i);                //取第i个元素的值
    bool IsEmpty();                        //判断是否为空链表
    void Create(Data* a , int n);        //创建长度为n的循环单链表(头插法)
    void Create1(Data* a , int n);        //创建长度为n的循环单链表(尾插法)
    Node* Locate(Data e,int* i);        //查找值为e的结点，返回指向e的指针
    void Insert(Data x,int i);            //将数据元素x插入到第i个位置
    Data Delete(int i);                    //删除第i个元素
    //int _Delete(Data e);                //删除值为e的第一个元素
    int Size();                            //返回链表的长度
    void Clear();                        //清空
    void Print();                        //显示元素
};

函数功能实现如下：

//计算链表长度
int CList::Size()
{
    Node* p;            //创建指针p
    int k;
    p=head->next;        //p指向第一个元素结点 
    k=0;
    while(p!=head)
    {
        p=p->next;
        ++k;
    }
    return k;
}

//显示所有元素
void CList::Print()
{
    Node* p;                //创建指针p
    p=head->next;            //p指向第一个元素结点 
    while(p!=head)    
    {
        cout<<p->data<<" ";
        p=p->next;
    }
    cout<<endl;
}

//取元素
Data CList::GetElem(int i)
{
    if(head->next == NULL)            //为空链表
    {
        cout<<"此链表为空"<<endl;
        exit(0);
    }
    else
    {
        Node* p;            //创建指针p
        int k;
        p=head;                //p指向头结点
        k=0;
        while(p&&k<i)        //p移到i的位置
        {
            p=p->next;
            k++;
        }
        return (p->data);
    }
}    //此算法的时间复杂度为O(n)

//插入操作
void CList::Insert(Data x,int i)
{
    Node* p=head;
    int k=0;
    while(p&&k<i-1)            //    将p指到第i个位置
    {
        p=p->next;
        ++k;
        
        if(p==head)
        p=p->next;
    }
    Node* s = new Node;            //创建此结点
    if(!s)
    {
        cout<<"空间分配失败"<<endl;
        exit(0);
    }
    
    s->data=x;                    //将元素存入创建的结点
    s->next=p->next;
    p->next=s;
}

//删除操作
Data CList::Delete(int i)
{
    Node* p = head;
    int k=0;
    while(p&&k<i-1)                //将p指到要删除的位置
    {
        p=p->next;
        ++k;
        
        if(p==head)
        p=p->next;
    }
    Node* q = p->next;            //暂存删除结点

    p->next = q->next;            //将结点隔离出来
    Data e=q->data;                //将删除的元素储存起来
    delete q;                    //释放将要删除的结点
    return e;
}

//判断链表是否为空 
bool CList::IsEmpty()
{
    if(head->next==NULL)
    {
        cout<<"此链表为空"<<endl;
        return true;
    }
    else
    {
        cout<<"此链表非空"<<endl;
        return false;
    }
}

//建立单循环链表 
//第一种是头插法
void CList::Create(Data* a,int n)
{
    Node* p=NULL;
    Node* q=NULL;
    for(int i=n-1;i>=0;--i)
    {
        p=new Node;                    //创建新结点
        p->data=a[i];                    //将元素存入结点
        
        p->next=head->next;            //将新加入结点指向头结点后面
        head->next=p;                //将头结点指向新加入的结点
    }
}

//第二种是尾插法
void CList::Create1(Data* a,int n)
{
    Node* p=NULL;
    Node* q=head;                    //创建中间结点指针
    for(int i=0;i<n;++i)
    {
        p=new Node;                    //创建储存元素的新结点
        p->data=a[i];                //将元素存入创建的结点
        p->next=q->next;            //插入到终端结点之后
        q->next=p;                    //终端结点指向新建结点
        q=p;                        //q指向新建结点
    }
    p->next=NULL;
}

//查找给定值的结点
Node* CList::Locate(Data e,int *i)
{
    *i=1;
    Node* p=head->next;
    
    while(p!=head)                        //p不为空
    {
        if(p->data==e)                //找到元素
            return p;
        else
        {
            p=p->next;
            ++(*i);
        }
    }
    cout<<"当前链表中无此元素"<<endl;
    exit(0);
    return NULL;
}

//清空单循环链表 
//保留表头结点，把链表中的
//其余所有结点全部释放。
void CList::Clear()
{
    Node* p=NULL;
    Node* q=NULL;
    p=head->next;
    while(p!=head)
    {
        q=p;
        p=p->next;
        delete q;
    }
    head->next = NULL;
}

//析构函数
//释放链表中的所有元素。
CList::~CList()
{
    Node* p;
    p=head;
    while(p!=head)
    {
        p=p->next;
        delete head;
        head=p;
    }
}

测试程序则放在main函数里：

int main()
{
    int i=0;
    Data e;
    int a[8]={2,4,6,8,5,1,7,9};
    
    CList list;                    //创建链表类
    list.IsEmpty();                    //判断链表是否为空
    list.Create(a,8);                //将数据插入
    list.Print();                    //显示
    cout<<"链表长度："<<list.Size()<<endl;
    
    cout<<"输入要插入的元素和位置：";
    cin>>e>>i;
    list.Insert(e,i);                //插入数据
    list.Print();
    cout<<"当前链表长度为"<<list.Size()<<endl<<endl;
        
    cout<<"输入要查找的元素值：";
    cin>>e;
    list.Locate(e,&i);                    //查找某元素
    cout<<"这是第"<<i<<"个元素"<<endl<<endl;
    
    list.IsEmpty();                    //判断链表是否为空
    
    cout<<"输入要查找的元素位置：";
    cin>>i;
    e=list.GetElem(i);                    //查找第i个位置的元素
    cout<<"这个元素值为："<<e<<endl<<endl;
    
    list.IsEmpty();                    //判断链表是否为空
    
    cout<<"输入要删除的元素位置：";
    cin>>i;
    e=list.Delete(i);                    //删除第i个位置的元素
    cout<<"这个元素值为："<<e<<endl;
    list.Print();
    cout<<"当前链表长度为"<<list.Size()<<endl<<endl;
    
    cout<<"输入要删除的元素位置：";
    cin>>i;
    e=list.Delete(i);                    //删除第i个位置的元素
    cout<<"这个元素值为："<<e<<endl;
    list.Print();
    cout<<"当前链表长度为"<<list.Size()<<endl<<endl;
    
    list.Clear();
    list.IsEmpty();                    //判断链表是否为空
    
    return 0;
}

测试情况如下：

到此，线性表的几种基本实现已经结束了，下方可查看几种线性表的具体实现：

1.顺序存储：http://www.cnblogs.com/tenjl-exv/p/7469316.html

2.单链表：http://www.cnblogs.com/tenjl-exv/p/7470075.html

3.双向链表：http://www.cnblogs.com/tenjl-exv/p/7475518.html

这里说一下循环链表的优点：

① 从表中任意结点出发均可访问到表中其他结点，这使得某些操作在循环链表上容易实现。

② 插入删除操作中不需区分尾节点还是中间结点，以使操作简化