双向循环链表C++实现

仅供参考

#include <iostream>
using namespace std;

// 函数结果状态代码
#define TRUE    1
#define FALSE   0
#define OK      1
#define ERROR   0
#define INFEASIBLE -1
#define OVERFLOW   -2
#define MAXSIZE    100

// Status 是函数的类型 其值是函数结果状态代码
typedef int Status;

typedef int ElemType;

typedef struct _tag_DoubleCirListNode{
    ElemType data;          // 数据域
    struct _tag_DoubleCirListNode *prior, *next;  // 指针域
}DuCirListNode, *DuCirLinkList;

// 双向循环链表的初始化
Status InitDuCirList(DuCirLinkList &L);

// 判断链表是否为空
int DuCirListEmpty(DuCirLinkList L);

// 双向循环链表的销毁，销毁后不存在
Status DestroyDuCirList_L(DuCirLinkList &L);

// 清空链表：链表仍存在，但链表中无元素，成为空链表(头指针和头节点仍然存在)
// 算法思路：依次释放所有节点，并将头结点的指针域设置为空
Status ClearDuCirList(DuCirLinkList &L);

// 双向循环链表的表长
int DuCirListLength(DuCirLinkList L);     // 返回Ｌ中数据元素个数

// 获取线性表Ｌ中的某个数据元素的内容，通过变量e返回
Status GetElem_L(DuCirLinkList L, int i, ElemType &e);

// 在线性表Ｌ中查找值为e的数据元素
// 找到，则返回Ｌ中值为e的数据元素的地址，查找失败返回ＮＵＬＬ；
DuCirListNode* LocateElem_address(DuCirLinkList L, ElemType e);

// 在线性表Ｌ中按照值为e的数据元素的位置序号
// 返回Ｌ中值为e的数据元素的序号，查找失败返回０；
int LocateElem_value(DuCirLinkList L, ElemType e);

// 在Ｌ中第i个元素之前插入数据元素e
Status DuCirLinkInsert_L(DuCirLinkList &L, int i, ElemType e);

// 将线性表Ｌ中第i个数据元素删除
Status CirListDelete_L(DuCirLinkList &L, int i, ElemType &e);

// 头插法  算法复杂度Ｏ(n)
void CreateDuCirList_H(DuCirLinkList &L, int n);

// 尾插法:正序输入Ｎ个元素值，建立带头结点的单链表  算法复杂度Ｏ(n)
void CreatDuCirList_R(DuCirLinkList &L, int n);

// 遍历链表
Status PrintCirList(DuCirLinkList L);

// 头插法测试代码
int main() {

    // 创建一个空链表
    DuCirLinkList L;
    // 初始化链表
    InitDuCirList(L);
    // 头插法
    //CreateDuCirList_H(L, 5);

    // 尾插法
    CreatDuCirList_R(L, 5);

    // 遍历链表
    PrintCirList(L);

    // 求线性表的长度
    int length = DuCirListLength(L);
    cout << "链表长度：" << length << endl;

    // 获取线性表第i个元素的值
    ElemType e;
    int i;
    cout << "查找第i个元素：";
    cin >> i;
    GetElem_L(L, i, e);
    cout << "第 " << i << " 个位置的值： " << e << endl;

    // 获取某个值的地址
    DuCirListNode *temp;
    cout << "想要获取值为e的地址:";
    cin >> e;
    temp = LocateElem_address(L, e);
    cout << "temp->data: "  << temp->data << endl;

    // 查找某个值的序号
    int index = 0;
    cout << "想要获取值为e的序号:";
    cin >> e;
    index =  LocateElem_value(L, e);
    cout << "值为 " << e << " 的序号: " << index << endl;

    // 插入元素
    cout << "在第几个位置插入元素：";
    cin >> i;
    cout << "插入的值为：";
    cin >> e;
    DuCirLinkInsert_L(L, i, e);
    length = DuCirListLength(L);
    cout << "链表长度：" << length << endl;
    // 遍历链表
    PrintCirList(L);

    // 删除元素
    cout << "在第几个位置删除元素：";
    cin >> i;
    int ret = CirListDelete_L(L, i, e);
    if (ret != OK){
        cout << "CirListDelete_L error!" << endl;
        return 0;
    }
    cout << "被删除的值为: " << e << endl;
    // 遍历链表
    PrintCirList(L);

    // 清空链表
    ClearDuCirList(L);
    // 是否为空
    DuCirListEmpty(L);
    // 销毁链表
    DestroyDuCirList_L(L);

    return 0;
}

// 双向循环链表的初始化
Status InitDuCirList(DuCirLinkList &L){
    L = new DuCirListNode;   // 生成新节点作头结点，用头指针Ｌ指向头结点
    L->next = L;  // 初始化时两个指针都指向其自身。
    L->prior = L;
    return OK;
}

// 判断链表是否为空
int DuCirListEmpty(DuCirLinkList L){
    if (L->next != L) {
        cout<<"链表非空";
        return FALSE;
    }
    else {
        cout << "链表为空";
        return TRUE;
    }

}

// 单链表的销毁，销毁后不存在
Status DestroyDuCirList_L(DuCirLinkList &L){
    DuCirListNode *p;
    while (L != L->next){          // Ｌ头结点非空
        p = L;          // 存储头结点的地址
        L = L->next;    // 头结点下移
        delete p;
    }
    return OK;
}

// 清空链表：链表仍存在，但链表中无元素，成为空链表(头指针和头节点仍然存在)
// 算法思路：依次释放所有节点，并将头结点的指针域设置为空
Status ClearDuCirList(DuCirLinkList &L){
    DuCirListNode *p, *q;    // 2个辅助指针
    p = L->next;        // ｐ指向第一个结点
    while (p != L){
        q = p->next;
        delete p;
        p = q;
    }
    L->next = L;
    return OK;
}

// 单链表的表长
int DuCirListLength(DuCirLinkList L){     // 返回Ｌ中数据元素个数
    DuCirListNode *p;
    int i = 0;
    p = L->next;           // p指向第一个结点
    while (p != L){              // 遍历单链表，统计结点数
        p = p->next;
        i++;
    }
    return i;
}

// 获取线性表Ｌ中的某个数据元素的内容，通过变量e返回
Status GetElem_L(DuCirLinkList L, int i, ElemType &e){
    DuCirListNode *p;
    p = L->next;
    int j = 1;
    while (p != L && j < i){

        p = p->next;
        j++;
    }
    if ( p == L || j > i) return ERROR;
    e = p->data;
    return OK;
}

// 在线性表Ｌ中查找值为e的数据元素
// 找到，则返回Ｌ中值为e的数据元素的地址，查找失败返回ＮＵＬＬ；
DuCirListNode* LocateElem_address(DuCirLinkList L, ElemType e){
    DuCirListNode *p;
    p = L->next;
    while ( p != L && p->data != e){
        p = p->next;
    }
    return p;
}

// 在线性表Ｌ中超照值为e的数据元素的位置序号
// 返回Ｌ中值为e的数据元素的序号，查找失败返回０；
int LocateElem_value(DuCirLinkList L, ElemType e){

    DuCirListNode *p;
    p = L->next;
    int j = 1;
    while (p != L && p->data != e){
        p = p->next;
        j++;
    }
    if (p != L) return j;
    else return 0;
}

// 在Ｌ中第i个元素之前插入数据元素e
Status DuCirLinkInsert_L(DuCirLinkList &L, int i, ElemType e){

    DuCirListNode *p, *s;
    if (i<1 || i > DuCirListLength(L)){
        cout << "插入位置不和法！" << endl;
        return ERROR;
    }
    p = L;
    int j = 0;
    while (j < i){      // 寻找
        p = p->next;
        j++;
    }

    s = new DuCirListNode;
    s->data = e;
    s->prior = p->prior;    // 1
    p->prior->next = s;     // 2
    s->next = p;            // 3
    p->prior = s;           // 4
    return OK;
}

// 将双向循环链表Ｌ中第i个数据元素删除
Status CirListDelete_L(DuCirLinkList &L, int i, ElemType &e){

    if  (i < 1 || i > DuCirListLength(L)){
        cout << "删除位置不合法！" << endl;
        return ERROR;
    }
    DuCirListNode *p = L->next;
    int j = 0;
    while (p->next != L && j < i-1){         // 寻找第i个节点，并令p指向其前驱
        p = p->next;
        j++;
    }
    e = p->data;
    p->prior->next = p->next;
    p->next->prior = p->prior;
    delete p;                   // 释放删除节点的空间
    return OK;
}

// 头插法  算法复杂度Ｏ(n)
void CreateDuCirList_H(DuCirLinkList &L, int n){

    L = new DuCirListNode;
    L->next = L;  // 先建立一个带头节点的双向循环链表
    L->prior = L;
    L->data = 0;

    cout << "头插法：";
    for (int i = n; i > 0; --i) {
        auto *p = new DuCirListNode;     // 生成新结点
        cin >> p->data;             // 输入元素值

        // 当链表只有头节点
        if (L->next == L){

            L->next = p;
            p->prior = L;
            p->next = L;
            L->prior = p;
        } else{                     // 当链表内还有其他节点

            p->next = L->next;      // 将新节点的next域指向原链表中头节点后面的节点
            L->next->prior = p;     //然后将原头节点中后面节点prev域指向新节点
            p->prior = L;           //将新节点prev域指向头节点
            L->next = p;            //将头节点的next域指向新节点
        }

    }
}

// 尾插法:正序输入Ｎ个元素值，建立带头结点的单链表  算法复杂度Ｏ(n)
void CreatDuCirList_R(DuCirLinkList &L, int n){

    L = new DuCirListNode;
    L->next = L;  // 先建立一个带头节点的双向循环链表
    L->prior = L;
    L->data = 0;

    cout << "头插法：";
    for (int i = 0; i < n; i++) {
        auto *p = new DuCirListNode;     // 生成新结点
        cin >> p->data;             // 输入元素值

        // 当链表只有头节点
        if (L->next == L){

            L->next = p;
            p->prior = L;
            p->next = L;
            L->prior = p;
        } else{                 // 当链表内还有其他节点

            L->prior->next = p;
            p->prior = L->prior;
            L->prior = p;
            p->next = L;
        }

    }
}

// 遍历链表
Status PrintCirList(DuCirLinkList L){

    DuCirListNode *p = L->next;
    while (p != L){
        cout << p->data << " ";
        p = p->next;
    }
    cout << endl;
    return OK;
}

 业务测试：

尾插法：1 2 3 4 5
1 2 3 4 5 
链表长度：5
查找第i个元素：1
第 1 个位置的值： 1
想要获取值为e的地址:1
temp->data: 1
想要获取值为e的序号:1
值为 1 的序号: 1
在第几个位置插入元素：1
插入的值为：1
链表长度：6
1 1 2 3 4 5 
在第几个位置删除元素：1
被删除的值为: 1
1 2 3 4 5 
链表为空

 

头插法：1 2 3 4 5
5 4 3 2 1 
链表长度：5
查找第i个元素：1
第 1 个位置的值： 5
想要获取值为e的地址:1
temp->data: 1
想要获取值为e的序号:1
值为 1 的序号: 5
在第几个位置插入元素：1
插入的值为：1
链表长度：6
1 5 4 3 2 1 
在第几个位置删除元素：1
被删除的值为: 1
5 4 3 2 1 
链表为空

感谢青岛大学-王卓老师细心的讲解~！