数据结构（06）— 线性循环链表实战

1. 循环链表定义

单链的循环链表结点的存储结构和单链表的存储结构一样, 所不同的是: 最后一个结点的 next 域指向头结点, 而不是“空”。这样, 由表尾很容易找到表头。

但若链表较长, 则由表头找到表尾较费时, 因而, 单循环链表往往设立尾指针而不是头指针, 如图 2 31所示。这在两个链表首尾相连合并成一个链表时非常方便。

2. 循环链表实现

2.1 创建单循环空链表

RingList::RingList()
{
    L = new LNode;  // 产生头结点,并使L指向此头结点
    L->next = L;    // 指针域指向头结点
    std::cout << "constructor done" << std::endl;
}

2. 销毁单循环链表

	LNode *q;
    LNode *p = L->next; // p指向头结点
    while (p != L)  // 没到表尾
    {
        q = p->next;
        delete p;
        p = q;
    }
    // 到达末尾, p == L
    delete p;
    p = NULL;

2.3 循环链表中插入元素

2.4 循环链表中删除元素

3. 代码清单

project.h

#include <iostream>
#include <string>

#define N (30)
#define K (9)
// 单链表中单个结点的完整数据结构定义
typedef struct LNode
{
   int data;       // 值域
   LNode *next;    // 指针域
}LNode;

class RingList
{
public:
   RingList();
   ~RingList();
   int init_ring_list();
   int clear_list();
   bool is_empty();
   int get_list_length();
   int get_element(int i, int &value);
   int insert_element(int i, int value);
   int delete_element(int i, int &value);
   int print_list();

private:
   LNode *L;
};

project.cpp

#include "project.h"

RingList::RingList()
{
    L = new LNode;  // 产生头结点,并使L指向此头结点
    L->next = L;    // 指针域指向头结点
    std::cout << "constructor done" << std::endl;
}

RingList::~RingList()
{
    LNode *q;
    LNode *p = L->next; // p指向头结点
    while (p != L)  // 没到表尾
    {
        q = p->next;
        delete p;
        p = q;
    }
    // 到达末尾, p == L
    delete p;
    p = NULL;
    std::cout << "destructor done" << std::endl;
}

int RingList::clear_list()
{
    L = L->next;    // L指向头结点
    LNode *q;
    LNode *p = L->next; // p指向第一个结点
    while (p != L)  // 没到表尾
    {
        q = p->next;
        delete p;
        p = q;
    }
    L->next = L;    // 头结点指针域指向自身
    std::cout << "destructor done" << std::endl;
    return 0;
}

bool RingList::is_empty()
{
    return L->next == L ? true : false;
}

int RingList::get_list_length() 
{
    int length = 0;
    LNode *p = L->next; // p指向头结点
    while (p != L)  // 没到表尾
    {
        length++;
        p = p->next;
    }
    return length;
}

int RingList::get_element(int i, int &value)
{
    if(i <= 0 || i > get_list_length())
    {
        std::cout << "i is not a valid value" << std::endl;
        return -1;
    }

    LNode *p = L->next; // p指向头结点
    for(int k=1; k<i; k++)  // 顺指针向后查找,直到p指向第i个元素
    {
        p = p->next;
    }
    value = p->data;
    return 0;
}

int RingList::insert_element(int i, int value)
{
    if(i<=0)
    {
        std::cout << "i is not a valid value" << std::endl;
        return -1;
    }

    LNode *p = L->next; // p指向头结点
    for(int k=1; k<i; k++)    // 寻找第i-1个结点
    {
        p = p->next;
    }
    LNode *q = new LNode;   // 生成新结点
    q->data = value;
    // 插入L中
    q->next = p->next;
    p->next = q;
    // 改变尾结点
    if(p == L)
    {
        L = q;
    }
    return 0;
}

int RingList::delete_element(int i, int &value)
{
    if(i<=0 || i > get_list_length())
    {
        std::cout << "i is not a valid value" << std::endl;
        return -1;
    }

    LNode *p = L->next; // p指向头结点
    for(int k=1; k<i; k++)    // 寻找第i-1个结点
    {
        p = p->next;
    }

    LNode *q;
    q = p->next;    // q指向待删除结点
    value = q->data;
    p->next = q->next;
    if(L == q)  // 删除的是表尾元素
    {
        L = p;
    }
    delete q;  // 释放待删除结点
    q = NULL;
    return 0;
}

int RingList::print_list()
{
    LNode *p = L->next->next; // p指向首元结点
    while (p != L->next)  // p不指向头结点
    {
        std::cout << "list element is " << p->data << std::endl;
        p = p->next;
    }
    return 0;
}

```main.cpp`

#include "project.cpp"

int main()
{
    RingList L;
    std::cout << "is empty: " << L.is_empty() << std::endl;
    L.insert_element(1, 10);
    L.insert_element(2, 20);
    L.insert_element(3, 30);
    L.print_list();
    std::cout << "list length: " << L.get_list_length() << std::endl;
    int value;
    L.get_element(3, value);
    std::cout << "第三个元素为: " << value << std::endl;

    int del_value;
    L.delete_element(2, del_value);
    std::cout << "删除的第二个元素为: " << del_value << std::endl;
}