数据结构——单向链表和双向链表的实现（C语言版）

目录

前言

1. 链表

1.1 链表的概念及结构

1.2 链表的分类

2. 单链表接口实现

2.1 数据结构设计与接口函数声明

2.2 创建结点，打印，查找

2.3 尾插，头插，尾删，头删

2.4 插入或删除

2.4.1在指定位置后

2.4.2在指定位置前

2.5 销毁链表

3. 双向带头循环链表

3.1 数据结构设计与接口函数声明

3.2 初始化，销毁，打印，动态创建结点

3.3 尾插，头插，尾删，头删

3.4 查找，插入和删除

4.链表和顺序表的区别

5. 源代码

5.1 单链表

（1）SList.h

（2）SList.c

（3）SLtest.c

5.2 双向链表

（1）Linked LIst.h

（2）Linked List.c

（3）Ltest.c

总结

前言

这篇文章关于链表的介绍，还有单向链表和双向链表的C语言实现，内容干货满满，建议边看边上手敲代码！

1. 链表

1.1 链表的概念及结构

概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。

 如下图所示：

注意：

  1. 从上图可看出，链式结构逻辑上是连续的，但在物理上不一定连续的，地址存放分布不均。
  2. 现实中的节点一般都是从堆上申请出来的。
  3. 从堆上申请的空间，是按照一定策略来分配的，两次申请的空间可能连续，也可能不连续。

1.2 链表的分类

实际中链表有这三种分法，单向或者双向，带头或不带头，循环或者非循环。

  1. 单向或双向
  2. 带头或者不带头
  3. 循环或者非循环

虽然有这么多的链表结构，但是我们实际中最常用还是两种结构：

  1. 无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。
  2.  带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了。

2. 单链表接口实现

在实现接口时，需要创建三个文件，分别是SList.h，SList.c和SLtest.c这三个文件，第一个是写入单链表数据结构设计和接口函数声明来串联三个文件，第二个是完成各个接口函数内部代码实现，第三个是来测试各个接口功能情况。

2.1 数据结构设计与接口函数声明

单链表结构体中有存储一个数据的变量，但与顺序表的不同之处，是使用指针联系着下一个结点，所以在创建个相同结构体的指针next。单链表只需要知道头结点的结构体指针就可以进行各种接口的实现，所以不用创建一个初始化接口，创建一个结构体指针就可以。

typedef int SLTDataType;typedef struct SListNode
{SLTDataType data;struct SListNode* next;
}SLTNode;//动态申请一个结点
SLTNode* BuyListNode(SLTDataType x);
//单链表打印
void SListPrint(SLTNode* phead);
//单链表尾插
void SListPushBack(SLTNode** pphead, SLTDataType x);
//单链表头插
void SListPushFront(SLTNode** pphead, SLTDataType x);
//单链表尾删
void SListPopBack(SLTNode** pphead);
//单链表头删
void SListPopFront(SLTNode** pphead);
//单链表查找
SLTNode* SListFind(SLTNode* phead, SLTDataType x);
//在pos位置之前去插入一个节点
void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);
// 在pos位置后面插入
void SListInsertAfter(SLTNode* pos, SLTDataType x);
//删除pos位置的节点
void SListErase(SLTNode** pphead, SLTNode* pos);
//删除pos位置后一个节点
void SListEraseAfter(SLTNode** pphead, SLTNode* pos);
//单链表销毁
void SListDestory(SLTNode** pphead);

2.2 创建结点，打印，查找

 创建新结点是为了后面接口实现做准备。

SLTNode* BuyListNode(SLTDataType x)
{   //动态申请新结点SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));if (newnode == NULL){   //可能开辟内存失败，加上判断，增强代码的健壮性printf("malloc fail\n");exit(-1);}newnode->data = x;newnode->next = NULL;return newnode;
}

打印链表中的内容，用的是while循环，判断条件是cur指针不为空。

void SListPrint(SLTNode* phead)
{SLTNode* cur = phead;while (cur != NULL){printf("%d->", cur->data);cur = cur->next;}printf("NULL\n");
}

assert是断言，判断phead是否为空结点，用while循环遍历整个链表。

SListNode* SListFind(SLTNode* phead, SLTDataType x)
{assert(phead);SLTNode* cur = phead;while (cur){if (cur->data == x){return cur;}else{cur = cur->next;}}return NULL;
}

2.3 尾插，头插，尾删，头删

因为只需要知道指向头结点的指针变量，就可以进行操作，但是第一次我们创建的头结点为空指针，尾插的时候如果传入一级指针在尾插函数内部修改头节点的值，无法影响头结点，因为尾插函数内的头结点的一份临时拷贝，即形参，改变形参的值是无法影响实参的值，所以要传入二级指针，通过指针变量的指针修改一级指针的值。故之后关于头结点的删除或者插入，都需要传二级指针，这是链表实现中较难理解的点。

void SListPushBack(SLTNode** pphead, SLTDataType x)
{assert(pphead);SLTNode* newnode = BuyListNode(x);//头结点为空时，直接赋值if (*pphead == NULL){*pphead = newnode;}else{//找到尾节点SLTNode* tail = *pphead;while (tail->next != NULL){tail = tail->next;}tail->next = newnode;}
}

我们写一个测试函数，测试一下尾插函数的功能。之后的测试函数，只写全局函数Test，不展示main函数的部分。

#include "SLinked list.h"void TestSlist1()
{SLTNode* plist = NULL;SListPushBack(&plist, 1);SListPushBack(&plist, 2);SListPushBack(&plist, 3);SListPushBack(&plist, 4);SListPrint(plist);
}int main()
{TestSlist1();return 0;
}

输出结果：

头插较为简单，只需要创建一个新结点，新结点的next指针指向头结点，再把头结点指向新结点。

void SListPushFront(SLTNode** pphead, SLTDataType x)
{assert(pphead);SLTNode* newnode = BuyListNode(x);newnode->next = *pphead;*pphead = newnode;
}

再写一个测试函数：

void TestSlist2()
{SLTNode* plist = NULL;SListPushFront(&plist, 1);SListPushFront(&plist, 2);SListPushFront(&plist, 3);SListPushFront(&plist, 4);SListPrint(plist);
}

输出的结果：

尾删要分情况，分为链表内有一个节点还是两个结点及以上。如果链表内只有一个结点直接释放头结点，并将其置为空指针，如果是两个节点及以上，需要找到尾结点的位置，用while循环遍历链表，新建一个tail指针，当tail的next指针为空时，便找到尾结点，然后进行释放操作。

void SListPopBack(SLTNode** pphead)
{assert(pphead);assert(*pphead != NULL);if ((*pphead)->next == NULL){//1. 一个节点free(*pphead);*pphead = NULL;}else{	//2. 两个及以上的节点SLTNode* tail = *pphead;while (tail->next->next){tail = tail->next;}free(tail->next);tail->next = NULL;}
}

在之前Test1函数上稍加改动：

void TestSlist1()
{SLTNode* plist = NULL;SListPushBack(&plist, 1);SListPushBack(&plist, 2);SListPushBack(&plist, 3);SListPushBack(&plist, 4);SListPrint(plist);SListPopBack(&plist);SListPopBack(&plist);SListPopBack(&plist);SListPrint(plist);
}

输出的结果：

但是如果你调用尾删次数超过链表存储数据个数，就会报错。所以调用尾删函数需注意。

头删函数只需在创建一个next指针，并赋值为头结点的下一个结点，释放头结点，再赋值。

void SListPopFront(SLTNode** pphead)
{assert(pphead);assert(*pphead != NULL);SLTNode* next = (*pphead)->next;free(*pphead);*pphead = next;
}

同理，这次在Test2函数上进行改动即可。

void TestSlist2()
{SLTNode* plist = NULL;SListPushFront(&plist, 1);SListPushFront(&plist, 2);SListPushFront(&plist, 3);SListPushFront(&plist, 4);SListPrint(plist);SListPopFront(&plist);SListPopFront(&plist);SListPopFront(&plist);SListPopFront(&plist);SListPrint(plist);
}

输出的结果：

2.4 插入或删除

一般是在指定位置后插入或删除，这是因为单链表的结点只有下一个结点的地址，如果想要在指定位置之前插入，需要从头结点开始遍历，消耗时间。

2.4.1在指定位置后

插入操作：

// 在pos位置后面插入,这个更适合单链表
void SListInsertAfter(SLTNode* pos, SLTDataType x)
{assert(pos);SLTNode* newnode = BuyListNode(x);if (newnode == NULL){return;}newnode->next = pos->next;pos->next = newnode;
}

删除操作：

void SListEraseAfter(SLTNode** pphead, SLTNode* pos)
{assert(pphead);assert(pos->next);SLTNode* next = pos->next;pos->next = next->next;free(next);
}

写个测试函数，先通过查找函数，获得想要结点的地址，再修改。

void TestSlist3()
{SLTNode* plist = NULL;SListPushFront(&plist, 1);SListPushFront(&plist, 2);SListPushFront(&plist, 3);SListPushFront(&plist, 4);SListPrint(plist);SLTNode* pos = SListFind(plist, 2);if (pos){SListInsertAfter(pos, 30);}SListPrint(plist);pos = SListFind(plist, 30);if (pos){SListEraseAfter(&plist, pos);}SListPrint(plist);
}

输出的结果：

2.4.2在指定位置前

在进行插入操作之前，应该先判断该位置是否为头结点，如果是头结点，直接头插；如果不是，需要遍历链表找到该位置结点的前一个节点，再插入。

void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{assert(pphead);SLTNode* newnode = BuyListNode(x);if (*pphead == pos){newnode->next = *pphead;*pphead = newnode;}else{// 找到pos的前一个位置SLTNode* posPrev = *pphead;while (posPrev->next != pos){posPrev = posPrev->next;}posPrev->next = newnode;newnode->next = pos;}
}

删除也是一样，需要区分该位置是否为头结点，不是的话需要先找到该位置前一个节点，再删除。

void SListErase(SLTNode** pphead, SLTNode* pos)
{assert(pphead);assert(pos);//删除头节点if (*pphead == pos){*pphead = pos->next;free(pos);//要不要把pos置为空指针呢pos = NULL;}else{	//找前一个节点SLTNode* posPrev = *pphead;while (posPrev->next != pos){posPrev = posPrev->next;}//开始删除posPrev->next = pos->next;free(pos);pos = NULL;}
}

再写一个测试函数，与前一个测试函数类似。

void TestSlist4()
{SLTNode* plist = NULL;SListPushFront(&plist, 1);SListPushFront(&plist, 2);SListPushFront(&plist, 3);SListPushFront(&plist, 4);SListPrint(plist);SLTNode* pos = SListFind(plist, 2);if (pos){SListInsert(&plist, pos, 30);}SListPrint(plist);pos = SListFind(plist, 1);if (pos){SListErase(&plist, pos);}SListPrint(plist);
}

 输出的结果：

2.5 销毁链表

销毁链表需要遍历整个链表，因为链表上的每一个结点都是动态开辟出来的。

void SListDestory(SLTNode** pphead)
{assert(pphead);SLTNode* cur = *pphead;while (cur){SLTNode* next = cur->next;free(cur); cur = next;}*pphead = NULL;
}

3. 双向带头循环链表

开始之前，需要先创建三个文件List.h ，List.c和Ltest.c这三个文件。

  • Linked List.h文件包含所有用到的头文件，还有数据结构的设计和各种接口函数声明。
  • Linked List.c文件完成所有接口函数的实现。
  • Ltest.c主要代码是测试函数，来测试接口函数功能是否达标。

3.1 数据结构设计与接口函数声明

双向链表的数据结构中，不只有指向下一个结点的指针，还有指向上一个结点的指针。

typedef int LTDataType;typedef struct ListNode
{LTDataType data;struct ListNode* next;struct ListNode* prev;
}LTNode;//创建返回链表的头结点
LTNode* ListInit();
//双向链表的销毁
void ListDestroy(LTNode* phead);
//双向链表打印
void ListPrint(LTNode* phead);
//双向链表尾插
void ListPushBack(LTNode* phead, LTDataType x);
//双向链表头插
void ListPopBack(LTNode* phead);
//双向链表尾删
void ListPushFront(LTNode* phead, LTDataType x);
//双向链表头删
void ListPopFront(LTNode* phead);
//双向链表查找
LTNode* ListFind(LTNode* phead, LTDataType x);
//双向链表在pos的前面进行插入
void ListInsert(LTNode* pos, LTDataType x);
//双向链表删除pos位置的结点
void ListErase(LTNode* pos);

3.2 初始化，销毁，打印，动态创建结点

初始化的时候不是都只为空，需要创建一个哨兵位结点，不存储有效数据，并且next和prev都需要指向头结点，函数返回类型是LTNode*这样子就不需要传入二级指针。

LTNode* ListInit()
{LTNode* phead = (LTNode*)malloc(sizeof(LTNode));if (phead == NULL){exit(1);}phead->next = phead;phead->prev = phead;return phead;
}

销毁操作跟单链表相同，需要逐个释放，最后头结点也得释放，但是不需要将头结点置为空指针，因为传入的是一级指针，此时销毁函数内的是形参，改变形参无法影响实参。

void ListDestroy(LTNode* phead)
{assert(phead);LTNode* cur = phead->next;while (cur != phead){LTNode* next = cur->next;free(cur);cur = next;}free(phead);
}

打印函数使用while循环遍历链表即可。

void ListPrint(LTNode* phead)
{assert(phead);LTNode* cur = phead->next;while (cur != phead){printf("%d ", cur->data);cur = cur->next;}printf("\n");
}

动态创建一个新结点用处很大。注意next和prev都要置为空指针。

LTNode* BuyListNode(LTDataType x)
{LTNode* ptr = (LTNode*)malloc(sizeof(LTNode));if (ptr != NULL){LTNode* newnode = ptr;newnode->data = x;newnode->next = NULL;newnode->prev = NULL;return newnode;}exit(1);
}

3.3 尾插，头插，尾删，头删

尾插不需要查找，只需要通过prev指针就能定位到。

void ListPushBack(LTNode* phead, LTDataType x)
{assert(phead);LTNode* tail = phead->prev;LTNode* newnode = BuyListNode(x);newnode->data = x;//改变结点连接关系tail->next = newnode;newnode->prev = tail;newnode->next = phead;phead->prev = newnode;
}

头插操作如下，改变结点之间的指向问题。

void ListPushFront(LTNode* phead, LTDataType x)
{assert(phead);LTNode* newnode = BuyListNode(x);LTNode* next = phead->next;phead->next = newnode;newnode->prev = phead;newnode->next = next;next->prev = newnode;
}

尾删需要注意不能删除到哨兵位，通过断言头结点的下一个结点不能指向本身。

void ListPopBack(LTNode* phead)
{assert(phead);assert(phead->next != phead);LTNode* tail = phead->prev;LTNode* tailPrev = tail->prev;free(tail);tailPrev->next = phead;phead->prev = tailPrev;
}

头删的断言跟尾删一样，接下来就是释放并改变结点的指向。

void ListPopFront(LTNode* phead)
{assert(phead);assert(phead->next != phead);LTNode* next = phead->next;LTNode* nextNext = next->next;phead->next = nextNext;nextNext->prev = phead;free(next);
}

3.4 查找，插入和删除

查找函数跟单链表查找函数类似，遍历链表。

LTNode* ListFind(LTNode* phead, LTDataType x)
{assert(phead);LTNode* cur = phead->next;while (cur != phead){if (cur->data == x)return cur;cur = cur->next;}printf("\n");
}

插入函数因为双链表结构的复杂性，反而变得十分简单，不需要遍历链表。

//pos位置之前插入
void ListInsert(LTNode* pos, LTDataType x)
{assert(pos);LTNode* posPrev = pos->prev;LTNode* newnode = BuyListNode(x);//posPrev newnode posposPrev->next = newnode;newnode->prev = posPrev;newnode->next = pos;pos->prev = newnode;
}

删除函数也是，注意可通过新创建几个变量区分pos位置的前一个结点和后一个结点，方便操作。

//删除pos位置
void ListErase(LTNode* pos)
{assert(pos);// posPrev  pos  posNextLTNode* posPrev = pos->prev;LTNode* posNext = pos->next;posPrev->next = posNext;posNext->prev = posPrev;free(pos);pos = NULL;
}

写个测试函数：

void TestList2()
{LTNode* plist = ListInit();ListPushFront(plist, 1);ListPushFront(plist, 2);ListPushFront(plist, 3);ListPushFront(plist, 4);ListPrint(plist);LTNode* pos = ListFind(plist, 3);if (pos){ListInsert(pos, 30);}ListPrint(plist);pos = ListFind(plist, 2);if (pos){ListErase(pos);}ListPrint(plist);ListDestroy(plist);plist = NULL;
}

输出的结果：

4.链表和顺序表的区别

         不同点                顺序表                  链表
存储空间上  物理上一定连续逻辑上连续，物理上不一定连续
随机访问  支持O(1)  不支持 ：O(N)
任意位置插入或删除元素可能需要搬移元素，效率低O(N)只需要修改指针指向
插入动态顺序表，空间不够需要扩容没有容量的概念
应用场景 元素高效存储+频繁访问任意位置插入和删除频繁
缓存利用率高低

5. 源代码

5.1 单链表

（1）SList.h

#pragma once#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>typedef int SLTDataType;typedef struct SListNode
{SLTDataType data;struct SListNode* next;
}SLTNode;//动态申请一个结点
SLTNode* BuyListNode(SLTDataType x);
//单链表打印
void SListPrint(SLTNode* phead);
//单链表尾插
void SListPushBack(SLTNode** pphead, SLTDataType x);
//单链表头插
void SListPushFront(SLTNode** pphead, SLTDataType x);
//单链表尾删
void SListPopBack(SLTNode** pphead);
//单链表头删
void SListPopFront(SLTNode** pphead);
//单链表查找
SLTNode* SListFind(SLTNode* phead, SLTDataType x);
//在pos位置之前去插入一个节点
void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);
// 在pos位置后面插入
void SListInsertAfter(SLTNode* pos, SLTDataType x);
//删除pos位置的节点
void SListErase(SLTNode** pphead, SLTNode* pos);
//删除pos位置后一个节点
void SListEraseAfter(SLTNode** pphead, SLTNode* pos);
//单链表销毁
void SListDestory(SLTNode** pphead);

（2）SList.c

#include "SLinked list.h"SLTNode* BuyListNode(SLTDataType x)
{//动态申请新结点SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));if (newnode == NULL){//可能开辟内存失败，加上判断，增强代码的健壮性printf("malloc fail\n");exit(-1);}newnode->data = x;newnode->next = NULL;return newnode;
}void SListPrint(SLTNode* phead)
{SLTNode* cur = phead;while (cur != NULL){printf("%d->", cur->data);cur = cur->next;}printf("NULL\n");
}SLTNode* SListFind(SLTNode* phead, SLTDataType x)
{assert(phead);SLTNode* cur = phead;while (cur){if (cur->data == x){return cur;}else{cur = cur->next;}}return NULL;
}void SListPushBack(SLTNode** pphead, SLTDataType x)
{assert(pphead);SLTNode* newnode = BuyListNode(x);if (*pphead == NULL){*pphead = newnode;}else{//找到尾节点SLTNode* tail = *pphead;while (tail->next != NULL){tail = tail->next;}tail->next = newnode;}
}void SListPushFront(SLTNode** pphead, SLTDataType x)
{assert(pphead);SLTNode* newnode = BuyListNode(x);newnode->next = *pphead;*pphead = newnode;
}void SListPopBack(SLTNode** pphead)
{assert(pphead);assert(*pphead != NULL);if ((*pphead)->next == NULL){//1. 一个节点free(*pphead);*pphead = NULL;}else{	//2. 两个及以上的节点SLTNode* tail = *pphead;while (tail->next->next){tail = tail->next;}free(tail->next);tail->next = NULL;}
}void SListPopFront(SLTNode** pphead)
{assert(pphead);assert(*pphead != NULL);SLTNode* next = (*pphead)->next;free(*pphead);*pphead = next;
}// 在pos位置后面插入,这个更适合单链表
void SListInsertAfter(SLTNode* pos, SLTDataType x)
{assert(pos);SLTNode* newnode = BuyListNode(x);if (newnode == NULL){return;}newnode->next = pos->next;pos->next = newnode;
}void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{assert(pphead);SLTNode* newnode = BuyListNode(x);if (*pphead == pos){newnode->next = *pphead;*pphead = newnode;}else{// 找到pos的前一个位置SLTNode* posPrev = *pphead;while (posPrev->next != pos){posPrev = posPrev->next;}posPrev->next = newnode;newnode->next = pos;}
}void SListErase(SLTNode** pphead, SLTNode* pos)
{assert(pphead);assert(pos);//删除头节点if (*pphead == pos){*pphead = pos->next;free(pos);//要不要把pos置为空指针呢pos = NULL;}else{	//找前一个节点SLTNode* posPrev = *pphead;while (posPrev->next != pos){posPrev = posPrev->next;}//开始删除posPrev->next = pos->next;free(pos);pos = NULL;}
}void SListEraseAfter(SLTNode** pphead, SLTNode* pos)
{assert(pphead);assert(pos->next);SLTNode* next = pos->next;pos->next = next->next;free(next);
}

（3）SLtest.c

#include "SLinked list.h"void TestSlist1()
{SLTNode* plist = NULL;SListPushBack(&plist, 1);SListPushBack(&plist, 2);SListPushBack(&plist, 3);SListPushBack(&plist, 4);SListPrint(plist);SListPopBack(&plist);SListPopBack(&plist);SListPopBack(&plist);SListPrint(plist);
}void TestSlist2()
{SLTNode* plist = NULL;SListPushFront(&plist, 1);SListPushFront(&plist, 2);SListPushFront(&plist, 3);SListPushFront(&plist, 4);SListPrint(plist);SListPopFront(&plist);SListPopFront(&plist);SListPopFront(&plist);SListPopFront(&plist);SListPrint(plist);
}void TestSlist3()
{SLTNode* plist = NULL;SListPushFront(&plist, 1);SListPushFront(&plist, 2);SListPushFront(&plist, 3);SListPushFront(&plist, 4);SListPrint(plist);SLTNode* pos = SListFind(plist, 2);if (pos){SListInsertAfter(pos, 30);}SListPrint(plist);pos = SListFind(plist, 30);if (pos){SListEraseAfter(&plist, pos);}SListPrint(plist);
}void TestSlist4()
{SLTNode* plist = NULL;SListPushFront(&plist, 1);SListPushFront(&plist, 2);SListPushFront(&plist, 3);SListPushFront(&plist, 4);SListPrint(plist);SLTNode* pos = SListFind(plist, 2);if (pos){SListInsert(&plist, pos, 30);}SListPrint(plist);pos = SListFind(plist, 1);if (pos){SListErase(&plist, pos);}SListPrint(plist);
}int main()
{//TestSlist1();//TestSlist2();//TestSlist3();TestSlist4();return 0;
}

5.2 双向链表

（1）Linked LIst.h

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>typedef int LTDataType;typedef struct ListNode
{LTDataType data;struct ListNode* next;struct ListNode* prev;
}LTNode;//创建返回链表的头结点
LTNode* ListInit();
//双向链表的销毁
void ListDestroy(LTNode* phead);
//双向链表打印
void ListPrint(LTNode* phead);
//双向链表尾插
void ListPushBack(LTNode* phead, LTDataType x);
//双向链表头插
void ListPopBack(LTNode* phead);
//双向链表尾删
void ListPushFront(LTNode* phead, LTDataType x);
//双向链表头删
void ListPopFront(LTNode* phead);
//双向链表查找
LTNode* ListFind(LTNode* phead, LTDataType x);
//双向链表在pos的前面进行插入
void ListInsert(LTNode* pos, LTDataType x);
//双向链表删除pos位置的结点
void ListErase(LTNode* pos);

（2）Linked List.c

#include "Linked List.h"LTNode* ListInit()
{LTNode* phead = (LTNode*)malloc(sizeof(LTNode));if (phead == NULL){exit(1);}phead->next = phead;phead->prev = phead;return phead;
}LTNode* BuyListNode(LTDataType x)
{LTNode* ptr = (LTNode*)malloc(sizeof(LTNode));if (ptr != NULL){LTNode* newnode = ptr;newnode->data = x;newnode->next = NULL;newnode->prev = NULL;return newnode;}exit(1);
}void ListPrint(LTNode* phead)
{assert(phead);LTNode* cur = phead->next;while (cur != phead){printf("%d ", cur->data);cur = cur->next;}printf("\n");
}void ListPushBack(LTNode* phead, LTDataType x)
{assert(phead);LTNode* tail = phead->prev;LTNode* newnode = BuyListNode(x);newnode->data = x;//改变结点连接关系tail->next = newnode;newnode->prev = tail;newnode->next = phead;phead->prev = newnode;
}void ListPopBack(LTNode* phead)
{assert(phead);assert(phead->next != phead);LTNode* tail = phead->prev;LTNode* tailPrev = tail->prev;free(tail);tailPrev->next = phead;phead->prev = tailPrev;
}void ListPushFront(LTNode* phead, LTDataType x)
{assert(phead);LTNode* newnode = BuyListNode(x);LTNode* next = phead->next;phead->next = newnode;newnode->prev = phead;newnode->next = next;next->prev = newnode;
}void ListPopFront(LTNode* phead)
{assert(phead);assert(phead->next != phead);LTNode* next = phead->next;LTNode* nextNext = next->next;phead->next = nextNext;nextNext->prev = phead;free(next);
}LTNode* ListFind(LTNode* phead, LTDataType x)
{assert(phead);LTNode* cur = phead->next;while (cur != phead){if (cur->data == x)return cur;cur = cur->next;}printf("\n");
}//pos位置之前插入
void ListInsert(LTNode* pos, LTDataType x)
{assert(pos);LTNode* posPrev = pos->prev;LTNode* newnode = BuyListNode(x);//posPrev newnode posposPrev->next = newnode;newnode->prev = posPrev;newnode->next = pos;pos->prev = newnode;
}//删除pos位置
void ListErase(LTNode* pos)
{assert(pos);// posPrev  pos  posNextLTNode* posPrev = pos->prev;LTNode* posNext = pos->next;posPrev->next = posNext;posNext->prev = posPrev;free(pos);pos = NULL;
}void ListDestroy(LTNode* phead)
{assert(phead);LTNode* cur = phead->next;while (cur != phead){LTNode* next = cur->next;free(cur);cur = next;}free(phead);
}

（3）Ltest.c

测试函数也可以自行封装几个，参照单链表的测试函数。

#include "Linked List.h"void TestList1()
{LTNode* plist = ListInit();ListPushBack(plist, 1);ListPushBack(plist, 2);ListPushBack(plist, 3);ListPushBack(plist, 4);ListPrint(plist);ListPopBack(plist);ListPopBack(plist);ListPrint(plist);}void TestList2()
{LTNode* plist = ListInit();ListPushFront(plist, 1);ListPushFront(plist, 2);ListPushFront(plist, 3);ListPushFront(plist, 4);ListPrint(plist);LTNode* pos = ListFind(plist, 3);if (pos){ListInsert(pos, 30);}ListPrint(plist);pos = ListFind(plist, 2);if (pos){ListErase(pos);}ListPrint(plist);ListDestroy(plist);plist = NULL;
}int main()
{//TestList1();TestList2();return 0;
}

总结

通过这篇文章，相信你已经对链表这个数据结构有了一定的了解，可以开始刷一些链表的OJ题目。如果只是看了一遍，建议上手敲敲代码，实践出真知。

创作不易，希望这篇文章能给你带来启发和帮助，如果喜欢这篇文章，请留下你的三连哦，你的支持的我最大的动力！！！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://xiahunao.cn/news/2777969.html

如若内容造成侵权/违法违规/事实不符，请联系瞎胡闹网进行投诉反馈，一经查实，立即删除！

相关文章

防疫物资管理新篇章：Java+SpringBoot实战

防疫物资管理新篇章：Java+SpringBoot实战

✍✍计算机编程指导师 ⭐⭐个人介绍&#xff1a;自己非常喜欢研究技术问题&#xff01;专业做Java、Python、微信小程序、安卓、大数据、爬虫、Golang、大屏等实战项目。 ⛽⛽实战项目&#xff1a;有源码或者技术上的问题欢迎在评论区一起讨论交流&#xff01; ⚡⚡ Java实战 |…
阅读更多...
初识String类和String类的拓展

初识String类和String类的拓展

前言&#xff1a;以下是Java中String类的知识点与一些常见问题和注意事项&#xff0c;如有讲解不妥&#xff0c;请见谅&#xff01; 目录 1.String类的创建及常见API &#xff08;1&#xff09;String类的四种创建方式&#xff1a; 补充&#xff1a;字符串转化成字符数组 / …
阅读更多...
038 什么是面向对象

038 什么是面向对象

面向过程&面向对象 什么是面向对象 现实世界中的事物、类、对象之间的关系 在我们想通过计算机解决一个具体问题的时候&#xff0c;我们可以研究与问题有关事物的共性&#xff0c;比如我在观察了大量的杯子后得出一些结论&#xff1a;杯子都应该有材质、颜色、尺寸、形状这…
阅读更多...
Docker 容器网络：C++ 客户端 — 服务器应用程序。

Docker 容器网络：C++ 客户端 — 服务器应用程序。

一、说明 在下面的文章中&#xff0c; 将向您概述 docker 容器之间的通信。docker 通信的验证将通过运行 C 客户端-服务器应用程序和标准“ping”命令来执行。将构建并运行两个单独的 Docker 映像。 由于我会关注 docker 网络方面&#xff0c;因此不会提供 C 详细信息。…
阅读更多...
LeetCode-第15题-三叔之和

LeetCode-第15题-三叔之和

1.题目描述 给你一个整数数组 nums &#xff0c;判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i ! j、i ! k 且 j ! k &#xff0c;同时还满足 nums[i] nums[j] nums[k] 0 。请你返回所有和为 0 且不重复的三元组。 注意&#xff1a;答案中不可以包含重复的三元组…
阅读更多...
1899_野火FreeRTOS教程阅读笔记_任务创建

1899_野火FreeRTOS教程阅读笔记_任务创建

1899_野火FreeRTOS教程阅读笔记_任务创建 全部学习汇总&#xff1a; g_FreeRTOS: FreeRTOS学习笔记 (gitee.com) 关于这部分&#xff0c;从一般前后台程序到RTOS的任务描述了很多。但是我觉得这本书的这部分描述没有描述到关键的信息点。其实&#xff0c;RTOS存在的一个主要的目…
阅读更多...
MySQL篇----第八篇

MySQL篇----第八篇

系列文章目录 文章目录 系列文章目录前言一、存储过程优化思路二、触发器(一段能自动执行的程序)三、数据库并发策略四、MySQL 中有哪几种锁？五、MySQL 中有哪些不同的表格？前言 前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。点击跳…
阅读更多...
创建自己的系统创富法则，做个轻松赚钱的甩手掌柜

创建自己的系统创富法则，做个轻松赚钱的甩手掌柜

一、教程描述 本套系统创富教程&#xff0c;大小744.80M&#xff0c;共有28个文件。 二、教程目录 01.走遍全球四十多个国家&#xff0c;我才发现赚钱的本质如此雷同.mp4 02.靠工资技术赚钱太慢&#xff0c;想赚到自己的第一个一百万的方法是&#xff1f;.mp4 03.不服暴发…
阅读更多...
CSP-202112-2-序列查询新解

CSP-202112-2-序列查询新解

CSP-202112-2-序列查询新解 【70分思路】 【暴力枚举】按照题目思路遍历一遍f(x)和g(x)&#xff0c;计算error(A)&#xff0c;时间复杂度为O(N)&#xff0c;时间超限。 #include <iostream> using namespace std; int main() {long long n, N, sum 0;cin >> n …
阅读更多...
【c++基础】骑士的金币（coin）（NOIP2015）

【c++基础】骑士的金币（coin）（NOIP2015）

说明 国王将金币作为奖励&#xff0c;发放给忠诚的骑士。第一天&#xff0c;骑士收到一枚金币&#xff1b;之后两天&#xff08;第二天和第三天&#xff09;里&#xff0c;每天收到两枚金币&#xff1b;之后三天&#xff08;第四、五、六天&#xff09;里&#xff0c;每天收到…
阅读更多...
微软 CMU - Tag-LLM：将通用大语言模型改用于专业领域

微软 CMU - Tag-LLM：将通用大语言模型改用于专业领域

文章目录 一、前言二、主要内容三、总结 &#x1f349; CSDN 叶庭云&#xff1a;https://yetingyun.blog.csdn.net/ 一、前言 论文地址&#xff1a;https://arxiv.org/abs/2402.05140 Github 地址&#xff1a;https://github.com/sjunhongshen/Tag-LLM 大语言模型&#xff08…
阅读更多...
ChatGPT高效提问—prompt常见用法

ChatGPT高效提问—prompt常见用法

ChatGPT高效提问—prompt常见用法 1.1 角色扮演 ​ prompt最为常见的用法是ChatGPT进行角色扮演。通常我们在和ChatGPT对话时&#xff0c;最常用的方式是一问一答&#xff0c;把ChatGPT当作一个单纯的“陪聊者”。而当我们通过prompt为ChatGPT赋予角色属性后&#xff0c;即使…
阅读更多...
SpringIOC之support模块PropertySourcesPlaceholderConfigurer

SpringIOC之support模块PropertySourcesPlaceholderConfigurer

博主介绍&#xff1a;✌全网粉丝5W&#xff0c;全栈开发工程师&#xff0c;从事多年软件开发&#xff0c;在大厂呆过。持有软件中级、六级等证书。可提供微服务项目搭建与毕业项目实战&#xff0c;博主也曾写过优秀论文&#xff0c;查重率极低&#xff0c;在这方面有丰富的经验…
阅读更多...
LeetCode Python - 6.Z字形变换

LeetCode Python - 6.Z字形变换

文章目录 题目答案运行结果 题目 将一个给定字符串 s 根据给定的行数 numRows &#xff0c;以从上往下、从左到右进行 Z 字形排列。 比如输入字符串为 “PAYPALISHIRING” 行数为 3 时&#xff0c;排列如下&#xff1a; P A H N A P L S I I G Y I R 之后&#xff0c;你的输…
阅读更多...
STM32 FSMC (Flexible static memory controller) 灵活静态内存控制器介绍

STM32 FSMC (Flexible static memory controller) 灵活静态内存控制器介绍

文章目录 1. 介绍FSMC2. FSMC特点3. Block示意图4. AHB接口4.1 Supported memories and transactionsGeneral transaction rulesConfiguration registers 5. 外部设备地址映射5.1 NOR/PSRAM地址映射将NOR Flash/PSRAM的支持进行封装 5.2 NAND/PC Card地址映射 1. 介绍FSMC 说到…
阅读更多...
【正在更新】从零开始认识语音识别：DNN-HMM混合系统语音识别(ASR)模型原理

【正在更新】从零开始认识语音识别：DNN-HMM混合系统语音识别(ASR)模型原理

摘要 | Abstract TO-BE-FILLED 前言 | Introduction 近期想深入了解HMM隐马尔可夫模型和DNN-HMM混合模型&#xff0c;但是尽管网络上有许多关于DNN-HMM的介绍&#xff0c;如李宏毅教授的《深度学习人类语言处理》[1]&#xff0c;一些博主的语音识别系列文章[2]&#xff0c;斯坦…
阅读更多...
4核8g服务器能支持多少人访问？- 腾讯云

4核8g服务器能支持多少人访问？- 腾讯云

腾讯云轻量4核8G12M轻量应用服务器支持多少人同时在线&#xff1f;通用型-4核8G-180G-2000G&#xff0c;2000GB月流量&#xff0c;系统盘为180GB SSD盘&#xff0c;12M公网带宽&#xff0c;下载速度峰值为1536KB/s&#xff0c;即1.5M/秒&#xff0c;假设网站内页平均大小为60KB…
阅读更多...
机器学习系列——（十八）K-means聚类

机器学习系列——（十八）K-means聚类

引言 在众多机器学习技术中&#xff0c;K-means聚类以其简洁高效著称&#xff0c;成为了数据分析师和算法工程师手中的利器。无论是在市场细分、社交网络分析&#xff0c;还是图像处理等领域&#xff0c;K-means都扮演着至关重要的角色。本文旨在深入解析K-means聚类的原理、实…
阅读更多...
Sodinokibi(REvil)黑客组织发起大规模供应链攻击

Sodinokibi(REvil)黑客组织发起大规模供应链攻击

前言 Sodinokibi勒索病毒黑客组织获取了远程管理解决方案提供商Kaseya基础设施的访问权限&#xff0c;并使用VSA软件的恶意升级执行程序在企业网络上部署Sodinokibi(REvil)勒索病毒&#xff0c;据报道该事件已经影响了全球数千家公司&#xff0c;相关受害者发布的信息&#xf…
阅读更多...
WWW 2024 | 时间序列（Time Series）和时空数据（Spatial-Temporal）论文总结

WWW 2024 | 时间序列（Time Series）和时空数据（Spatial-Temporal）论文总结

WWW 2024已经放榜&#xff0c;本次会议共提交了2008篇文章&#xff0c;research tracks共录用约400多篇论文&#xff0c;录用率为20.2%。本次会议将于2024年5月13日-17日在新加坡举办。 本文总结了WWW 2024有关时间序列&#xff08;Time Series&#xff09;和时空数据&#xf…
阅读更多...
最新文章

Copyright @ 2022~2023