数据结构之线性表的链式存储

已于 2022-04-27 21:10:22 修改
阅读量773 收藏 1
点赞数 2
分类专栏： 数据结构 文章标签： c语言 数据结构
于 2022-04-27 20:52:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AHuRui/article/details/124453661
版权

文章目录

线性表的链式存储结构（单链表）

这里是数据结构个人学习的笔记记录，如有问题欢迎指正说明

单链表的定义

n个结点链结成一个链表。每个结点由数据域和指针域两部分组成，在此处我们之研究结点只含一个指针域的链表，即单链表。
单链表定义

我们把链表中的第一个结点的存储位置叫做头指针，整个链表的存取必须从头指针开始。为了方便操作，我们还可以在单链表的第一个结点前附设一个结点，称为头结点。注意头结点不是必不可少的。头结点和头指针的区别如下图：
头指针和头结点的异同

单链表的相关操作实现

基础宏定义

使用这些宏定义能增强代码的阅读性和通用性

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

#define MAXSIZE 20

typedef int Status;/*函数结果状态代码*/
typedef int ElemType;/*待存储数据的数据类型*/

基本结构体

typedef struct Node
{
    ElemType data;
    struct Node *next;
}Node;
typedef Node *LinkList;

初始化

/* 初始化 */
Status InitList(LinkList *L)
{
    *L=(LinkList)malloc(sizeof(Node));
    if(!(*L))
    return ERROR;
    (*L)->next=NULL;/*指针域为空*/

    return OK;
}

依次对单链表中的每个数据元素输出

/* 依次对L的每个数据元素输出 */
Status ListTraverse(LinkList L)
{
    LinkList p=L->next;
    while(p)
    {
        visit(p->data);//vist函数为输出值
        p=p->next;
    }
    printf("\n");
    return OK;
}

返回单链表中元素的个数

/*返回L中数据元素个数*/
int ListLength(LinkList L)
{
    int i=0;
    LinkList p=L->next;
    while(p)
    {
        i++;
        p=p->next;
    }
    return i;
}

在单链表中指定位置之前插入新的数据元素

插入操作

/* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */
Status ListInsert(LinkList *L,int i,ElemType e)
{
    int j=1;
    LinkList p,s;
    p=*L;
    while(p&&j<i)
    {
        p=p->next;
        ++j;
    }
    if(!p||j>i)
    return ERROR;
    s=(LinkList)malloc(sizeof(Node));
    s->data=e;
    s->next=p->next;
    p->next=s;
    return OK;
}

删除线性表的指定位置的数据元素

在这里插入图片描述

/* 删除线性表的指定位置的数据元素 */
Status ListDelete(LinkList *L,int i,ElemType *e)
{
    int j=1;
    LinkList p,q;
    p=*L;
    while(p->next&&j<i)
    {
        p=p->next;
        ++j;
    }
    if(!(p->next)||j>i)
    return ERROR;
    q=p->next;
    p->next=q->next;
    *e=q->data;
    free(q);
    return OK;
}

返回单链表中第一个与指定数据相符的数据的位序

/* 返回L中第1个与e满足关系的数据元素的位序。 */
/* 若这样的数据元素不存在，则返回值为0 */
int LocateElem(LinkList L,ElemType e)
{
    int i=0;
    LinkList p=L->next;
    while(p)
    {
        i++;
        if(p->data==e)
        return i;
        p=p->next;
    }
    return 0;
}

返回指定位置的值

/* 用e返回L中第i个数据元素的值 */
Status GetElem(LinkList L,int i,ElemType *e)
{
    int j=1;
    LinkList p;
    p=L->next;
    while(p&&j<i)
    {
        p=p->next;
        ++j;
    }
    if(!p||j>i)
    return ERROR;
    *e=p->data;
    return OK;
}

将单链表重置为空表

/* 将L重置为空表 */
Status ClearList(LinkList *L)
{
    LinkList p,q;
    p=(*L)->next;
    while(p)
    {
        q=p->next;
        free(p);
        p=q;
    }
    (*L)->next=NULL;
    return OK;
}

头插的实现

/*  随机产生n个元素的值，建立带表头结点的单链线性表L（头插法） */
void CreateListHead(LinkList *L,int n)
{
    LinkList p;
    int i;
    srand(time(0));
    *L=(LinkList)malloc(sizeof(Node));
    (*L)->next=NULL;
    for(i=0;i<n;i++)
    {
        p=(LinkList)malloc(sizeof(Node));
        p->data=rand()%100+1;
        p->next=(*L)->next;
        (*L)->next=p;
    }
}

尾插的实现

/*  随机产生n个元素的值，建立带表头结点的单链线性表L（尾插法） */
void CreateListTail(LinkList *L, int n) 
{
	LinkList p,r;
	int i;
	srand(time(0));                   
	*L = (LinkList)malloc(sizeof(Node)); 
	r=*L;                           
	for (i=0; i<n; i++) 
	{
		p = (Node *)malloc(sizeof(Node)); 
		p->data = rand()%100+1;     
		r->next=p;                        
		r = p;                          
	}
	r->next = NULL;                     
}

链式存储的代码实现

#include<stdio.h>
#include<stdlib.h>
#include<ctype.h>
#include<math.h>
#include<time.h>

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

#define MAXSIZE 20

typedef int Status;
typedef int ElemType;

typedef struct Node
{
    ElemType data;
    struct Node *next;
}Node;
typedef Node *LinkList;

Status visit(ElemType c)
{
    printf("%d ",c);
    return OK;
}
/* 初始化链式线性表 */
Status InitList(LinkList *L)
{
    *L=(LinkList)malloc(sizeof(Node));
    if(!(*L))
    return ERROR;
    (*L)->next=NULL;

    return OK;
}
/* 初始条件：链式线性表L已存在。操作结果：将L重置为空表 */
Status ClearList(LinkList *L)
{
    LinkList p,q;
    p=(*L)->next;
    while(p)
    {
        q=p->next;
        free(p);
        p=q;
    }
    (*L)->next=NULL;
    return OK;
}
/* 初始条件：链式线性表L已存在。操作结果：返回L中数据元素个数 */
int ListLength(LinkList L)
{
    int i=0;
    LinkList p=L->next;
    while(p)
    {
        i++;
        p=p->next;
    }
    return i;
}
/* 初始条件：链式线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：用e返回L中第i个数据元素的值 */
Status GetElem(LinkList L,int i,ElemType *e)
{
    int j=1;
    LinkList p;
    p=L->next;
    while(p&&j<i)
    {
        p=p->next;
        ++j;
    }
    if(!p||j>i)
    return ERROR;
    *e=p->data;
    return OK;
}
/* 初始条件：链式线性表L已存在 */
/* 操作结果：返回L中第1个与e满足关系的数据元素的位序。 */
/* 若这样的数据元素不存在，则返回值为0 */
int LocateElem(LinkList L,ElemType e)
{
    int i=0;
    LinkList p=L->next;
    while(p)
    {
        i++;
        if(p->data==e)
        return i;
        p=p->next;
    }
    return 0;
}
/* 初始条件：链式线性表L已存在,1≤i≤ListLength(L)， */
/* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */
Status ListInsert(LinkList *L,int i,ElemType e)
{
    int j=1;
    LinkList p,s;
    p=*L;
    while(p&&j<i)
    {
        p=p->next;
        ++j;
    }
    if(!p||j>i)
    return ERROR;
    s=(LinkList)malloc(sizeof(Node));
    s->data=e;
    s->next=p->next;
    p->next=s;
    return OK;
}
/* 初始条件：链式线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 */
Status ListDelete(LinkList *L,int i,ElemType *e)
{
    int j=1;
    LinkList p,q;
    p=*L;
    while(p->next&&j<i)
    {
        p=p->next;
        ++j;
    }
    if(!(p->next)||j>i)
    return ERROR;
    q=p->next;
    p->next=q->next;
    *e=q->data;
    free(q);
    return OK;
}
/* 初始条件：链式线性表L已存在 */
/* 操作结果：依次对L的每个数据元素输出 */
Status ListTraverse(LinkList L)
{
    LinkList p=L->next;
    while(p)
    {
        visit(p->data);
        p=p->next;
    }
    printf("\n");
    return OK;
}
/*  随机产生n个元素的值，建立带表头结点的单链线性表L（头插法） */
void CreateListHead(LinkList *L,int n)
{
    LinkList p;
    int i;
    srand(time(0));
    *L=(LinkList)malloc(sizeof(Node));
    (*L)->next=NULL;
    for(i=0;i<n;i++)
    {
        p=(LinkList)malloc(sizeof(Node));
        p->data=rand()%100+1;
        p->next=(*L)->next;
        (*L)->next=p;
    }
}
/*  随机产生n个元素的值，建立带表头结点的单链线性表L（尾插法） */
void CreateListTail(LinkList *L, int n) 
{
	LinkList p,r;
	int i;
	srand(time(0));                   
	*L = (LinkList)malloc(sizeof(Node)); 
	r=*L;                           
	for (i=0; i<n; i++) 
	{
		p = (Node *)malloc(sizeof(Node)); 
		p->data = rand()%100+1;     
		r->next=p;                        
		r = p;                          
	}
	r->next = NULL;                     
}
void ListTest()
{        
    LinkList L;
    ElemType e;
    Status i;
    int j,k;
    i=InitList(&L);
    printf("初始化L后:ListLength(L)=%d\n",ListLength(L));
    for(j=1;j<=5;j++)
            i=ListInsert(&L,1,j);
    printf("在L的表头依次插入1~5后:L.data=");
    ListTraverse(L); 
    printf("ListLength(L)=%d \n",ListLength(L));

    i=ClearList(&L);
    printf("清空L后:ListLength(L)=%d\n",ListLength(L));

    for(j=1;j<=10;j++)
            ListInsert(&L,j,j);
    printf("在L的表尾依次插入1:10后:L.data=");
    ListTraverse(L); 
    printf("ListLength(L)=%d \n",ListLength(L));

    ListInsert(&L,1,0);
    printf("在L的表头插入0后:L.data=");
    ListTraverse(L); 
    printf("ListLength(L)=%d \n",ListLength(L));

    GetElem(L,5,&e);
    printf("第5个元素的值为:%d\n",e);
    for(j=3;j<=4;j++)
    {
            k=LocateElem(L,j);
            if(k)
                    printf("第%d个元素的值为%d\n",k,j);
            else
                    printf("没有值为%d的元素\n",j);
    }
    
    k=ListLength(L); /* k为表长 */
    for(j=k+1;j>=k;j--)
    {
            i=ListDelete(&L,j,&e); /* 删除第j个数据 */
            if(i==ERROR)
                    printf("删除第%d个数据失败\n",j);
            else
                    printf("删除第%d个的元素值为:%d\n",j,e);
    }
    printf("依次输出L的元素:");
    ListTraverse(L); 

    j=5;
    ListDelete(&L,j,&e); /* 删除第5个数据 */
    printf("删除第%d个的元素值为:%d\n",j,e);

    printf("依次输出L的元素:");
    ListTraverse(L); 

    i=ClearList(&L);
    printf("\n清空L后:ListLength(L)=%d\n",ListLength(L));
    CreateListHead(&L,20);
    printf("整体创建L的元素(头插法):");
    ListTraverse(L); 
    
    i=ClearList(&L);
    printf("\n删除L后:ListLength(L)=%d\n",ListLength(L));
    CreateListTail(&L,20);
    printf("整体创建L的元素(尾插法):");
    ListTraverse(L); 
}
int main()
{
    ListTest();

    return 0;
}

样例测试输出

初始化L后:ListLength(L)=0
在L的表头依次插入1~5后:L.data=5 4 3 2 1
ListLength(L)=5
清空L后:ListLength(L)=0
在L的表尾依次插入1:10后:L.data=1 2 3 4 5 6 7 8 9 10
ListLength(L)=10
在L的表头插入0后:L.data=0 1 2 3 4 5 6 7 8 9 10
ListLength(L)=11
第5个元素的值为:4
第4个元素的值为3
第5个元素的值为4
删除第12个数据失败
删除第11个的元素值为:10
依次输出L的元素:0 1 2 3 4 5 6 7 8 9
删除第5个的元素值为:4
依次输出L的元素:0 1 2 3 5 6 7 8 9
清空L后:ListLength(L)=0
整体创建L的元素(头插法):87 50 42 93 84 66 26 28 64 76 46 68 59 87 22 2 25 39 66 33
删除L后:ListLength(L)=0
整体创建L的元素(尾插法):33 66 39 25 2 22 87 59 68 46 76 64 28 26 66 84 93 42 50 87

链式存储的优缺点

优点：存储空间可自由扩充
插入、删除等操作不必移动数据，修改效率较高
缺点：读写效率不高，必须采用顺序读取

ALuoJi
关注
专栏目录
c语言链表的重置,将单链表重置为空表
weixin_35192322的博客
05-21 3220
当我们不打算使用某个单链表时，就需要把它销毁，其实也就是在内存中将它释放掉，以便于留出空间给其他程序或软件使用。置空单链表应该挺简单的吧，我先写写函数。/* 初始条件：顺序线性表L已存在。操作结果：将L重置为空表 */Status ClearList(LinkList *L){LinkList p;p=(*L)->next; /* p指向第一个结点 */while(p)...
C语言实现链表之单向链表（四）清空链表
君临天下的博客
11-08 7044
C语言实现链表之单向链表（四）清空链表     上一篇文章给出了创建链表的函数，本篇文章将给出清空链表的函数，程序如下。 /*============================================================================== * 操作 ：清空链表，释放结点内存，将链表重置为空表 * 操作前：ppHeadNod
单链表的清空
热门推荐
hunjiancuo5340的博客
06-15 1万+
转自：https://blog.csdn.net/dan15188387481/article/details/49721749 C语言实现链表之单向链表（四）清空链表 &nbsp; &nbsp; 上一篇文章给出了创建链表的函数，本篇文章将给出清空链表的函数，程序如下。 [cpp] view plain copy ...
数据结构——线性表（链式存储结构）
qq_55869380的博客
04-09 2864
链表的13种操作 实现思路和代码
数据结构——线性表的链式存储
weixin_69224277的博客
10-01 1541
一看就会的单链表知识
数据结构-线性表的链式存储（包含代码实现）
qq_46338854的博客
05-05 8975
线性表的链式表示和实现 链式存储结构 结点在存储器中的位置是任意的，即逻辑上相邻的数据元素在物理上不一定相邻 线性表的链式存储结构又称为非顺序映像或链式映像。 用一组物理位置任意的存储单元来存放线性表的数据元素 这组存储单元既可以是连续的，也可以是不连续的，甚至是零散分布在内存中的任意位置上的。 链表中元素的逻辑次序和物理次序不一定相同 与链式存储结构相关的术语 1、结点：数据元素的存储映像。由数据域和指针域两部分组成 数据域：存放元素数值数据 指针域：存放直接后继结点的存储位置 2、链表：n个结点
数据结构实验三 线性表的链式存储结构及实现
qq_64314976的博客
08-06 4525
1、掌握线性表的逻辑结构2、熟练掌握线性表的链式存储结构定义及基本操作3、加深对链式存储数据结构的理解，逐步培养解决实际问题的编程能力1、演示程序运行结果2、分析调试过程中出现的现象3、总结单链表基本操作的特点4、分析算法的时间复杂度编写程序，实现单链表的创建、插入和删除等基本操作算法。(1) 创建带头结点的单链表。(3) 查找值为给定值的元素，如果找到返回其位序，否则返回0(4) 在单链表的特定位置插入任意元素并输出单链表中的各元素值。.........
数据结构之线性表的链式存储2.0
AHuRui的博客
04-27 1664
文章目录线性表的链式存储结构（单链表）单链表的定义单链表的相关操作实现初始化依次对单链表中的每个数据元素输出在单链表中指定位置之前插入新的数据元素删除线性表中指定的数据元素尾插的实现新增操作返回单链表中元素的个数头插的实现整表删除链式存储的代码实现样例测试输出链式存储的优缺点写在最后 线性表的链式存储结构（单链表） 这里是数据结构个人学习的笔记记录，如有问题欢迎指正说明 单链表的定义 n个结点链结成一个链表。每个结点由数据域和指针域两部分组成，在此处我们之研究结点只含一个指针域的链表，即单链表。
《数据结构》线性表——链式存储结构
执着&你
04-01 2729
线性表链式存储结构简称链表，与顺序不同的是链表中的结点不仅包含有元素本身的信息，还包含有元素之间的逻辑关系的信息！！！
数据结构-线性表的顺序、链式存储结构
qq_61167424的博客
03-21 4790
一篇文章带你了解线性表的顺序、链式存储结构
数据结构实验报告2线性表的链式存储结构.pdf
09-30
数据结构实验报告2线性表的链式存储结构 本实验报告的主要内容是介绍线性表的链式存储结构，并通过编程实验来掌握线性表的逻辑结构和链式存储结构，以及单链表的基本算法。 一、线性表的概念 线性表是最基本的...
数据结构-线性表的链式存储
09-17
线性表的链式存储是数据结构课程中的核心概念之一，它的主要特点是通过链接而非内存位置连续来组织数据。 链式存储与顺序存储是线性表的两种基本实现方式。顺序存储（如数组）要求所有元素在内存中是连续存放的，而...
数据结构之线性表的链式存储结构
11-06
数据结构线性表的链式存储结构，使用c语言完成。线性表的链式存储结构的特点是用一组任意的存储单元存储线性表的数据元素。
漫话数据结构-线性表的链式存储.pptx
11-03
线性表是计算机科学中一种基础且重要的数据结构，它由有限个相同类型的数据元素构成，元素之间存在着一对一的线性关系。线性表的链式存储是相对于顺序存储的一种方式，尤其适用于动态变化的数据集合。 在链式存储中...
数据结构实验报告2线性表的链式存储结构.doc
07-11
在实际应用中，链式存储结构常用于实现各种复杂数据结构，如图和树。在处理不确定数据量或频繁进行插入、删除操作的场景下，链式存储通常比顺序存储更优。实验报告的编写有助于巩固理论知识，提高实践能力，同时培养...
数据结构 —— 链式二叉树（C语言讲解）
知其然 知其所以然
10-17 746
本篇文章主要讲解链式存储的二叉树，如果读者不清楚二叉树的基础知识，推荐阅读数据结构——树和二叉树简介。对于二叉树这种数据结构的学习，重点不是增删改查，而是学习这种结构，所以，主要讲解一些链式二叉树的操作。
前端常用算法和数据结构
renqq001的博客
10-17 300
前端常用算法和数据结构
#数据结构（一）
2302_79847831的博客
10-17 199
2 创造顺序表3 判断是否为空4遍历输出5 查找索引位置6 删除7 在固定位置插入。
数据结构(8.2_1)——插入排序
最新发布
m0_65240792的博客
10-17 201
算法思想：每次将一个待排序的记录按其关键字大小插入到前面已排序好的子序列中，直到全部记录插入完成。 代码实现 (带哨兵) 空间复杂度：O(1)时间复杂度:主要来自对比关键字，移动元素，若有n个元素，则需要n-1趟处理最好情况：共n-1趟处理，每一趟只需要对比关键字1次，不用移动元素———O(n)最坏情况：第1趟：对比关键字2次，移动元素3次第2趟：对比关键字3次，移动元素4次...第i趟：对比关键字i+1次，移动元素i+2次———O(n^2)平均时间复杂度：O(n^2) 思路：先用折半查找
谭浩强C语言数据结构-线性表与链式存储解析
动态线性表使用链式存储结构，每个节点包含数据域和指向下一个节点的指针。这样，插入和删除操作只需要修改指针，而不需要移动其他元素，提高了效率。 此外，文档还提及了栈和队列，这两种都是线性数据结构的特例。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

ALuoJi

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

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

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

打赏作者

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

抵扣说明：

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

余额充值