单链表的应用_单链表应用-CSDN博客

本文链接：https://blog.csdn.net/tongxuexie/article/details/79684125

1.单链表的简单介绍

单链表是一种链式存取的数据结构，用一组任意地址空间（地址空间即存储单元）来存放线性表的数据元素。单链表中的数据是以节点的形式来表示，而节点是用结构体来描述，每个节点都是由元素和指针构成，即该结构体中包含两个成员变量：存放元素的成员变量和存放下一个节点地址的成员变量。单链表的节点结构为如下所示：

2.顺序表的简单介绍

用顺序存储方法存储的线性表称为顺序表，顺序表是用一组连续的地址空间（地址空间即存储单元）存放线性表的数据元素。顺序表的特点为:逻辑相邻的两个节点其物理存储位置也是相邻的。顺序表的存储方式如下所示：

3.顺序表与链表的区别

顺序表的特点为：逻辑相邻的两节点其物理地址也是相邻的；链表的特点为：逻辑相邻的两节点其物理地址不相邻。顺序表的存储方式是：节点元素连续存放在存储单元；链表的存储方式是：节点元素随机存放在存储单元。

4.链表的应用

了解了什么是链表之后，需考虑如何定义一个结构体？我们需要定义一个结构体用于表示节点信息，故还结构体需要存放节点元素和下一节点地址，即：

typedef struct LinkNode
{
char data;
struct LinkNode* next;

}LinkNode;

那么我如果需要的不是char类型的节点元素呢？那么就得修改每次操作的节点元素的数据类型，这使得代码不具有可拓展性，那么就想到了宏定义一个节点元素的数据类型，从而只要修改该宏即可修改该节点元素的数据类型，具体如下：

#define LinkListType char
typedef struct LinkNode
{
LinkListType data;
struct LinkNode* next;

}LinkNode;

根据已有的思路，下面具体写头文件linklist.h的代码：

//头文件只被编译一次
#pragma once
//自定义元素的类型，方便用户去修改元素的数据类型
typedef char LinkListType;
//定义一个结构体，用于元素的存放和查找下一个元素所在的位置
typedef struct LinkNode
{
LinkListType data;
struct LinkNode* next;
}LinkNode; //其中LinkNode是对所定义的结构体的重命名，LinkList*是定义指向该结构
体的指针类型
//宏定义一个标识符，用于测试函数时打印其对应的函数名，方便了代码的编写

#define HEADER printf("============%s===========\n",__FUNCTION__);

4.1 链表的初始化

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include"linklist.h"
//思路：初始链表中的节点个数为0，故只需要一个头指针指向一个NULL，则表明该链表为空链表
void LinkListInit(LinkNode** phead)
{
//判断非法输入
if(phead==NULL)
return;
*phead=NULL;

}

注：为了方便表述，以下的代码不再引用头文件，所需头文件与上述相同。

4.2 链表的打印

//思路：第一个参数接收链表的头指针，第二个参数接收字符串的地址，用于打印时显示关于打印的具体信息

void LinkListPrintChar(LinkNode* head,const char* msg)
{
printf("[%s]\n",msg);
LinkNode* cur=head;
for(cur=head;cur!=NULL;cur=cur->next)
{
printf("[%p]|[%c] ",cur,cur->data);
}
printf("\n");
}

4.3 链表的尾插

//思路：创建一个新节点并修改链表中最后一个节点的next值，当为空链表时，则需要修改头指针的内容
//创建一个节点，用函数封装起来从而提高代码的可维护性
LinkNode* CreateNode(LinkListType value)
{
LinkNode* new_node=(LinkNode*)malloc(sizeof(LinkNode));
new_node->data=value;
new_node->next=NULL;
return new_node;

}

void LinkListPushBack(LinkNode** phead,LinkListType value)
{
//判断非法输入
if(phead==NULL)
return;
//链表为空时，是通过创建新节点并修改头指针的指向
if(*phead==NULL)
{
LinkNode* new_node=CreateNode(value);
*phead=new_node;
return;
}
//链表非空时，通过创建新节点并遍历找到最后一个节点，将其的next进行修改
LinkNode* cur=*phead;
while(cur->next!=NULL)
{
cur=cur->next;
}
cur->next=CreateNode(value);
}

4.4 链表的尾删

//销毁一个节点，用函数封装起来从而提高代码的可维护性
void DestroyNode(LinkNode* node)
{
free(node);
}
//思路：有三种情况处理：1.链表为空 2.链表只有一个节点 3.链表至少有两个节点
void LinkListPopBack(LinkNode** phead)
{
//判断非法输入
if(phead==NULL)
return;
//判断链表是否为空
if(*phead==NULL)
return;
//链表为一个节点时，销毁该节点的空间并修改头指针的指向
if((*phead)->next==NULL)
{
DestroyNode(*phead);
*phead=NULL;
}
//链表至少为两个节点时，遍历链表需要两个指针：存放倒数第二个节点的地址和需要释放的最后一个节点的地址
LinkNode* cur=*phead; //存放要释放的最后一个节点的地址
LinkNode* pre=NULL; //存放倒数第二个节点的地址
while(cur->next!=NULL)
{
pre=cur;
cur=cur->next;
}
//当循环结束后，cur就指向最后一个节点，pre就指向倒数第二个节点
pre->next=NULL;
DestroyNode(cur);
}

4.5 链表的头插

//思路：创建一个新节点，并修改头结点的指向和新节点的next值
void LinkListPushFront(LinkNode** phead,LinkListType value)
{
//判断非法输入
if(phead==NULL)
return;
//空链表与非空链表一致处理
LinkNode* new_node=CreateNode(value);
new_node->next=*phead;
*phead=new_node;
}

4.6 链表的头删

//思路：分情况处理：1.链表为空 2.链表只有一个节点 3.链表至少有两个节点
void LinkListPopFront(LinkNode** phead)
{
//判断非法输入
if(phead==NULL)
return;
//判断链表是否为空
if(*phead==NULL)
return;
//链表只有一个节点时，直接释放第一个节点的空间并修改头指针的指向
if((*phead)->next==NULL)
{
DestroyNode(*phead);
*phead=NULL;
return;
}
//链表至少有两个节点时，将头指针指向第二个节点位置，释放第一个节点空间
LinkNode* freenode=*phead;
DestroyNode(freenode);
*phead=(*phead)->next;
//也可以将2.3情况一并处理
}

4.7 链表任意位置的插入

4.7.1任意位置的插入(pos后插)
//思路：创建新节点并修改新节点的next值和pos的next值
void LinkListInsert(LinkNode* pos,LinkListType value)
{
//判断非法输入，pos表示一个节点的地址，若pos==NULL则表示不存在这样的节点
if(pos==NULL)
return;
LinkNode* new_node=CreateNode(value);
new_node->next=pos->next;
pos->next=new_node;
}
4.7.2任意位置的插入(pos前插)
//思路：去遍历链表找到pos的前一个节点，在用LinkListInsert()函数进行插入
void LinkListInsertBefore(LinkNode** phead,LinkNode* pos,LinkListType value)
{
//判断非法输入
if(phead==NULL||pos==NULL)
return;
//链表中只有一个节点时
if(*phead==pos)
{
//要插入的位置为第一个节点，用头插法
LinkListPushFront(phead,value);
return;
}
//链表中至少有两个节点
LinkNode* cur=*phead;
for(cur=*phead;cur!=NULL;cur=cur->next)
{
if(cur->next==pos)
break;
}
//循环结束之后，需要知道是找到pos了还是没找到
if(cur==NULL)
//没找到
return;
//找到pos的前一个节点后使用LinkListInsert()函数
LinkListInsert(cur,value);
}
4.7.3不允许遍历单链表，在pos位置前插入,使得时间复杂度变为O(1)
//思路：先插在pos后面，再修改两个节点的值
void LinkListInsertBeforeEx(LinkNode* pos,LinkListType value)
{
//判断非法输入，当pos==NULL时表示不存在这样的节点
if(pos==NULL)
return;
LinkNode* new_node=CreateNode(pos->data);
new_node->next=pos->next;
pos->next=new_node;
pos->data=value;
//以上四条语句的功能可以用以下两条语句代替
//LinkListInsert(pos,pos->data);
//pos->data=value;
}

4.8 查找元素在链表中的位置

//思路：通过遍历查找，返回所查找到的节点地址
LinkNode* LinkListFind(LinkNode* head,LinkListType to_find)
{
//判断链表是否为空
if(head==NULL)
return NULL;
LinkNode* cur=head;
while(cur!=NULL)
{
if(cur->data==to_find)
return cur;
cur=cur->next;
}
return NULL;
}

4.9 删除指定位置的元素

//思路：通过遍历销毁pos位置的节点，并修改pos位置的前一个节点的next值
void LinkListErase(LinkNode** phead,LinkNode* pos)
{
//判断非法输入
if(phead==NULL||pos==NULL)
return;
//空链表时
if(*phead==NULL)
return;
//删除第一个节点时
if((*phead)==pos)
{
//当只有一个节点时
if((*phead)->next==NULL)
{
*phead=NULL;
DestroyNode(pos);
return;
}
else
{
*phead=pos->next;
DestroyNode(pos);
}
}
//链表节点至少为2时，遍历链表，并判断是否找到pos
LinkNode* cur=*phead;
for(cur=*phead;cur!=NULL;cur=cur->next)
{
if(cur->next==pos)
break;
}
//循环结束，判断是否找到pos
if(cur==NULL) //未找到pos
return;
cur->next=pos->next;
DestroyNode(pos);
}

4.10 删除指定值的元素（如有重复的元素只删除一个即可）

//思路：通过LinkListFind()找到对应元素的地址，再使用对任意位置做删除的函数LinkListErase()即可
void LinkListRemove(LinkNode** phead,LinkListType to_delete)
{
//判断非法输入
if(phead==NULL)
return;
LinkNode* to_find=LinkListFind(*phead,to_delete);
LinkListErase(phead,to_find);
}

4.11 指定值的所有元素都删除

//思路1：通过遍历链表以及利用LinkListRemove()删除所有指定的元素
void LinkListRemoveAll(LinkNode** phead,LinkListType remove)
{
//判断非法输入
if(phead==NULL)
return;
LinkNode* cur=*phead;
for(cur=*phead;cur!=NULL;cur=cur->next)
{
if(cur->data==remove)
LinkListRemove(phead,remove);
}

}

//思路2：通过遍历链表以及利用LinkListFind()和LinkListErase()删除所有指定的元素
void LinkListRemoveAllEx(LinkNode** phead,LinkListType remove)
{
if(phead==NULL)
//非法输入
return;
while(1)
{
LinkNode* pos=LinkListFind(*phead,remove);
if(pos==NULL)
return;
LinkListErase(phead,pos);
}

}

//思路3:时间复杂度变为O(n)
void LinkListRemoveAllExp(LinkNode** phead,LinkListType remove)
{
if(phead==NULL)
//非法输入
return;
//空链表
if(*phead==NULL)
return;
LinkNode* cur=*phead;
//非空链表
while(cur!=NULL)
{
//当删除的元素为第一个元素时
if((*phead)->data==remove)
{
LinkNode* delete=*phead;
*phead=delete->next;
cur=*phead;
DestroyNode(delete);
}
//当删除的元素不是第一个元素，第二个元素存在时
else if(cur->next!=NULL)
{
//第二个元素存在时，判断第二个元素是否是想要删除的元素
if(cur->next->data==remove)
{
LinkNode* delete=cur->next;
cur->next=delete->next;
DestroyNode(delete);
}
else
cur=cur->next;
}
//删除后，第二个元素不存在
else
return;
}
}

4.12 判定链表为空

//思路：返回类型为int，链表为空返回1，链表非空返回0
int LinkListEmpty(LinkNode* head)
{
if(head==NULL)
return 1;
return 0;

}

//方法二思路：返回类型为int，链表为空返回1，链表非空返回0
int LinkListEmpty(LinkNode* head)
{

return head==NULL?1：0;

}

4.13 求链表的元素个数

//思路：遍历链表去统计元素个数
size_t LinkListSize(LinkNode* head)
{
if(head==NULL)
return 0;
size_t size=0;
LinkNode* cur=head;
while(cur!=NULL)
{
size++;
cur=cur->next;
}
return size;
}

4.14 逆序打印单链表

//思路1：分三种情况：1. 链表为空 2.链表只有一个元素 3.链表至少有两个元素
void LinkListReservePrintChar(LinkNode* head)
{
//判断链表是否为空
if(head==NULL)
return;
//判断链表是否只有一个元素
if(head->next==NULL)
{
printf("[%p][%c] \n",head,head->data);
return;
}
//链表至少有两个元素时
LinkNode* end=NULL;
LinkNode* cur=head->next;
while(cur!=head)
{
for(cur=head;cur!=NULL;cur=cur->next)
{
if((cur->next)==end)
{
printf("[%p][%c] ",cur,cur->data);
end=cur;
break;
}
}
}
//printf("[%p][%c]\n",head,head->data);
printf("\n");

}

//思路2：上述的方式是非递归的方式，下面将利用递归的思想逆序打印链表元素
void LinkListReversePrintCharEx(LinkNode* head)
{
LinkNode* cur=head;
if(cur==NULL)
return;
LinkListReversePrintCharEx(cur->next);
printf("%c ",cur->data);

}

4.15 测试上述函数是否正确

/*测试代码块，用于测试代码是否正确*/
//1.测试初始化链表是否正确
void Test_LinkListInit()
{
HEADER;
LinkNode* head;
LinkListInit(&head);
LinkListPrintChar(head,"对空链表打印");
}
//2.测试尾插法是否正确
void Test_LinkListPushBack()
{
HEADER;
LinkNode* head;
LinkListInit(&head);
LinkListPushBack(&head,'a');
LinkListPushBack(&head,'b');
LinkListPushBack(&head,'c');
LinkListPrintChar(head,"尾插节点'a','b','c'");
}
//3.测试尾删法是否正确
void Test_LinkListPopBack()
{
HEADER;
LinkNode* head;
LinkListInit(&head);
LinkListPushBack(&head,'a');
LinkListPushBack(&head,'b');
LinkListPushBack(&head,'c');
LinkListPopBack(&head);
LinkListPrintChar(head,"链表节点'a' 'b' 'c'中尾删一个节点");
}
//4.测试头插法是否正确
void Test_LinkListPushFront()
{
HEADER;
LinkNode* head;
LinkListInit(&head);
LinkListPushFront(&head,'a');
LinkListPushFront(&head,'b');
LinkListPushFront(&head,'c');
LinkListPrintChar(head,"头插节点'a' 'b' 'c'");
}
//5.测试头删法
void Test_LinkListPopFront()
{
HEADER;
LinkNode* head;
LinkListInit(&head);
LinkListPopFront(&head);
LinkListPrintChar(head,"头删法删除空链表");
LinkListPushFront(&head,'a');
LinkListPushFront(&head,'b');
LinkListPushFront(&head,'c');
LinkListPopFront(&head);
LinkListPrintChar(head,"头删法删除链表节点'c' 'b' 'a'的一个节点");
}
//6.测试任意位置的插入(pos后插)是否正确
void Test_LinkListInsert()
{
HEADER;
LinkNode* head;
LinkListInit(&head);
LinkListPushFront(&head,'a');
LinkListPushFront(&head,'b');
LinkListPushFront(&head,'c');
LinkListInsert(head,'x');
LinkListPrintChar(head,"在链表'c' 'b' 'a'的'c'节点后插入节点'x'");
}
//7.测试任意位置的插入(pos前插)是否正确
void Test_LinkListInsertBefore()
{
HEADER;
LinkNode* head;
LinkListInit(&head);
LinkListPushFront(&head,'a');
LinkListPushFront(&head,'b');
LinkListPushFront(&head,'c');
LinkListInsertBefore(&head,head,'x');
LinkListPrintChar(head,"在链表'c' 'b' 'a'的'c'节点前插入节点'x'");
}
//7.1.测试不允许遍历链表，在pos前插入的时间复杂度为O(1)是否正确
void Test_LinkListInsertBeforeEx()
{
HEADER;
LinkNode* head;
LinkListInit(&head);
LinkListPushFront(&head,'a');
LinkListPushFront(&head,'b');
LinkListPushFront(&head,'c');
LinkListInsertBeforeEx(head->next,'x');
LinkListPrintChar(head,"使用时间复杂度为O(1)在链表'c' 'b' 'a'的'b'节点前插入节点'x'");
}
//8.测试查找元素在链表中的位置是否正确
void Test_LinkListFind()
{
HEADER;
LinkNode* head;
LinkListInit(&head);
LinkListPushFront(&head,'a');
LinkListPushFront(&head,'b');
LinkListPushFront(&head,'c');
LinkListPrintChar(head,"查找链表中没有的节点'x'");
LinkNode* find=LinkListFind(head,'x');
printf("&a=%p\n",find);
LinkListPrintChar(head,"查找链表中的节点'a'");
find=LinkListFind(head,'a');
printf("&a=%p\n",find);
}
//9.测试指定位置的删除是否正确
void Test_LinkListErase()
{
HEADER;
LinkNode* head;
LinkListInit(&head);
LinkListErase(&head,head);
LinkListPrintChar(head,"对空链表进行删除");
LinkListPushBack(&head,'a');
LinkListErase(&head,head);
LinkListPrintChar(head,"删除链表中的节点'a'");
LinkListPushBack(&head,'a');
LinkListPushBack(&head,'b');
LinkListPushBack(&head,'c');
LinkListErase(&head,head);
LinkListPrintChar(head,"删除链表中的节点'a'");
}
//10.测试指定元素的删除是否正确
void Test_LinkListRemove()
{
HEADER;
LinkNode* head;
LinkListInit(&head);
LinkListPushBack(&head,'a');
LinkListPushBack(&head,'b');
LinkListPushBack(&head,'c');
LinkListRemove(&head,'a');
LinkListPrintChar(head,"[指定元素的删除]删除链表中的节点'a'");
}
//11.测试删除所有指定元素是否正确
void Test_LinkListRemoveAll()
{
HEADER;
LinkNode* head;
LinkListInit(&head);
LinkListPushBack(&head,'a');
LinkListPushBack(&head,'x');
LinkListPushBack(&head,'a');
LinkListPushBack(&head,'b');
LinkListPushBack(&head,'c');
LinkListPushBack(&head,'a');
LinkListRemoveAll(&head,'a');
LinkListPrintChar(head,"[删除所有指定元素]删除链表中的节点'a'");
}
void Test_LinkListRemoveAllEx()
{
HEADER;
LinkNode* head;
LinkListInit(&head);
LinkListPushBack(&head,'a');
LinkListPushBack(&head,'x');
LinkListPushBack(&head,'a');
LinkListPushBack(&head,'b');
LinkListPushBack(&head,'c');
LinkListPushBack(&head,'a');
LinkListRemoveAllEx(&head,'a');
LinkListPrintChar(head,"[删除所有指定元素]删除链表中的节点'a'");
}
void Test_LinkListRemoveAllExp()
{
HEADER;
LinkNode* head;
LinkListInit(&head);
LinkListPushBack(&head,'a');
LinkListPushBack(&head,'x');
LinkListPushBack(&head,'a');
LinkListPushBack(&head,'b');
LinkListPushBack(&head,'c');
LinkListPushBack(&head,'a');
LinkListRemoveAllExp(&head,'a');
LinkListPrintChar(head,"[删除所有指定元素]删除链表中的节点'a'");
}
//12.测试判定链表为空是否正确
void Test_LinkListEmpty()
{
HEADER;
LinkNode* head;
LinkListInit(&head);
int ret=LinkListEmpty(head);
if(ret==1)
printf("链表为空\n");
else if(ret==0)
printf("链表非空\n");
LinkListPushBack(&head,'a');
LinkListPushBack(&head,'x');
LinkListPushBack(&head,'a');
ret=LinkListEmpty(head);
if(ret==1)
printf("链表为空\n");
else if(ret==0)
printf("链表非空\n");
}
//13.测试求链表元素个数是否正确
void Test_LinkListSize()
{
HEADER;
LinkNode* head;
LinkListInit(&head);
size_t ret=LinkListSize(head);
printf("expect 0,autual %lu\n",ret);
LinkListPushBack(&head,'a');
LinkListPushBack(&head,'x');
LinkListPushBack(&head,'a');
LinkListPushBack(&head,'b');
LinkListPushBack(&head,'c');
ret=LinkListSize(head);
printf("expect 5,autual %lu\n",ret);
}
//14.测试逆序打印链表是否正确
void Test_LinkListReversePrintChar()
{
HEADER;
LinkNode* head;
LinkListInit(&head);
LinkListReservePrintChar(head);
LinkListPushBack(&head,'a');
LinkListPushBack(&head,'b');
LinkListPushBack(&head,'c');
LinkListPrintChar(head,"正向打印");
printf("[逆序打印]\n");
LinkListReservePrintChar(head);
}
void Test_LinkListReversePrintCharEx()
{
HEADER;
LinkNode* head;
LinkListInit(&head);
LinkListReservePrintCharEx(head);
LinkListPushBack(&head,'a');
LinkListPushBack(&head,'b');
LinkListPushBack(&head,'c');
LinkListPrintChar(head,"正向打印");
printf("[逆序打印]\n");
LinkListReservePrintCharEx(head);
}
/*主函数*/
int main()
{
Test_LinkListInit();
Test_LinkListPushBack();
Test_LinkListPopBack();
Test_LinkListPushFront();
Test_LinkListPopFront();
Test_LinkListInsert();
Test_LinkListInsertBefore();
Test_LinkListInsertBeforeEx();
Test_LinkListFind();
Test_LinkListErase();
Test_LinkListRemove();
Test_LinkListRemoveAll();
Test_LinkListRemoveAllEx();
Test_LinkListEmpty();
Test_LinkListSize();

Test_LinkListReversePrintChar();

Test_LinkListReversePrintCharEx();

return 0;
}