链表（单向链表、双向链表、循环链表）

于 2024-09-12 23:12:16 发布
阅读量435 收藏 4
点赞数 5
文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2303_82176667/article/details/142188059
版权

文章目录


本文将详细展示单向链表、双向链表、循环链表的构造以及最基本的增删改查。

1.单向链表

1.1单链表的定义

单向链表的每个节点包含一个数据字段和一个指向下一个节点的指针。

typedef int ElemType;  // 定义元素类型为int  
  
typedef struct LNode {  
    ElemType data;  // 节点存储数据
    struct LNode *next;        // 指向下一个节点的指针  
} LNode, *LinkList;          // 定义LNode结构体和LinkList指针类型

这是一个定义链表的数据结构。链表的节点 LNode 包含两个部分：一个用于存储数据的数组 data[Max_Size]，以及一个指向下一个节点的指针 next。

1.2 链表的初始化与销毁

链表的初始化

 //链表的初始化  
void InitList(LinkList L) {  
	L = (LinkList) malloc(sizeof(LinkList));  
    //next结点置空  
    L->next = NULL;  
}

InitList 函数现在接受一个指向链表头指针的指针，分配内存，并初始化 next 指针将其置空。
销毁链表

void DestroyList(LinkList L) {  
    LinkList p;  
    LinkList q;  
  
    p = L; // p 指向头结点  
    while (p != NULL) {  
        q = p;  
        p = p->next; // 移动 p 到下一个节点  
        free(q); // 释放当前节点 q 的内存  
    }  
    L = NULL; // 将头指针设置为 NULL}

1.3链表的其创建

头插法

//头插法创建链表  
void CreateListF(LinkList L,ElemType e[],int n) {  
    LinkList s;  
    for (int i = 0; i < n; ++i) {  
        s = (LinkList)malloc(sizeof(LNode));  
        s->data = e[i];  
        s->next = L->next;  
        L->next = s;  
    }  
}

尾插法

// 尾插法创建链表  
void CreateListR(LinkList L, ElemType e[], int n) {  
    LinkList s, r;  
    r = L; // 初始化r指针指向头结点  
    for (int i = 0; i < n; ++i) {  
        s = (LinkList)malloc(sizeof(LNode)); // 为新节点分配内存  
        s->data = e[i]; // 将数据赋值给新节点  
        s->next = NULL; // 新节点的next指针初始化为NULL  
        r->next = s; // 将新节点链接到链表的尾部  
        r = s; // 更新r指针到新的尾部节点  
    }  
}

1.4链表的插入

//在第i个位置插入元素e  
void Insert(LinkList L,int i,ElemType e) {  
    int j = 0;  
    LinkList s = (LinkList)malloc(sizeof(LNode));  
    LinkList p = L;  
  
    //遍历链表  
    while (j < i - 1 && p != NULL) {  
        p = p->next;  
        j++;  
    }  
    //执行插入操作  
    s->data = e;  
    s->next = p->next;  
    p->next = s;  
}

1.5链表的删除

//删除第i个位置的元素  
void Delete(LinkList L,int i) {  
    int j = 0;  
    LinkList p = L;  
    LinkList q = NULL;  
  
    //遍历链表  
    while (j < i - 1 && p != NULL) {  
        p = p->next;  
        j++;  
    }  
     q = p->next ;  
    p->next = q->next;  
    free(q);  
}

1.6链表的查找

//查找第i个位置的元素  
ElemType Find(LinkList L,int i) {  
    int j = 0;  
    LinkList p = L;  
  
    //遍历链表  
    while (j < i - 1 && p != NULL) {  
        p = p->next;  
        j++;  
    }  
    if(p == NULL) {  
        return -1;  
    }  
    return p->data;  
}

2. 双向链表

双向链表的每个节点包含三个部分：一个用于存储数据的 data，一个指向前一个节点的指针 prev，以及一个指向后一个节点的指针 next。

2.1 双向链表的定义

typedef int ElemType;  // 定义元素类型为int  
  
typedef struct DNode {  
    ElemType data;     // 节点存储数据
    struct DNode *prev;  // 指向前一个节点的指针
    struct DNode *next;  // 指向下一个节点的指针
} DNode, *DLinkList;    // 定义DNode结构体和DLinkList指针类型

2.2 链表的初始化与销毁

双向链表的初始化

// 双向链表的初始化  
void InitDList(DLinkList L) {  
    L = (DLinkList) malloc(sizeof(DLinkList));  
    L->prev = NULL;  // prev指针置空
    L->next = NULL;  // next指针置空
}

销毁双向链表

void DestroyDList(DLinkList L) {  
    DLinkList p = L;  
    DLinkList q;  
    while (p != NULL) {  
        q = p;  
        p = p->next;  
        free(q);  
    }  
    L = NULL;  
}

2.3 双向链表的创建

头插法

// 头插法创建双向链表  
void CreateDListF(DLinkList L, ElemType e[], int n) {  
    DLinkList s;  
    for (int i = 0; i < n; ++i) {  
        s = (DLinkList)malloc(sizeof(DNode));  
        s->data = e[i];  
        s->next = L->next;  
        s->prev = L;  
        if (L->next != NULL) {  
            L->next->prev = s;  
        }  
        L->next = s;  
    }  
}

尾插法

// 尾插法创建双向链表  
void CreateDListR(DLinkList L, ElemType e[], int n) {  
    DLinkList s, r;  
    r = L; // r指向尾部节点
    while (r->next != NULL) {  
        r = r->next;  
    }  
    for (int i = 0; i < n; ++i) {  
        s = (DLinkList)malloc(sizeof(DNode));  
        s->data = e[i];  
        s->next = NULL;  
        s->prev = r;  
        r->next = s;  
        r = s;  
    }  
}

2.4 双向链表的插入

// 在第i个位置插入元素e
void InsertDList(DLinkList L, int i, ElemType e) {  
    int j = 0;  
    DLinkList p = L;  
    DLinkList s = (DLinkList)malloc(sizeof(DNode));  
  
    while (j < i - 1 && p != NULL) {  
        p = p->next;  
        j++;  
    }  
  
    s->data = e;  
    s->next = p->next;  
    if (p->next != NULL) {  
        p->next->prev = s;  
    }  
    s->prev = p;  
    p->next = s;  
}

2.5 双向链表的删除

// 删除第i个位置的元素
void DeleteDList(DLinkList L, int i) {  
    int j = 0;  
    DLinkList p = L;  
  
    while (j < i - 1 && p != NULL) {  
        p = p->next;  
        j++;  
    }  
  
    DLinkList q = p->next;  
    if (q != NULL) {  
        p->next = q->next;  
        if (q->next != NULL) {  
            q->next->prev = p;  
        }  
        free(q);  
    }  
}

2.6 双向链表的查找

// 查找第i个位置的元素
ElemType FindDList(DLinkList L, int i) {  
    int j = 0;  
    DLinkList p = L;  
  
    while (j < i - 1 && p != NULL) {  
        p = p->next;  
        j++;  
    }  
  
    if (p == NULL) {  
        return -1;  
    }  
  
    return p->data;  
}

3. 循环链表

循环链表与单链表的区别在于其尾节点的 next 指针指向链表的头节点，使得整个链表形成一个环。

3.1 循环链表的定义

typedef int ElemType;  // 定义元素类型为int  
  
typedef struct CNode {  
    ElemType data;     // 节点存储数据
    struct CNode *next;  // 指向下一个节点的指针
} CNode, *CLinkList;   // 定义CNode结构体和CLinkList指针类型

3.2 循环链表的初始化与销毁

循环链表的初始化

// 循环链表的初始化
void InitCList(CLinkList L) {  
    L = (CLinkList) malloc(sizeof(CLinkList));  
    L->next = L;  // 循环链表的next指针指向自己
}

销毁循环链表

void DestroyCList(CLinkList L) {  
    CLinkList p = L->next;  
    CLinkList q;  
    while (p != L) {  
        q = p;  
        p = p->next;  
        free(q);  
    }  
    free(L);  
}

3.3 循环链表的创建

头插法

// 头插法创建循环链表
void CreateCListF(CLinkList L, ElemType e[], int n) {  
    CLinkList s;  
    for (int i = 0; i < n; ++i) {  
        s = (CLinkList)malloc(sizeof(CNode));  
        s->data = e[i];  
        s->next = L->next;  
        L->next = s;  
    }  
    s->next = L;  // 形成循环
}

尾插法

// 尾插法创建循环链表
void CreateCListR(CLinkList L, ElemType e[], int n) {  
    CLinkList s, r;  
    r = L;  
    while (r->next != L) {  
        r = r->next  
    }  
    for (int i = 0; i < n; ++i) {  
        s = (CLinkList)malloc(sizeof(CNode));  
        s->data = e[i];  
        s->next = L;  // 新节点的next指向头节点，形成环
        r->next = s;  
        r = s;  
    }  
}

3.4 循环链表的插入

// 在第i个位置插入元素e
void InsertCList(CLinkList L, int i, ElemType e) {  
    int j = 0;  
    CLinkList p = L;  
    CLinkList s = (CLinkList)malloc(sizeof(CNode));  
  
    while (j < i - 1 && p->next != L) {  
        p = p->next;  
        j++;  
    }  
  
    s->data = e;  
    snext = p->next;  
    p->next = s;  
}

3.5 循环链表的删除

// 删除第i个位置的元素
void DeleteCList(CLinkList L, int i) {  
    int j = 0;  
    CLinkList p = L;  
  
    while (j < i - 1 && p->next != L)  
        p = p->next;  
        j++;  
    }  
  
    CLinkList q = p->next;  
    if (q != L) {  
        p->next = q->next;  
        free(q);  
    }  
}

3.6 循环链表的查找

// 查找第i位置的元素
ElemType FindCList(CLinkList L, int i) {  
    int j = 0;  
    CLinkList p = L->next;  
  
    while (j < i - 1 && p != L) {  
        p = p->next;  
        j++;  
    }  
  
    if (p == L) {  
        return -1;  
    }  
  
    return p->data;  
}

以上是链表的一些基本操作，原版代码上传至(https://gitee.com/shi-chengfu)

如果有错误请联系QQ:303613518

写代码的大学生
关注
单向循环列表（题）
weixin_45276189的博客
12-16 3740
A约瑟夫环问题： 据说著名犹太历史学家Josephus有过一下的故事： 在罗马人占领乔塔帕特后，39个犹太人与Josephus及他的朋友躲在一个洞中，39个犹太人决定宁愿死也不要被敌人抓到，于是决定了一个自杀方式，41个人排成一个圆圈，由第1个人开始报数，每报数到第3个人该人必须自杀，然后再由下一个重新报数，直到所有人都自杀身亡为止。 然而Josephus和他的朋友并不想遵从，Josephus要他...
数据结构——单向循环链表&双向循环链表
qq_56668869的博客
08-24 3248
数据结构、单向循环链表、程序实现单向循环链表、方法操作示例、双向循环链表、程序实现双向循环链表
一步一步写算法（之循环单向链表）
热门推荐
嵌入式-老费，一个分享专业嵌入式知识的blog
10-08 2万+
【 声明：版权所有，欢迎转载，请勿用于商业用途。  联系信箱：feixiaoxing @163.com】     前面的博客中，我们曾经有一篇专门讲到单向链表的内容。那么今天讨论的链表和上次讨论的链表有什么不同呢？重点就在这个"循环"上面。有了循环，意味着我们可以从任何一个链表节点开始工作，可以把root定在任何链表节点上面，可以从任意一个链表节点访问数据，这就是循环的优势。
常见的链表——单向链表&双向链表&循环链表
前者已逝，后者未至。
10-05 485
目标 熟悉单向链表的数据结构，包括增删改查操作； 用代码实现单向链表。 单向链表的数据结构示意图 代码实现 package com.ctx; import java.util.LinkedList; import java.util.NoSuchElementException; /** * 实现单向链表 */ public class UnidirectionalLinkedList<T> { //集合的大小 private int size = 0;..
数据结构单向链表、单向循环链表、双向链表、双向循环链表操作
最新发布
weixin_62318298的博客
07-24 362
本文对单向链表，单向循环链表，双向链表，双向循环链表进行了完整操作
单向循环链表
qq_45772965的博客
01-27 847
单向循环链表   单向循环链表和单向非环形链表的区就是，单向非环形链表的尾结点的指针是指向null的，而环形的是指向头结点。单向循环链表如图下所示： 节点类代码 class MyNode { int data; MyNode next; String name; public MyNode() { } public MyNode(int data) { this.data = data; } public MyNode(
单链表实现双向循环链表_链表_
09-29
单链表实现双向循环链表单向链表存在一个弊端就是，当需要获取某个结点p的前驱时，需要从头指针开始遍历链表，获得“前驱”的执行时间为O(n)，为了克服单向链表的这种缺点，可以利用双向链表。在双向链表中有两个...
Python单向链表和双向链表原理与用法实例详解
09-20
在Python中，我们可以自定义链表结构来实现单向链表和双向链表。 单向链表（Single Linked List）的特点是每个节点只包含一个指向下一个节点的引用。在单向链表中，遍历只能从头节点开始，按顺序访问每个节点，无法...
C语言中双向链表和双向循环链表详解
08-30
C语言中双向链表和双向循环链表详解 本文主要介绍了C语言中双向链表和双向循环链表的实现与操作，包括双向链表和双向循环链表的定义、初始化、插入操作、删除操作等。 一、双向链表和双向循环链表的定义 在C语言...
[循环链表]——单向循环链表
weixin_42067873的博客
02-24 5313
单向循环链表与普通链表的区别在于：普通链表的最后一个链表的next指向NULL，而单向循环链表的最后一个节点的next指向头结点
数据结构----链表（单链表，循环链表，双向表）
qq_38198286的博客
06-26 1180
文章目录一、基本概念二、单链表的基本操作1.初始化和判断空表2.销毁单链表3.清空单链表4.求单链表的表总结 一、基本概念 链表：用一组物理位置任意的存储单元来存放线性表的数据元素，逻辑次序和物理次序不一定相同。 结点=数据域+指针域。结点只有一个指针域为单链表，首尾相接为循环链表。 头指针指向链表第一个结点，存储第一个数据为首元结点，首元结点前可能附设头结点。 无头结点时，头指针为空则为空表；有头结点时，头结点的指针域为空则为空表。 头结点的优势：便于首元结点的处理，在链表的第一个位置的操作和其他位
循环单链表
theking121380的博客
09-24 2878
循环单链表的简单初始化
单向循环列表
qq_39088927的博客
10-23 1903
单向循环列表定义操作操作实现测试结果如图 定义 单链表的一个变形是单向循环链表，链表中最后一个节点的next域不再为None，而是指向链表的头节点。 操作 is_empty() 判断链表是否为空 length() 返回链表的长度 travel() 遍历 add(item) 在头部添加一个节点 append(item) 在尾部添加一个节点 insert(pos, item) 在指定位置pos添加...
C——(单向、单向循环、双向、双向循环)链表学习总结
C_Aya的博客
07-25 1万+
这段时间一边看书一边把链表的知识总结了一下，并且画了示意图来帮助理解。主要是单向链表，单向循环链表，双向链表，双向循环链表四个部分，每个部分都包括了初始化，创建，插入，删除的基本操作，并总结了各个操作的核心代码。抽空可以看看Linux内核自带的链表(list.h)写法，增进学习。以下的链表均是不操作头节点的。一、单向链表1.单向链表：链式的存储结构，在逻辑上是连续的，每次通过一个指针来指向下一个节点
数据结构之单向循环链表
jiangbazi的博客
09-05 3394
概述 单向循环链表里面的每一个节点的next都要有指向，最后一个节点的next指向head节点 单向循环链表跟普通的单链表的操作逻辑几乎—模一样，唯一的区别，结尾的判断，区别如下 建议学完单向非循环链表，再来对比 （本人先是在掘金上编辑的，然后复制粘贴自己的博客，所以图片都有掘金的水印，欢迎来我的掘金博客查看原文） 示例代码 //单向循环链表 #include <stdio.h> #include <stdbool.h> #include <stdlib.h> typ
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

写代码的大学生

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值