单链表——线性表的链式存储

最新推荐文章于 2023-06-14 02:03:18 发布
最新推荐文章于 2023-06-14 02:03:18 发布
阅读量649 收藏 4
点赞数
分类专栏： 数据结构 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_73926427/article/details/129396260
版权

单链表—— Singly Linked List

一、单链表的定义

单链表：线性表的链式存储，它是通过一组任意的存储单元来存储线性表中的数据元素，不需要使用地址连续的存储单元，因此它不要求在逻辑上相邻的两个元素在物理位置上也相邻。

二、单链表的特点

①不能随机访问：遍历查找访问

②存储密度不高：每个节点既要存数据元素又要存指针

③拓展容量方便：直接用建立单链表拓展

④插入、删除操作方便：知道位置直接插入和删除

三、单链表的实现方式

实现方式：不带头结点和带头结点，一般带头结点比不带头结点好

带头结点：写操作代码方便，一般用带头结点，不明确的都是带头结点的

不带头结点：写操作代码麻烦，要区分第一个数据和后续数据的处理

注：这两种方式主要是：类型描述相同，初始化和判空不同

四、单链表上的操作

单链表的类型描述
typedef struct LNode{    //定义单链表结点类型
	int data;            //数据域，可以是别的各种数据类型，本文统一用int类型
	struct LNode *next;  //指针域
}LNode, *LinkList;
初始化和判空

在这里插入图片描述

不带头结点的初始化和判空
//初始化
void InitList(LinkList &L){
    L = NULL;
    L->next = NULL;
}

//判空操作
bool Empty(LinkList L){
    if(L == NULL){
        return true;
    }else{
        return false;
    }
}
带头结点的初始化和判空
//初始化
void InitList(LinkList &L){
    L = (LNode *)malloc(sizeof(LinkList));
    L->next = NULL;
}

//判空操作
bool Empty(LinkList L){
    if(L->next == NULL){
        return true;
    }else{
        return false;
    }
}
建立单链表
头插法建立单链表

用于链表的逆置

在这里插入图片描述

//头插法建立单链表
LinkList HeadInsert(LinkList &L){
    InitList(L); //初始化
    int x;
    cin>>x;
    while(x!=9999){ //输入9999表示结束
        LNode *s = (LNode *)malloc(sizeof(LNode));
        s->data = x;
        s->next = L->next;
        L->next = s;
        cin>>x;
    }
    return L;
}
尾插法建立单链表

在这里插入图片描述

//尾插法建立单链表
LinkList TailInsert(LinkList &L){
    InitList(L);
    LNode *s,*r=L;
    int x;
    cin>>x;
    while(x!=9999){
        s = (LNode *)malloc(sizeof(LNode));
        s->data = x;
        r->next = s;
        r = s;
        cin>>x;
    }
    r->next = NULL;
    return L;
}
插入

时间复杂度=O(1)

带头结点的插入
//将x插入到单链表L的第i个位置上
bool Insert(LinkList &L, int i, int e){
    if(i<1) return false;
    LNode *p = GetElem(L,i-1);    //查找第i个位置
    return InsertNextNode(p, e);  //用后插操作，插在p后面
}
不带头结点的插入
//将x插入到单链表L的第i个位置上
bool Insert(LinkList &L, int i, int e){
    if(i<1) return false;
    if(i==1){
        LNode *s = (LNode *)malloc(sizeof(LNode));
    	s->data = e;
    	s->next = L;
    	L = s;
        return true;
    }
    LNode *p = GetElem(L,i-1);    //查找第i个位置
    return InsertNextNode(p, e);  //用后插操作，插在p后面
}
指定结点的后插操作
//后插操作：在p结点之后插入元素e
bool InsertNextNode(LNode *p, int e){
    if(p==NULL) return false;
    LNode *s = (LNode *)malloc(sizeof(LNode));
	if(s==NULL) return false;
    s->data = e;
    s->next = p->next;
    p->next = s;
    return true;
}
指定结点的前插操作

还是插在p后面，只不过让p和插入结点的值交换

//前插操作：在p结点之前插入元素e
bool InsertPriorNode(LNode *p, int e){
    if(p==NULL) return false;
    LNode *s = (LNode *)malloc(sizeof(LNode));
	if(s==NULL) return false;
    s->next = p->next;
    p->next = s;
    s->data = p->data;
    p->data = e;
    return true;
}
删除
按位序删除
//删除操作:将单链表中的第i个结点删除
bool Delete(LinkList &L, int i int &e){
    if(i<1 || i>Length(L))
        return false;
    LNode *p = GetElem(L,i-1);  //查找第i个位置
    LNode *q = p->next;
    e = q->data;
    p->next = q->next;
    free(q);
    return true;
}
按位序删除的时间复杂度：

最好情况：删除第一个，不需查找位置，循环0次，最好时间复杂度=O(1)

最坏情况：删除最后一个，需查找第n位，循环n次，最坏时间复杂度=O(n)

平均情况：删除任意一个，平均时间复杂度=O(n)

指定结点的删除

时间复杂度=O(n)

方法：p的后一个为q，p指向q的下一个，把q的值给p，最后释放q

//删除指定结点p
bool Delete(LNode *p){
    if(p==NULL) return false;
    LNode *q = p->next;
    p->data = q->data
    p->next = q->next;
    free(q);
    return true;
}
查找
按位查找

平均时间复杂度=O(n)

//按位查找：查找在单链表L中第i个位置的结点
LNode *GetElem(LinkList L, int i){
    int j=0;
    LNode *p = L;
    if(i<0) return NULL;
    while(p && j<i){
        p = p->next;
        j++;
    }
    return p; //如果i大于表长，p=NULL,直接返回p即可
}
按值查找

平均时间复杂度=O(n)

//按值查找：查找e在L中的位置
LNode *LocateElem(LinkList L, int e){
    LNode *p = L->next;
    while(p && p->data != e){
        p = p->next;
    }
    return p;
}
求表长

平均时间复杂度=O(n)

//求表的长度
int Length(LinkList L){
    int len = 0;
    LNode *p = L;
    while(P->next){
        p = p->next;
        len++;
    }
    return len;
}
遍历
//遍历操作
void PrintList(LinkList L){
    LNode *p = L->next;
    while(p){
        cout<<p->data<<" ";
        p = p->next;
    }
    cout<<endl;
}

五、完整代码

#include<bits/stdc++.h>
using namespace std;

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

//初始化
void InitList(LinkList &L){
    L = (LNode *)malloc(sizeof(LinkList));
    L->next = NULL;
}

//遍历操作
void PrintList(LinkList L){
    LNode *p = L->next;
    while(p){
        cout<<p->data<<" ";
        p = p->next;
    }
    cout<<endl;
}

//求单链表的长度
int Length(LinkList L){
    LNode *p = L->next;
    int len = 0;
    while(p){
        len++;
        p = p->next;
    }
    return len;
}

//头插法建立单链表
LinkList HeadInsert(LinkList &L){
    InitList(L); //初始化
    int x;
    cin>>x;
    while(x!=9999){
        LNode *s = (LNode *)malloc(sizeof(LNode));
        s->data = x;
        s->next = L->next;
        L->next = s;
        cin>>x;
    }
    return L;
}

//尾插法建立单链表
LinkList TailInsert(LinkList &L){
    InitList(L);
    LNode *s,*r=L;
    int x;
    cin>>x;
    while(x!=9999){
        s = (LNode *)malloc(sizeof(LNode));
        s->data = x;
        r->next = s;
        r = s;
        cin>>x;
    }
    r->next = NULL;
    return L;
}

//按值查找：查找x在L中的位置
LNode *LocateElem(LinkList L, int x){
    LNode *p = L->next;
    while(p && p->data != x){
        p = p->next;
    }
    return p;
}

//按位查找：查找在单链表L中第i个位置的结点
LNode *GetElem(LinkList L, int i){
    int j=1;
    LNode *p = L->next;
    if(i==0)return L;
    if(i<1)return NULL;
    while(p && j<i){
        p = p->next;
        j++;
    }
    return p; //如果i大于表长，p=NULL,直接返回p即可
}

//将x插入到单链表L的第i个位置上
void Insert(LinkList &L, int i, int x){
    LNode *p = GetElem(L,i-1);
    LNode *s = (LNode *)malloc(sizeof(LNode));
    s->data = x;
    s->next = p->next;
    p->next = s;
}

//删除操作:将单链表中的第i个结点删除
void Delete(LinkList &L, int i){
    if(i<1 || i>Length(L)){
        cout<<"delete failed: index is wrong."<<endl;
        return;
    }
    LNode *p = GetElem(L,i-1);
    LNode *q = p->next;
    p->next = q->next;
    free(q);
}


int main(){
    //初始化，尾插法建立单链表
    LinkList L = TailInsert(L);
    //插入：在第二个位置插入结点，数据域为888，并遍历单链表
    Insert(L,2,888);
    cout<<"在第二个位置插入888： ";
    PrintList(L);
    //删除：删除第四个结点
    Delete(L,4);
    cout<<"删除第四个结点后：";
    PrintList(L);
    //按位查找：查找第三个结点，并输出其数据域的值
    LNode *p = GetElem(L,3);
    cout<<"第三个结点的值为："<<p->data<<endl;
    //按值查找：查找数据域为2的结点的指针
    LNode *q = LocateElem(L,2);
    cout<<"数据为2的结点的下一个结点的值为："<<q->next->data<<endl;
    //输出单链表的长度
    cout<<"单链表的长度："<<Length(L)<<endl;
    return 0;
}
运行结果：

在这里插入图片描述

Ju-un
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构——线性表(选择题).docx
07-11
简单，线性表的链式存储原理，02702004 [单选题] A、必须是连续的 B、一定是不连续的 C、部分地址必须是连续的 D、连续与否均可以(正确答案) 数据结构——线性表(选择题)全文共11页，当前为第1页。 数据结构——...
【数据结构】第二章线性表：单链表的定义、插入和删除、查找、建立
weixin_37706349的博客
10-13 3234
2.3.1 单链表的定义 用链式存储的线性表统称为链表，本小节将会依次学习单链表、双链表、循环链表、静态链表。 一、什么是单链表 二、用代码定义一个单链表 （1）结构体变量和结构体类型的定义 菜鸟教程链接： 结构体变量和结构体类型的定义 | 菜鸟教程 typedef 关键字，将 struct LNode 这个结构体类型名字重新定义为 LNode 和 *LinkList（用来表示指向struct LNmde的指针）； 下次想定义一个 struct LNode 结构体变量时，直接 L..
线性表的链式存储结构——链表及其操作(创建,查找,插入,输出,删除)
striver的博客
03-13 1万+
文章目录1.单链表的建立1.1头插法1.2尾插法2.链表基本操作 1.单链表的建立 1.1头插法 1)从一个空表开始，创建一个头结点。 2)依次读取数组a中的元素，生成新节点。 3)将新节点插入到当前链表的表头上，直到结束为止，插入过程如下图所示。 typedef struct LNode { int data; struct LNode *next;//存储后继节点位置的指针域，用next表示 }LinkNode; 头插法代码如下，由数组元素a创建单链表L void CreatListF(Lin
单链表——单链表的定义及基本操作（初始化、头插法尾插法建表、查找、插入、删除、判空等）
热门推荐
薛定谔的猫的博客
04-17 9万+
文章目录单链表的定义单链表上的操作初始化建立单链表头插法建立单链表尾插法建立单链表遍历单链表求单链表的长度查找操作按值查找按位查找插入操作删除操作完整代码及实例 单链表的定义   由于顺序表的插入删除操作需要移动大量的元素，影响了运行效率，因此引入了线性表的链式存储——单链表。单链表通过一组任意的存储单元来存储线性表中的数据元素，不需要使用地址连续的存储单元，因此它不要求在逻辑上相邻的两个元素在物理位置上也相邻。   单链表的特点： 单链表不要求逻辑上相邻的两个元素在物理位置上也相邻，因此不需要连续的存储
数据结构--线性表的链式存储结构（单链表）的创建+查询+插入+删除操作
Bearing in mind forever！
09-08 1735
1、单链表的创建 #include<iostream> #include<cstdio> #include<cstdlib> using namespace std; struct node{ int data; struct node *next; }; struct node *head=NULL,*q,*p; void build(int n) { ...
四、数据结构——单向链表的基本操作详解：创建、插入（头插法、尾插法、任意点插法）、删除（头删法、尾删法、任意位置删法）、查询（按值查下标、按下标查值）、遍历链表和清空链表
最新发布
qq_57737603的博客
06-14 2160
单向链表是一种线性数据结构，由一系列节点组成。每个节点包含两个部分：数据和指向下一个节点的引用（也称为指针）。节点之间通过这个引用连接在一起，形成链表结构。最后一个节点的引用指向空值，表示链表的结束。
数据结构——线性表分享.pdf
01-01
数据结构——线性表分享 一、顺序存储结构 在数据结构中，顺序存储结构是一种常用的存储方式，它将线性表的每个元素存储在一块连续的存储空间中。这种存储方式的优点是可以快速访问任意一个元素，但缺点是插入或...
数据结构实验——线性表子系统
07-31
在这个实验中，我们主要关注线性表的链式存储结构，特别是字符型的单链表。实验的目标是理解线性表的特点，掌握顺序存储和链式存储结构的基本操作，包括创建、插入、删除和显示线性表中的元素。 在C语言中，我们...
C++与数据结构 第一次上机实验——线性表.pdf
11-07
本文主要讨论了C++编程中关于数据结构中的线性表，包括线性表的定义、顺序存储结构和链式存储结构的特点，以及如何通过C++实现线性表的相关操作，如插入、删除和查找等。 线性表是一种数据结构，其中的元素之间存在...
C++与数据结构 第一次上机实验——线性表.docx
11-07
线性表可以采用两种主要的存储方式：顺序存储结构和链式存储结构。 **顺序存储结构**是指用一组连续的存储单元来依次存储线性表中的数据元素，通过元素的物理位置来反映它们之间的逻辑关系。这种存储方式的优点在于...
链表学习笔记（kk-zkx）
weixin_42585296的博客
09-29 258
链表学习单链表（链式存储结构）链表节点头节点，头指针和首元节点 单链表（链式存储结构） 链表，别名链式存储结构或单链表，用于存储逻辑关系为 “一对一” 的数据。与顺序表不同，链表不限制数据的物理存储状态，换句话说，使用链表存储的数据元素，其物理存储位置是随机的。 栗子，使用链表存储 {1,2,3}，数据的物理存储状态如图 所示： 数据元素随机存储，并通过指针表示数据之间逻辑关系的存储结构就是链式存储结构。 链表节点 链表中每个数据的存储都由以下两部分组成： 数据元素本身，其所在的区域称为数据域； 指向
线性表——链式存储结构实现(单链表)
一个很懒的人
07-25 913
1.单链表基本知识点 2.单链表代码实现 1.带头结点（基本实现） 1.头插法可以实现单链表 逆置 2. 偷天换日(见文末代码)-----在某个结点前插入结点 3.头插法和尾插法中心思想------- 结点后插法 (见文末代码) 4.注意代码 封装 思想(见文末代码) #include<bits/stdc++.h> using namespace std; //定义结点 typedef struct LNode{ int data; //存储数据 struct LNo.
单链表的存储结构及操作
流彩飞霞的专栏
03-29 2564
在讨论单链表（带头节点，不带头节点类似，这里不再赘述）之前我，我们学习过线性表的顺序存储结构，我们知道它是有缺点的，最大的缺点就是插入和删除元素时需要移动大量元素、并且需要预先分配存储空间，但是优点是存取方便。 线性表的链式存储结构特点是用一组任意的存储单元存储线性表的数据元素，这组存储单元可以是连续的，也可以是不连续的。其存储结构如下： /*线性表的链式存储结构*/ typedef int...
线性表的单链表存储结构
亦是远方的小地方
09-23 1413
数据结构；单链表；带表头的线性表；
【单链表】数据结构单链表的实现
m0_56069910的博客
01-31 1220
单链表的实现
【数据结构】静态链表和单链表的存储方式、优缺点与区别
qq_55930097的博客
06-07 1303
创建一个足够大的数组，假设大小为6，在将数据存放到数组中时，给各个数据元素配备游标，用于指明各个元素的直接后继元素所在数组中的位置下标，从a[1]存储的数据元素1开始，通过存储的游标变量 3，就可以在a[3]中找到元素1的直接后继元素2；同样，通过元素a[3]存储的游标变量5，可以在a[5]中找到元素2的直接后继元素3，这样的循环过程直到某元素的游标变量为0截止，因为 a[0] 默认不存储数据元素。静态链表，也是线性存储结构的一种，它兼顾了顺序表和链表的优点于一身，可以看做是顺序表和链表的升级版。
单链表-创建、读取、插入（头插法、尾插法）、删除(线性表的链式存储结构)
weixin_45201953的博客
11-11 1624
单链表-线性表的链式存储结构链式存储结构的特点单链表头结点、头指针单链表存储结构单链表创建，读取，插入，删除的简单思路创建读取插入删除单链表常见操作代码示例单链表对比顺序表优缺点存储分配方式时间性能结论 链式存储结构的特点 顺序存储结构里面，每次都要预先分配一片连续的内存，有些时候分配的空间会有剩余，有些时候分配的空间又不足，灵活性较差，因此，为了解决这个问题，诞生了链式存储结构。那么，链式存储结...
数据结构中单链表的存储c语言,单链表一 - 数据结构与算法教程 - C语言网
weixin_29216353的博客
05-18 477
1. 单链表概念&设计单链表是一种链式存取的数据结构，，链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。以“结点的序列”表示的线性表称作线性链表(单链表)，单链表是链式存取的结构。对于链表的每一个结点，我们使用结构体(struct)进行设计，其主要内容有：其中，DATA数据元...
1分别在什么情况下用顺序和链式存储结构实现线性表? 2. 设用带头结点的单链表实现线性表。如何判断线性表的元素是否两两不等?
06-09
1. 顺序存储结构适用于线性表元素个数较少，存储空间相对充足，且需要频繁进行随机存取的情况。链式存储结构适用于线性表元素个数较多，存储空间受限，且需要频繁进行插入和删除操作的情况。 2. 要判断线性表的元素是否两两不等，可以采用以下算法： 1. 遍历单链表，对于每个结点，将其值与后续所有结点的值进行比较。 2. 如果找到一个与该结点值相等的结点，则说明线性表中存在相同的元素，返回false。 3. 如果遍历完整个单链表，都没有找到相同的元素，则说明线性表中所有元素都不相同，返回true。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Ju-un

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

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

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

打赏作者

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

抵扣说明：

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

余额充值