线性表的链式实现(单链表)

最新推荐文章于 2023-03-23 19:32:49 发布

lanhuazui10

最新推荐文章于 2023-03-23 19:32:49 发布

阅读量1.3k

点赞数

分类专栏：数据结构

原文链接：https://blog.csdn.net/emdfans/article/details/16905211

版权

数据结构专栏收录该内容

30 篇文章 6 订阅

订阅专栏

单链表的定义

为了表示每个数据元素与其直接后续元素之间的逻辑关系，每个元素除了存储本身的信息外，还需要存储指示其直接后续的信息，即每个结点存放本身的数据元素和下一个元素的地址。n个结点连接成一个链式线性表的结构我们叫做链表，当每个结点只包含一个指针域时，叫做单链表。

首先给出一个线性表，存放数据元素，a1 到 an 有这样的线性逻辑关系。单链表在存储空间上是这样存放的，它是存放在任意位置的，这个任意位置表示它们不一定要连续。如图所示的 a2、a3 与 a3、a4 。

第二个很明显的差别是单链表在存放数据元素同时，不仅仅存放了数据本身，还存放了下一个数据元素地址，通过这样的地址来维持了线性的逻辑关系。表示 a2 是 a1 的后继，a3 是 a2 的后继。这样地址像一条链子一样，把所有的数据元素串了起来，形成了一个单链表，我们管这样的数据加地址的组合叫做单链表的一个节点。该节点是由存放数据元素的数据 data 和存放下一个数据元素的地址的指针域 next 共同来组成。

typedef struct LNode {
    ElemType data;
    struct LNode *next;
} LNode, *LinkList;

在程序设计语言上，我们会通过一个结构体来实现这样一个节点，它的名字叫做 LNode ，其中包含保存数据元素的变量 data 和存放下一个数据元素的指针 LNode *next 。它这个结构体的名字不仅仅叫做 LNode，还叫做 LinkList。通过名字可以发现一个节点也可以表示为一个单链表。因为只要给出第一个节点的地址，就可以依次找到属于这个单链表的所有节点。所以通过一个指针，还可以表示该单链表。

单链表虽然有一些优点，但是它也存在一些弊端。比如说单链表在存放数据元素的同时，还要存放指向下一个节点位置的指针域，那么这些指针域会造成空间的浪费。单链表在存放数据元素时，没有像顺序表那样存储空间连续相邻这样一个特点，所以不能实现随机存取，只能实现顺序存取。也就是说，想要找到其中的一个数据元素，只能从第一个数据元素的位置依次查找，遍历单链表。这就是单链表的具体实现方式。

这是所画出的一个单链表 L。其中保存的数据元素是 a1 到 an ，并且 a2 是 a1 后继，a3 是 a2 后继这样的线性逻辑关系。在线性表的表头也就是 a1 节点的位置有一个指针 head 指向了第一个数据节点，这样指针管它叫做头指针。如果知道了头指针，也就知道了整个线性表所有的节点。因为可以通过头指针，按照遍历的方法找到线性表当中的每一个节点。

但是在平时利用单链表去解决问题时，往往会利用这样一种引入头结点的单链表。

此时头指针指向的是头结点，而头结点的 next 域指向的是线性表当中的第一个数据元素的位置。头结点中的数据域，往往是不存放数据元素的，但是可能有时会利用它来存放一些关键的信息，比如说单链表的表长等。

在引入头结点之后，很多东西都发生变化了，其中一个就是如何判断单链表是一个空表。观察第一种单链表，发现判断他为空的方法为头指针是否为空，如果头指针为空时，那么单链表就为空。第二种判断单链表为空的方法是头结点的 next 域，也就是 head -> next 为 null 时，单链表 L 为空。

要记住引入头结点之后，第一个数据元素依旧是头结点的 next 域指向的那个节点，而绝非是头结点。

在平常我们利用单链表解决问题时，为什么会用这种引入头结点的单链表呢？它有两个优点，第一个优点是链表的第一个位置和其他位置的操作进行统一了。为什么可以统一操作，比如说在单链表没有头结点时，想要实现插入操作，在表中进行插入操作时，两边都是有节点的，而在表头进行插入操作时，前面是没有节点的，所以在具体实现上，这里会有所不同。接着来看带有头结点的单链表，在表头进行插入时，它两边依旧是都有节点的，所以它就达到了一个统一操作的目的。

第二个优点是空表和非空表的操作统一。如何统一？我们知道，无论是有没有数据节点，带有头结点的，单链表始终 head 指针都不为空，它始终指向了头结点，所以说空表和非空表的操作也统一了。这就是为什么在利用单链表时要引入一个头结点。

创建可复用的单链表

单链表的插入操作：

单链表的删除操作：

单链表实现

//LinkList.h

#ifndef _LINKLIST_H_
#define _LINKLIST_H_

typedef void LinkList;
typedef struct _tag_LinkListNode LinkListNode;

//结点指针域定义
struct _tag_LinkListNode
{
LinkListNode* next;
};

LinkList* LinkList_Create();

void LinkList_Destroy(LinkList* list);

void LinkList_Clear(LinkList* list);

int LinkList_Length(LinkList* list);

int LinkList_Insert(LinkList* list, LinkListNode* node, int pos);

LinkListNode* LinkList_Get(LinkList* list, int pos);

LinkListNode* LinkList_Delete(LinkList* list, int pos);

#endif

//LinkList.c

#include <stdio.h>
#include <malloc.h>
#include "LinkList.h"

//单链表表头结点定义
typedef struct _tag_LinkList
{
LinkListNode header;
int length;
} TLinkList;

LinkList* LinkList_Create() // O(1)
{
TLinkList* ret = (TLinkList*)malloc(sizeof(TLinkList));

if( ret != NULL )
{
ret->length = 0;
ret->header.next = NULL;
}

return ret;
}

void LinkList_Destroy(LinkList* list) // O(1)
{
free(list);
}

void LinkList_Clear(LinkList* list) // O(1)
{
   //list为void型，这里需要转化成TLinkList类型
TLinkList* sList = (TLinkList*)list;

if( sList != NULL )
{
sList->length = 0;
sList->header.next = NULL;
}
}

int LinkList_Length(LinkList* list) // O(1)
{
TLinkList* sList = (TLinkList*)list;
int ret = -1;

if( sList != NULL )
{
ret = sList->length;
}

return ret;
}

int LinkList_Insert(LinkList* list, LinkListNode* node, int pos) // O(n)
{
TLinkList* sList = (TLinkList*)list;

   //判断线性表和待插入结点及插入位置是否合法
int ret = (sList != NULL) && (pos >= 0) && (node != NULL);
int i = 0;

if( ret )
{
       //定义一个current指针，指向单链表的头结点
       //看结构体的定义，LinkListNode与TLinkList在内存地址相同，可以直接转
LinkListNode* current = (LinkListNode*)sList;
       //这里也可以不强制转化，通过结构体成员来调用
       //LinkListNode* current = &(sList->header);

       //从表头开始通过next指针移动pos次后，当前元素的next指针指向即指向要插入的位置
for(i=0; (i<pos) && (current->next != NULL); i++)
{
current = current->next;
}
//将新元素插入
node->next = current->next;
current->next = node;

       //线性表长度加1
sList->length++;
}

return ret;
}

LinkListNode* LinkList_Get(LinkList* list, int pos) // O(n)
{
TLinkList* sList = (TLinkList*)list;
LinkListNode* ret = NULL;
int i = 0;
//判断线性表和待插入结点及插入位置是否合法
if( (sList != NULL) && (0 <= pos) && (pos < sList->length) )
{
       //定义一个current指针，指向单链表的头结点
       //看结构体的定义，LinkListNode与TLinkList在内存地址相同，可以直接转
LinkListNode* current = (LinkListNode*)sList;
       //这里也可以不强制转化，通过结构体成员来调用
       //LinkListNode* current = &(sList->header);

       //获取第pos个元素
for(i=0; i<pos; i++)
{
current = current->next;
}

ret = current->next;
}

return ret;
}

LinkListNode* LinkList_Delete(LinkList* list, int pos) // O(n)
{
TLinkList* sList = (TLinkList*)list;
LinkListNode* ret = NULL;
int i = 0;

   //判断线性表和待插入结点及插入位置是否合法
if( (sList != NULL) && (0 <= pos) && (pos < sList->length) )
{
       //定义一个current指针，指向单链表的头结点
       //看结构体的定义，LinkListNode与TLinkList在内存地址相同，可以直接转
LinkListNode* current = (LinkListNode*)sList;

       //获取第pos个元素
for(i=0; i<pos; i++)
{
current = current->next;
}

ret = current->next;

       //将第pos个元素从链表中删除
current->next = ret->next;
//线性表长度减1
sList->length--;
}

return ret;
}

//测试文件main.c

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

//数据元素结构体定义
struct Value
{
LinkListNode header;
int v;
};

int main(int argc, char *argv[])
{
int i = 0;
LinkList* list = LinkList_Create();

struct Value v1;
struct Value v2;
struct Value v3;
struct Value v4;
struct Value v5;

v1.v = 1;
v2.v = 2;
v3.v = 3;
v4.v = 4;
v5.v = 5;

   //头插法
   //LinkList_Insert(list, (LinkListNode*)&v1, 0);
//LinkList_Insert(list, (LinkListNode*)&v2, 0);
//LinkList_Insert(list, (LinkListNode*)&v3, 0);
//LinkList_Insert(list, (LinkListNode*)&v4, 0);
//LinkList_Insert(list, (LinkListNode*)&v5, 0);

   //尾插法
LinkList_Insert(list, (LinkListNode*)&v1, LinkList_Length(list));
LinkList_Insert(list, (LinkListNode*)&v2, LinkList_Length(list));
LinkList_Insert(list, (LinkListNode*)&v3, LinkList_Length(list));
LinkList_Insert(list, (LinkListNode*)&v4, LinkList_Length(list));
LinkList_Insert(list, (LinkListNode*)&v5, LinkList_Length(list));

for(i=0; i<LinkList_Length(list); i++)
{
struct Value* pv = (struct Value*)LinkList_Get(list, i);

printf("%d\n", pv->v);
}

while( LinkList_Length(list) > 0 )
{
struct Value* pv = (struct Value*)LinkList_Delete(list, 0); //每次从头部删除元素
//struct Value* pv = (struct Value*)LinkList_Delete(list, LinkList_Length(list)-1); //每次从尾部删除元素
printf("%d\n", pv->v);
}

LinkList_Destroy(list);

return 0;
}

参考：

https://www.cnblogs.com/qiuxirufeng/p/12079387.html

https://blog.csdn.net/emdfans/article/details/16905211

lanhuazui10

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
线性表的链式实现(单链表)

单链表的定义为了表示每个数据元素与其直接后续元素之间的逻辑关系，每个元素除了存储本身的信息外，还需要存储指示其直接后续的信息，即每个结点存放本身的数据元素和下一个元素的地址。n个结点连接成一个链式线性表的结构我们叫做链表，当每个结点只包含一个指针域时，叫做单链表。首先给出一个线性表，存放数据元素，a1到 an有这样的线性逻辑关系。单链表在存储空间上是这样存放的，它是存放在任意位置的，这个任意位置表示它们不一定要连续。如图所示的 a2、a3与 a3、a4。第二个很明显的差别是单链表在存...
复制链接

扫一扫

专栏目录