学习笔记：2.3 线性表的链式表示和实现（单链表详解）

最新推荐文章于 2024-11-02 20:41:42 发布
最新推荐文章于 2024-11-02 20:41:42 发布
阅读量675 收藏 6
点赞数 15
分类专栏： 数据结构 学习笔记 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52344565/article/details/120516004
版权

2.3 线性表的链式表示和实现

这里写目录标题

（注意：所有代码均已成功测试。编译环境：devC++）

（一）复习：（线性顺序存储结构的优缺点）

优点：

  1. 无须为表示表中元素之间的逻辑关系而增加额外的存储空间。

  2. 可以迅速地存取表中任一位置的元素。

缺点：

  1. 插入和删除操作需要移动大量元素。（耗费时间）

  2. 当线性表长度变化较大时，难以确定存储空间的容量。

  3. 造成存储空间的 “碎片”。

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

1. 单链表

课本概念：用一组地址任意的存储单元存放线性表中的数据元素。

以元素(数据元素的映象) + 指针(指示后继元素存储位置)= 结点 (表示数据元素 或 数据元素的映象)

以“结点的序列”表示线性表称作链表。

在这里插入图片描述

以线性表中第一个数据元素 的存储地址作为线性表的地址，称作线性表的头指针。

有时为了操作方便，在第一个结点之前虚加一个“头结点”，以指向头结点的指针为链表的头指针。

线性表为空表时，头结点的指针域为空。

在这里插入图片描述

理解（要点）：

  • 链表是一种常用的数据结构，它通过指针将一些列数据结点，连接成一个数据链。相对于数组，链表具有更好的动态性（非顺序存储）。

在这里插入图片描述

  • 数据域用来存储数据，指针域用于建立与下一个结点的联系。

  • 建立链表时无需预先知道数据总量的，可以随机的分配空间 (链表的内存是非连续的)，可以高效的在链表中的任意位置实时插入或删除数据 (只需要修改指针即可）。

  • 链表的开销，主要是访问顺序性和组织链的空间损失（指针域空间的开销)。

简单理解数组和链表的区别：

数组：一次性分配一块连续的存储区域。

  • ​ 优点：随机访问元素效率高。
  • ​ 缺点： 1.需要分配一块连续的存储区域（很大区域，有可能分配失败）。

​ 2.删除和插入某个元素效率低。

链表：无需一次性分配一块连续的存储区域，只需分配n块节点存储区域，通过指针建立关系。

  • ​ 优点：1.不需要一块连续的存储区域。

    ​ 2.删除和插入某个元素效率高。

  • ​ 缺点：随机访问元素效率低。

1.1 结点和单链表的代码描述

结点的定义：

链表的节点类型实际上是结构体变量，此结构体包含数据域和指针域：

  • 数据域用来存储数据；

  • 指针域用于建立与下一个结点的联系，当此节点为尾节点时，指针域的值为NULL；

/* C语言线性表的单链表存储结构 */
typedef struct  LNode {
      ElemType      data;  // 数据域     typedef int ElemType;
      struct LNode   *next;  // 指针域
   } LNode;

typedef struct LNode *LinkList; //定义头指针。

理解：

p->data/p->next/p->next->data;

在这里插入图片描述

小编分析：p是指向线性表第i个元素的指针，则该节点a(i)的数据域可以用p->data来表示，它的值是数据元素，节点a(i)的指针域可以用p->next来表示；p->next指向第i+1个元素，即指向a(i+1)的指针。所以p->next->data即为a(i+1);

链表的初始化：
/* 初始化链式线性表 */
Status InitList(LinkList &L)   //typedef int Status;
{ 
    L=(LinkList)malloc(sizeof(LNode));    //c++: L = new LNode;
    if(!L) // 存储分配失败 
            return ERROR;
    L->next=NULL; //指针域为空 

    return OK;
}
判断链表是否为空：
/* 初始条件：链式线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE */
Status ListEmpty(LinkList L)
{ 
    if(L->next)
            return FALSE;
    else
            return TRUE;
}
清空单链表：

（核心思想：工作指针向后移，依次清空，释放内存）

/* 初始条件：链式线性表L已存在。操作结果：将L重置为空表 */
Status ClearList(LinkList &L)
{ 
	LinkList p,q;
	p=L->next;           // p指向第一个结点 
	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; // p指向第一个结点 
    while(p)                        
    {
        i++;
        p=p->next;
    }
    return i;
}
用e返回L中第i个数据元素的值：

（核心思想：工作指针向后移，遍历搜索）

算法思路：

(1）声明一个指针p指向链表第一个结点，初始化i从1开始;

(2）当j<i时,就遍历链表；让p的指针向后移动,不断指向下一结点,j累加1;

(3）若到链表末尾p为空,则说明第i个结点不存在;

(4）否则查找成功,返回结点p的数据。

/* 初始条件：链式线性表L已存在，1≤i≤ListLength(L) */
Status GetElem(LinkList L,int i,ElemType &e)
{
	int j;
	LinkList p;		// 声明一结点p 
	p = L->next;		// 让p指向链表L的第一个结点 
	j = 1;		//  j为计数器 
	while (p && j<i)  // p不为空或者计数器j还没有等于i时，循环继续 
	{   
		p = p->next;  // 让p指向下一个结点 
		++j;
	}
	if ( !p || j>i ) 
		return ERROR;  //  第i个元素不存在 
	e = p->data;   //  取第i个元素的数据 
	return OK;
}
返回L中第1个与e满足关系的数据元素的位序:

（核心思想：工作指针向后移，遍历链表判断是否符合条件）

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;
}
单链表的元素插入：

图解：

在这里插入图片描述
在这里插入图片描述
算法思路：

(1）声明一个指针p指向链表头结点，初始化j从1开始。

(2）当j<i时,就遍历链表；让p的指针向后移动,不断指向下一结点,j累加1。

(3）若到链表末尾p为空,则说明第i个结点不存在。

(4）否则查找成功,在系统中生成一个空结点s。

(5）将数据元素e赋值给s->data。

(6）由图解可知单链表的插入标准语句是s->next=p->next; p->next=s; (顺序切不可交换)。

(7）返回成功。

Status ListInsert(LinkList &L,int i,ElemType e)
{ 
	int j;
	LinkList p,s;
	p = L;   
	j = 1;
	while (p && j < i)    
	{
		p = p->next;
		++j;
	} 
	if (!p || j > i) 
		return ERROR;  
	s = (LinkList)malloc(sizeof(LNode));  
	s->data = e;  
	s->next = p->next;      /* 将p的后继结点赋值给s的后继  */
	p->next = s;          /* 将s赋值给p的后继 */
	return OK;
}
单链表的元素删除：

图解：

在这里插入图片描述
将前继结点绕过指向后继结点即可。

算法思路：

(1) 声明一结点p指向链表第一个结点,初始化j从1开始。

(2) 当j<i时，就遍历链表，让p的指针向后移动，不断指向下一个结点,j累加。

(3) 若到链表末尾p为空，则说明第i个元素不存在。

(4) 否则查找成功，将欲删除的结点p->next赋值给q。

(5) 单链表的删除标准语句p->next=q->next。

(6) 将q结点中的数据赋值给e，作为返回。

(7) 释放q结点。

Status ListDelete(LinkList &L,int i,ElemType &e) 
{ 
	int j;
	LinkList p,q;
	p = L->next;
	j = 1;
	while (p && 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;
}
单链表的整表创建：
1. 头插法
/* 建立带表头结点的单链线性表L（头插法） */
void CreateListHead(LinkList &L, int n) 
{
	LinkList p;
	int i;
	L = (LinkList)malloc(sizeof(LNode));
	L->next = NULL;                     
	for (i=0; i<n; i++) 
	{
		p = (LinkList)malloc(sizeof(LNode)); 
		p->data = (i+1)*10;            
		p->next = L->next;    
		L->next = p;					
	}
}
2. 尾插法
/*建立带表头结点的单链线性表L（尾插法） */
void CreateListTail(LinkList &L, int n) 
{
	LinkList p,r;
	int i;                    
	L = (LinkList)malloc(sizeof(LNode)); 
	r=L;                                
	for (i=0; i<n; i++) 
	{
		p = (LinkList)malloc(sizeof(LNode)); 
		p->data = (i+1)*10;          
		r->next=p;                        
		r = p;                           
	}
	r->next = NULL;                       
}
单链表的销毁：
Status DestroyList(LinkList &L){
	LinkList p;
	while(L){
		p=L;
		L=L->next;
		free(p); 
	}
	return OK;
}
单链表的打印：
Status ListTraverse(LinkList L)
{
    LinkList p=L->next;
    while(p)
    {
        printf("%d ",p->data);
        p=p->next;
    }
    printf("\n");
    return OK;
}
单链表的逆转：（有头结点）
void ReverseList(LinkList &L)
{
    LinkList old_head, new_head, Temp;
    new_head = NULL;
    old_head = L->next;

    while ( old_head )  {
        Temp = old_head->next;
        old_head->next = new_head;
        new_head = old_head;  
        old_head = Temp; 
    }
    
	L->next = new_head;
}
代码测试：
int main(){
	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=ListEmpty(L);
    printf("L是否空：i=%d(1:是 0:否)\n",i);
    
    i=ClearList(L);
    printf("清空L后：ListLength(L)=%d\n",ListLength(L));
    i=ListEmpty(L);
    printf("L是否空：i=%d(1:是 0:否)\n",i);
    
    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为表长 */
    printf("%d \n",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); 
    
    i=ListDelete(L,5,e); /* 删除第j个数据 */
    if(i==ERROR)
        printf("删除第%d个数据失败\n",j);
    else
        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,10);
    printf("整体创建L的元素(尾插法)：");
    ListTraverse(L); 
    LinkList pCur = L->next;
    
    k=ListLength(L); /* k为表长 */
    printf("ListLength(L)=%d \n",k); 
    
    printf("L逆转： "); 
    ReverseList(L);
    ListTraverse(L); 
	return 0;
}

在这里插入图片描述

希望可以对大家有帮助，若发现错误请及时反馈。

程序猿小张的日常笔记
关注
专栏目录
数据结构 学习笔记之：线性表——顺序表、静态链表、动态链表(单链表、双链表、单循环链表、双循环链表，链式栈、链式队列)——基础概念大扫盲！
可乐虎博客
03-12 2408
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 更多原创“uC/OS-II学习笔记之：系列”基础及嵌入式相关知识详解，请
单链表详解（学习笔记）
m0_61608863的博客
12-16 1363
链表是一种链式储存结构，在C语言中有着重要的作用。 而在如同我一样的初学者的学习过程中，链表的操作很有难度，故而有必要用博客记录学习过程，分享给大家的同时也自我巩固。 一.链表的概念和定义 相对于线性表，链表有许多优点，例如在线性表中，删除或插入元素的操作很复杂，需要将插入或删除位置的前/后元素不停地移动，倘若涉及到频繁地插入或者删除的操作，链表的优点就凸显出来了。 链表作为一种链式存储结构，其的存储内容除了要存的数据元素信息之外，还储存着后继元素的存储地址。为了表示链表中每一个存储元素a（i...
【数据结构】--章节2.3----线性表的链式表示和实现
1900的博客
09-19 914
存储结构 P28 typedef struct LNode{ int data; struct LNode *next; }LNode,*LinkList;
【数据结构】C语言实现单链表万字详解(附完整运行代码)
C/C++领域,数据结构,linux,MySQl学习者
11-11 734
使用C语言实现单链表程序的新手入门万字详解,包括每个函数的设计原理图示,设计思路,每步代码的注释以及程序完整实现代码.
java线性表详解,数据结构（java版）学习笔记（一）——线性表
weixin_33680141的博客
03-16 174
一、线性表的定义线性表是n(n>=0)个具有相同特性的数据元素的有限序列。线性表是最简单、最常用的一种数据结构线性表属于线性结构的一种如果一个数据元素序列满足：(1)除第一个和最后一个数据元素外，每个数据元素只有一个前驱数据元素和一个后继数据元素；(2)第一个数据元素没有前驱数据元素；(3)最后一个数据元素没有后继数据元素则可以称这样的数据结构为线性结构二、线性表的种类线性表的存储结构主要有...
【数据结构学习笔记】二、线性表---顺序表篇（1）（画图详解+代码实现）
大家好我叫张同学
12-29 3427
数据结构、算法图解、线性表、顺序表、链表
《大话数据结构》——学习笔记（概述&线性表）
benhuo931115的博客
12-18 2446
数据数据：是描述客观事物的符号，是计算机中可以操作的对象，是能被计算机识别，并输入给计算机处理的符号集合数据元素数据元素：是组成数据的、有一定意义的基本单位，在计算机中通常作为整体处理，也被称为记录数据项数据项：一个数据元素可以由若干个数据项组成，数据项是数据不可分割的最小单位数据对象数据对象：是性质相同的数据元素的集合，是数据的子集数据结构不同数据元素之间不是独立的，而是存在特定的关系，我们将这些
数据结构（C语言版） 第二章 线性表 知识梳理+作业习题详解
热门推荐
繁凡さん的博客
04-29 6万+
单链表顺序存储结构 单链表强调元素在逻辑上紧密相邻，所以首先想到用数组存储。但是普通数组有着无法克服的容量限制，在不知道输入有多少的情况下，很难确定出一个合适的容量。对此，一个较好的解决方案就是使用动态数组。首先用malloc申请一块拥有指定初始容量的内存，这块内存用作存储单链表元素，当录入的内容不断增加，以至于超出了初始容量时，就用calloc扩展内存容量，这样就做到了既不浪费内存，又可以让单链...
数据结构学习笔记（一）线性表
weixin_45880069的博客
05-28 2013
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、线性表是什么？线性结构线性表二、线性表的顺序表示和实现1.什么是线性表的顺序表示2.代码实现总结参考资料 前言 文章目的在于记录学习数据结构这门课程中遇到的知识点以及难点，为解决或优化实际代码问题打好基础 一、线性表是什么？ 线性结构 想要理解线性表，首先明确一个概念：线性结构 线性结构有以下特点： 1. 存在唯一的首元素（被称为第一个的数据元素） 2. 存在唯一的末元素（被称为最后一个的数据元素） 3. 除第一个元素
武汉大学数据结构考研详笔记：线性表与栈队列详解
涉及的内容包括线性表的基本概念（如前驱、后继、表长等）、顺序存储与链式存储的不同实现（静态分配和动态分配）、单链表、循环链表、双向链表及其操作（如插入、删除和归并算法），以及不同链表类型判空的方法。...
数据结构详解：线性表的顺序表示与动态分配
"这篇文档是基于《王道数据结构》和其他相关资料整理的数据结构学习笔记，主要关注线性表这一重要概念。文档详述了线性结构的定义、特点以及线性表的顺序表示，包括静态和动态分配两种实现方式。" 在计算机科学中，...
软考数据结构基础：线性表详解与存储结构
本资源是一份关于软考数据结构基础的学习笔记，主要聚焦于线性表的概念及其两种...这份学习笔记涵盖了线性表的基础概念，其存储结构的优缺点，以及栈的特性和实现方式，对理解和掌握数据结构的入门级知识具有重要意义。
通用型函数——冒泡排序
2401_84654619的博客
10-29 391
计算机中，任何数据最终都是二进制数，故只需有足够的空间，就可以将任何数据存储起来，相应的，读取时使用数据类型容器识别就可还原原本的意思。memcpy函数用于将指定数量的字节从源内存地址（src）复制到目标内存地址（dest）。n : 要复制的字节数，类型为size_t表示要复制的字节的数量。代码：（char型）
栈和队列（数据结构）
etamaos的博客
10-28 324
1.创建新队列（结点；
数据结构和算法-动态规划(3)-经典问题
qq_36115196的博客
10-30 818
动态规划(Dynamic Programming): 计算并存储小问题的解， 并将这些解组合成大问题的解。
java-数据结构
2301_80708315的博客
10-30 980
如果使用 left < right 作为条件，那么在最后一次迭代中，当 left 和 right 相邻时（即 left = right - 1），循环就会提前终止，从而可能错过目标元素（如果它正好位于 left 或 right 指向的位置）。left ==right 意味着它们指向的元素也会参与比较，left < right 只意味着middle指向的元素参与比较。l为总循环次数，当元素在最右边与最左边时的循环次数不一致。eg 当我的数组为{1，23，45，77，123}时我查找12时就会返回。
【数据结构篇】探索堆的算法的巧妙
braveact的博客
11-02 539
⽤剩余的N-K个元素依次与堆顶元素来⽐较，不满⾜则替换堆顶元素 ，然后再将交换进去后的元素向下调整（保证这k个元素始终是堆），最后将剩余N-k个元素依次与堆顶元素⽐完之后，堆中剩余的K个元素就是所求的前k个最⼩或者最⼤的元素。对于Top-K问题，能想到的最简单直接的⽅式就是排序，但是：如果数据量⾮常⼤，排序就不太可取了 (可能数据都不能⼀下⼦全部加载到内存中)。依次将堆顶最大的数据与最后一个（不断发生变化）元素交换，每次都是将最大的数据放最后，可以想象一下，就是升序了。前k个最⼩的元素，则建⼤堆。
数据结构，问题 F: 括弧匹配检验
最新发布
nick_912912的博客
11-02 180
假设表达式中允许包含两种括号：圆括号和方括号，其嵌套的顺序随意，如（［ ］（））或［（［ ］［ ］）］等为正确的匹配，［（ ]）或（［ ］（ ）或 ( ( ) ) ）均为错误的匹配。输入一个只包含圆括号和方括号的字符串，判断字符串中的括号是否匹配，匹配就输出 “OK” ，不匹配就输出“Wrong”。匹配就输出 “OK” ，不匹配就输出“Wrong”。现在的问题是，要求检验一个给定表达式中的括弧是否正确匹配？输入仅一行字符（字符个数小于255）输入一个字符串：［（［］［］）］，输出：OK。
数据结构初识及顺序表详解
chuxinweihui的博客
11-01 862
我们在写程序的时候，会出现许多的数据，如果我们想要修改某一个值或者删除和添加一个数据的时候就会非常困难，尤其是数据量庞大的时候，这时候数据结构就出来了。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

程序猿小张的日常笔记

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

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

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

打赏作者

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

抵扣说明：

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

余额充值