循环链表简单介绍

已于 2022-05-31 23:06:42 修改
阅读量678 收藏
点赞数
分类专栏： 数据结构 文章标签： 链表 数据结构
于 2022-05-31 22:55:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_49567286/article/details/125074978
版权

循环链表

1、循环链表长什么样

1

​ 将单链表中终端结点的指针端自空指针改为指向头结点，就使整个单链表形成 个环，这种头尾相接的单链表称 单循环链表，简称循环链表

​ 如图，就是尾巴指向头结点

2、有什么用？

​ 当需要访问最后一个节点时，需要遍历整个单链表，有没有可能用 0(1) 的时间由链表指针访问到最后一个结点呢?当然可以。只需要在最后一个结点的指针域指向头结点就行，

​ 终端结点用尾指针 rear 示，则查找终端结点是 0(1)， 而开始结点其实就是 rear->next->next ，其时间复杂也为 0(1)

2

3、实现

3.1实现概览

#include <stdio.h>
#include <stdlib.h>

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

typedef struct Node
{
    int data;
    struct Node *next;
} Node, *LinkList;

int createListTail(LinkList *L, int n);
int listInsert(LinkList *L, int i, int e);
int listDelete(LinkList *L, int i, int *e);
int listLength(LinkList L);
void traverse(LinkList L);
LinkList mergeTwoList(LinkList *A, LinkList *B);

3.2尾插法创建循环链表

/* 尾插法创建n个结点的双向链表 */
int createListTail(LinkList *L, int n)
{
    LinkList p, q;
    (*L) = (LinkList)malloc(sizeof(Node));
    p = (*L);
    for (int i = 1; i <= n; i++)
    {
        q = (LinkList)malloc(sizeof(Node));
        q->data = i;
        p->next = q;
        p = q;
    }

    p->next = (*L);//尾结点的指针域指向了头结点(*L是头结点，L存放*L的地址，是头指针)
    return OK;
}

3.3插入元素

/* 双向链表插入, 在第i个结点 前 插入元素值为e的结点 */
int listInsert(LinkList *L, int i, int e)
{
    LinkList p = (*L), q;
    int j = 1;
    while (p && j < i)
    {
        p = p->next;
        j++;
    }

    if (!p || j > i)
        return ERROR;
    q = (LinkList)malloc(sizeof(Node));
    q->data = e;
    q->next = p->next;
    p->next = q;

    return OK;
}

3.4删除元素

/* 双向链表删除第i个位置的结点，并用e返回删除的结点值 */
int listDelete(LinkList *L, int i, int *e)
{
    LinkList p = (*L), temp;
    int j = 1;
    while ((p->next) && j < i)
    {
        p = p->next;
        j++;
    }

    if (!(p->next) || j > i)
        return ERROR;

    temp = p->next; // temp存放待删除的结点
    p->next = temp->next;
    *e = temp->data;
    free(temp);

    return OK;
}

注意：这里的插入删除都和单链表一样

3.5合并两个循环链表

引用的是大话数据结构的图

3

/* 以A为头结点，将两个双向链表A B合并，返回合并后的双向链表A */
LinkList mergeTwoList(LinkList *A, LinkList *B)
{
    LinkList p = (*A)->next, tailA, tailB;
    //找到A链表的最后一个结点
    while (p->next != *A) //p->next != *A,当p->next == *A时， 说明此时p结点是最后一个结点
        p = p->next;
    tailA = p;// 保存A的尾结点

    p = (*B)->next;
    while (p->next != *B)
        p = p->next;
    tailB = p;// 保存B的尾结点

    LinkList headA, headB;
    headA = tailA->next; // 1，保存A的头结点
    headB = tailB->next; // 1，保存B的头结点

    tailA->next = headB->next; // 2, A的尾结点的指针域，指向了B的第一个的结点
    tailB->next = headA;       // 3， B的尾结点的指针域，指向了A的头结点

    return headA;//返回合并后的双向链表
}

3.6求循环链表的长度

/* 返回双向链表长度 */
int listLength(LinkList L)
{
    LinkList p = L->next;
    int k = 0;
    while (p)
    {
        k++;
        p = p->next;
    }

    return k;
}

3.7遍历双向链表

/* 遍历双向链表 */
void traverse(LinkList L)
{
    LinkList p = L->next;
    while (p != L)//为什么不是p->next != L?，p == L时，说明不满足条件，此时p是最后一个结点
    {
        printf("%d ", p->data);//先打印数据第一个结点的数据，所以放在p = p->next;前面
        p = p->next;
    }
}

4.完整代码

#include <stdio.h>
#include <stdlib.h>

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

typedef struct Node
{
    int data;
    struct Node *next;
} Node, *LinkList;

int createListTail(LinkList *L, int n);
int listInsert(LinkList *L, int i, int e);
int listDelete(LinkList *L, int i, int *e);
int listLength(LinkList L);
void traverse(LinkList L);
LinkList mergeTwoList(LinkList *A, LinkList *B);

/* 尾插法创建n个结点的双向链表 */
int createListTail(LinkList *L, int n)
{
    LinkList p, q;
    (*L) = (LinkList)malloc(sizeof(Node));
    p = (*L);
    for (int i = 1; i <= n; i++)
    {
        q = (LinkList)malloc(sizeof(Node));
        q->data = i;
        p->next = q;
        p = q;
    }

    p->next = (*L);//尾结点的指针域指向了头结点(*L是头结点，L存放*L的地址，是头指针)
    return OK;
}

/* 双向链表插入, 在第i个结点 前 插入元素值为e的结点 */
int listInsert(LinkList *L, int i, int e)
{
    LinkList p = (*L), q;
    int j = 1;
    while (p && j < i)
    {
        p = p->next;
        j++;
    }

    if (!p || j > i)
        return ERROR;
    q = (LinkList)malloc(sizeof(Node));
    q->data = e;
    q->next = p->next;
    p->next = q;

    return OK;
}

/* 双向链表删除第i个位置的结点，并用e返回删除的结点值 */
int listDelete(LinkList *L, int i, int *e)
{
    LinkList p = (*L), temp;
    int j = 1;
    while ((p->next) && j < i)
    {
        p = p->next;
        j++;
    }

    if (!(p->next) || j > i)
        return ERROR;

    temp = p->next; // temp存放待删除的结点
    p->next = temp->next;
    *e = temp->data;
    free(temp);

    return OK;
}

/* 以A为头结点，将两个双向链表A B合并，返回合并后的双向链表A */
LinkList mergeTwoList(LinkList *A, LinkList *B)
{
    LinkList p = (*A)->next, tailA, tailB;
    //找到A链表的最后一个结点
    while (p->next != *A) //p->next != *A,当p->next == *A时， 说明此时p结点是最后一个结点
        p = p->next;
    tailA = p;// 保存A的尾结点

    p = (*B)->next;
    while (p->next != *B)
        p = p->next;
    tailB = p;// 保存B的尾结点

    LinkList headA, headB;
    headA = tailA->next; // 1，保存A的头结点
    headB = tailB->next; // 1，保存B的头结点

    tailA->next = headB->next; // 2, A的尾结点的指针域，指向了B的第一个的结点
    tailB->next = headA;       // 3， B的尾结点的指针域，指向了A的头结点

    return headA;//返回合并后的双向链表
}

/* 返回双向链表长度 */
int listLength(LinkList L)
{
    LinkList p = L->next;
    int k = 0;
    while (p)
    {
        k++;
        p = p->next;
    }

    return k;
}

/* 遍历双向链表 */
void traverse(LinkList L)
{
    LinkList p = L->next;
    while (p != L)//为什么不是p->next != L?，p == L时，说明不满足条件，此时p是最后一个结点
    {
        printf("%d ", p->data);//先打印数据第一个结点的数据，所以放在p = p->next;前面
        p = p->next;
    }
}

int main()
{
    // LinkList L;
    // int e;
    // createListTail(&L, 5);
    // traverse(L);

    // // printf("\n");
    // // listInsert(&L, 6, 22);
    // // traverse(L);

    // printf("\n");
    // listDelete(&L, 5, &e);
    // traverse(L);

    LinkList A, B;
    createListTail(&A, 2);
    createListTail(&B, 2);

    LinkList mergeList = mergeTwoList(&A, &B);
    traverse(mergeList);


    // LinkList A, B;
    // createListTail(&A, 2);
    // traverse(A);

    return 0;
}

/ // traverse(L);

// printf("\n");
// listDelete(&L, 5, &e);
// traverse(L);

LinkList A, B;
createListTail(&A, 2);
createListTail(&B, 2);

LinkList mergeList = mergeTwoList(&A, &B);
traverse(mergeList);


// LinkList A, B;
// createListTail(&A, 2);
// traverse(A);

return 0;

}
小飞侠(NO.1)
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构入门】带头双向循环链表（List）详解（定义、增、删、查、改） | 配有大量图解，超详细哦~
codewinter的博客
09-10 2096
文章目录（1）前言（2）带头双向循环链表的实现1）双向链表的定义2）双向链表的初始化3）双向链表的销毁4）打印双向链表5）双向链表的尾插6）双向链表的尾删7）双向链表的头插8）双向链表的头删9）查找双向链表中的元素10）在指定pos位置之前插入元素11）删除指定pos位置的元素12）双向链表的判空13）获取双向链表的元素个数 学习双向链表之前，建议先学习下顺序表和单链表，配合这两篇文章食用更佳哦： 【数据结构入门】顺序表（SeqList）详解（初始化、增、删、查、改） 【数据结构入门】无头单向非循环链表（S
循环链表
lzjsqn的专栏
10-30 883
循环链表循环链表 基本概念 设计与实现 代码实现 优缺点 约瑟夫问题-循环链表典型应用1.基本概念循环链表的定义： 　　将单链表中最后一个数据元素（也去节点）的next指针指向第一个元素 　　 循环链表拥有单链表的所有操作 创建链表 销毁链表 获取链表长度 清空链表 获取第pos个元素操作 插入元素到位置pos 删除位置pos处的元素 新增功能：游标的定
c语言简单循环链表
04-22
#include #include int main(void) { //线性表在计算机中的存储结构是连续的 //以下是两种建立线性表的方式,可能还有更多方法 int lineTable[10]; int *ptrlineTable = (int *) malloc (sizeof(int));...
单向循环链表
01-20
实际上，循环链表也很简单。它跟单链表唯一的区别就在尾结点。我们知道，单链表的尾结点指针指向空地址，表示这就是最后的结点了。而循环链表的尾结点指针是指向链表的头结点。从我画的循环链表图中，你应该可以看...
PHP简单实现循环链表功能示例
10-19
在循环链表中，最后一个节点的指针指向链表的头节点，从而形成一个环状结构，使得在遍历到链表尾部时，还能继续回到链表的头部，继续遍历。 在PHP中实现循环链表，需要定义节点类和循环链表类。节点类包含两个属性...
C语言循环链表的简单应用
07-25
本文介绍了一个简单的循环链表的应用实例，包括如何在指定位置插入和删除节点。通过具体的代码示例，展示了如何实现这些基本操作，并通过输入验证等手段提高了程序的安全性和稳定性。对于学习C语言和数据结构的初学...
C语言实现循环链表
12-17
3、循环链表的优势在于双链表合并，以及实现尾插法简单（首先新建结点指向头结点，然后把尾指针的next域指向该新建结点） 4、在创建链表时，使用尾插法，而不是用头插法（因为头插法很难去更新尾指针，使得最后尾...
数据结构讲解：循环链表与双向链表操作
"循环链表和双向链表的讲解，包括它们的定义、操作以及线性表的应用示例。" 在数据结构与算法的学习中，循环链表和双向链表是两种重要的链式存储结构，它们扩展了单链表的功能，为数据操作提供了更多的便利。 5.1 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值