数据结构--线性表的链式表示

最新推荐文章于 2022-10-31 15:07:25 发布
最新推荐文章于 2022-10-31 15:07:25 发布
阅读量733 收藏 15
点赞数 4
分类专栏： 考研 文章标签： 数据结构 线性表的链式常见操作表达方式
小斌斌专属
本文链接：https://blog.csdn.net/weixin_45428890/article/details/114683124
版权

按位序插入（带头结点）

//在第i个位置插入元素e（带头结点）
bool listInsert(LinkList &L,int i,ElemType e)
{
    if(i<1)
      return false;
      LNode *p;  //指针p指向当前扫描的结点
      int j=0; //当前p指向的是第几个结点
      P=L;//L指向头结点，头结点是第几个0结点（不存数据）
      while (P!==Null&& j<i-1)
      {//循环找到第i-1个结点
      P=p->next;
      j++;
	  }
	  if(P=NULL)//i值不合法
	  	return false;
	 LNode *s=(LNode *)malloc (sizeof(LNode));
	 s->data=e;
	 s->next=p->next;
	 p->next=s;
	 return true;
}
typedef struct LNode{
   ElemType data'
   struct LNode *next;
}LNode,*LinkList;

在这里插入图片描述

按位序插入（不带头结点）

bool listInsert(LinkList &L,int i,ElemType 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;  //指针p指向当前扫描的结点
      int j=1; //当前p指向的是第几个结点
      P=L;//P指向第一个结点不是头结点
      while (P!==Null&& j<i-1)
      {//循环找到第i-1个结点
      P=P->next;
      j++;
	 }
	  if(P=NULL)//i值不合法
	  	return false;
	 LNode *s=(LNode *)malloc (sizeof(LNode));
	 s->data=e;
	 s->next=p->next;
	 p->next=s;
	 return true;
}
typedef struct LNode{
   ElemType data'
   struct LNode *next;
}LNode,*LinkList;

在这里插入图片描述

指定结点的后插操作

//后插操作：在P结点之后插入元素e
bool InsertNextNode(LNode *p,ElemType e){
   if (p==Null)
   	return false;
   LNode *s=(LNode *)malloc (sizeof(LNode));
   if(s==Null) //内存分配失配
   	return false;
   s->data=e;//用结点s保存数据元素e
   s->next=p->next;
   p->next=s;//将结点s连到p之后
   return true;
}
typedef struct LNode{
     ElemType data;
     struct LNode *next;
}LNode,*LinkList;

在这里插入图片描述

指定结点的前插操作

//前插操作：在P结点之后插入元素e
bool InsertPriorNode (LNode *P,ElemType e){
	if(P==NULL)
		return false;
	LNode *s =(LNode *)malloc (sizeof(LLNode));
	if(s==NULL)//内存分配失败
	 return false;
	 s->next=P->next;
	 p->next=s;  //新结点S连到P之后
	 s->data=P->data;//将P中的元素复制到S中
	 p->data=e;//P元素覆盖为e
	 return true;
}

在这里插入图片描述

//在P结点之前插入结点S
bool InsertPriorNode (LNode *P,LNode *s){
	if(P==NULL||s=NULL)
		return false;
	 s->next=P->next;
	 p->next=s;  //新结点S连到P之后
	 ElemType temp=p->data;//交换数据域
	 s->data=temp;
	 return true;
}

在这里插入图片描述

封装的好处
小功能模块化，代码逻辑清晰，避免重复代码，简洁易维护

带头结点按位序删除

bool ListDelete(LinkList &L,int i,ElemType &e){
   if(i<1)
   		return false;
   LNode *p;
   int j=0;
   P=L;
   while(P!=NULL&&j<i-1){
   //循环找到第i-1个结点
   P=P->next;
   j+=;
}
if(P==NULL)
	return false;
if(P->next==NULL)
	return false;
	LNode *q=P->next;//令q指向被删除结点
	e=q->data;  //用e返回元素的值
	P->next=q->next;  //将*q结点从链中断开
	free(q);
	return true;
}

在这里插入图片描述
指定结点的删除

//删除指定结点P
bool DeleteNode(LNode *P){
    if(P=NULL)
    	return false;
    LNode *q=P->next;//令q指向*p的后继结点
    P->data=P->next->data;//和后继结点交换数据域
    p->next=q->next;//将*q结点从链中断开
    free(q); //释放后继结点的存储空间
    return true;
}

但是当删除的这个指定结点是最后一个结点时，上述代码却又出现了问题，当是最后的结点时需要特殊讨论。
在这里插入图片描述

单链表按位查找

//按位查找，返回第i个元素（带头结点，把头结点看成第0个结点）
LNode *GetElem(LinkList L,int i){
	if(i<0)
		return NULL;
	LNode *P;//指针P指向当前扫描的结点
	int j=0;//当前P指向的是第几个结点
	P=L;//L指向头结点，头结点是第0个结点不存数据
	whie(P!=NULL&&j<i){
     //循环找到第i个结点
     P=P->next;
     j++;
}
return P;
}

在这里插入图片描述

单链表的按值查找

//按值查找，找到数据域=e的结点
LNode *LocateElem(LinkList L,ElemType e){
   LNode *p=L->next;
   //从第1个结点开始查找数据域为e的结点
   while(P!=NULL&&P->data!=e)
   		P=P->next;
   return P;//找到后返回该点指针，否则返回null
}

在这里插入图片描述

求单链表的长度

//求表的长度
int length(LinkList L)
{
   int len=0; //统计表长
   LNode *P=L;
   while(P->next!=NULL)
   {
   	P=P->next;
   	len++;
   }
   return len;
}

单链表不具有随机访问的特点，只能依次扫描。

尾插法建立单链表
设置一个指向表尾结点的指针

LinkList List_Taillnsert(LinkList &L){
//正向建立单链表
int x;
L=(LinkList)malloc (sizeof(LNode));//初始化空表建立头结点
LNode *s,*r=L;  //r为表尾指针
scanf("%d",&x);
while(x!=9999){
   s=(LNode *)malloc (sizeof(LNode));
   s->data=x;
   r->next=s;//在r结束之后插入元素x
   r=s;//r指向新的表尾元素，永远保持r指向最后一个结点
   scanf("%d",&x);
}
r->next=NULL;//尾结点指针置空
return L;
}

头插法建立单链表(主要应用于链表的逆置)

LinkList List_HeadInsert(LinkList &L){
   //逆向建立单链表
   LNode *s;
   int x;
   L=(LinkList)malloc(sizeof(LNode));//创建头结点
   L->next=NULL;  //初始化为空链表
   scaanf("%d",&x);
   while(x!=9999)
   {
   s=(LNode *)malloc(sizeof(LNode));
   s->data=x;
   s->next=L->next;
   L->next=s;
   scanf("5d",&x);
}
	return L;
}

双链表

//双链表的定义
typedef struct DNode{
   Elemtype data;
   struct DNode *prior,*next;
}DNode,*DLinklist;

在这里插入图片描述

带结点的双链表的初始化

bool Initlinklist(Dlinklist &L){
      L=(DNode*)malloc(sizeof(DNode));//malloc分配一个头结点
      if(N==null)
      	return false;
      L->prior=null;
      L->next=null;
      return true;
}
//判断带头结点的双链表是否为空
bool empty(Dlinklist L){
     if(l->next==null)
     	return true;
     else
     	return false;
}

在这里插入图片描述

双链表的插入

bool InsertNextDnode(Dnode *p,Dnode *s){
	if(p==null||s==null)
		return false;
    s->next=p->next;
    if(p->next!=null)//如果p结点有后继结点
    	p->next->prior=s;
    s->prior=p;
    p->next=s;
    return true;    
}

在这里插入图片描述

双链表的删除

//删除p的后继结点Q
bool DeleteNextDnode(Dnode *p){
	if(p==null) return false;
	Dnode *q=p->next;//找到p的后继结点q
	if(q==null) return false;
	p->next=q->next;
	if(q->next!=null)
		q->next->prior=p;
	free(q);
	retutn true;
}

在这里插入图片描述
销毁双链表

void Destory(Dlinklist &L)
{
   //循环释放各个数据结点
   while(L->next!=null)
   		DeleteNextDnode(L);
   	free(L);//释放头结点
   	L=NULL;//头结点指向null
	
}

在这里插入图片描述
双链表的遍历

//后向遍历
while(p!=null){
   //对下相应的结点处理
   p=p->next;
}
//前向遍历
while(p->prior!=null){
   //对下相应的结点处理
   p=p->prior;
}

双链表不可随机存取、按位查找、按值查找等操作都只能用遍历的方式去实现，其时间复杂度为O(n)
循环遍历单链表

typedef struct LNode{
  elemtype data;
  struct Lnode *next;
}Lnode,*linklist;
//初始化一个循环单链表
bool InitList(Linklist &L){
   L=(LNode *malloc(sizeof(LNode)));//分配一个头结点
	if(L==null)
		return false;
	L->next=L;
	return true;
}

在这里插入图片描述
循环双链表

//初始化空的循环双链表
bool InitDlinklist (Dlinklist &L){
   L=(Dnode*)malloc(sizeof(Dnode));
   if(L==null)
   	return false;
   L->prior=L;
   L->next=L;
   return true;
}

在这里插入图片描述
双链表的插入

//在P结点之后插入S结点
bool INsertNextDnode(Dnode *P,Dnode *S)
{
   S->next=P->next;
   P->next->prior=S;
   S->prior=P;
   P->next=S;
}

//判断循环双链表是否为空
bool Empty(Dlinklist L){
   if(L->next==L)
   	return true;
   else
   	return false;
}

//判断结点P是否为循环双链表的表尾结点
bool isTail(Dlinklist L,Dnode *p){
  if(P->next==L)
  	return false;
  else
  	return false;
}

在这里插入图片描述
双链表的删除

//删除P的后继结点Q
P->next=q->next;
q->next->prior=P;
free(q);

在这里插入图片描述
静态链表
分配一整片连续的内存空间，各个结点集中安置
优点：增删操作不需要大量移动元素
缺点：不能随机存取只能从开头依次往后，容量固定不可变

//用代码定义一个静态链表
#define Maxsize 10
struct Node{
   ElemType data;
   int next;//下一个元素的数组下标
};
//重命名
typedef struct Node SLinklist[MaxSize];

在这里插入图片描述
初始化静态链表：把a[0]的next设为-1（代表空结点null），把其他结点的next设为一个特殊值用来表示结点空闲如-2
查找：从头结点出发挨个往后遍历结点，其时间复杂度为O(n)
插入位序为i的结点：
1）先找到一个空的结点，存入数据元素
2）从头结点出发找到位序为i-1的结点
3）修改新结点后的next
4)修改i-1号结点的next
删除结点：
1）从头结点出发找到前驱结点
2）修改前驱结点的游标
3）把被删除结点的next设为-2

在这里插入图片描述

爱吃香菜的斌斌
关注
  • 4
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
线性表的链式表示和实现
代码演奏家
11-09 168
#include <stdio.h> #include <stdlib.h> #define ElemType int typedef struct LNode { ElemType data; struct LNode* next; } LNode, * LinkList; // 定义头结点 typedef struct Head { int len; struct LNode* next; } Head, * header; // 头插入法 he
【1】3. 线性表的链式表示_单链表的插入和删除操作
JJL的博客
07-26 723
目录 1. 按位序插入_带头结点 2. 按位序插入_不带头结点 指定结点的后插操作 指定结点的前插操作 3. 按位序删除_带头结点 指定结点的删除 1. 按位序插入_带头结点 2. 按位序插入_不带头结点 考试中两种情况都会考察! 指定结点的后插操作 然后代码就可以修改成： 指定结点的前插操作 3. 按位序删除_带头结点 ListDelete(&L,&...
线性表的链式实现:链表
m0_52902391的博客
05-04 122
线性表的链式实现:链表 简介: 在线性表中插入，删除元素时需要移动很多元素，如果数据元素本身很大，就比较耗时。另外，如果线性表的元素个数非常多，可能无法申请到一个足够大的内存块，为了克服这些缺点，可以考虑用所谓的链表来表示线性表。链表在插入，删除上比顺序表更为省时，但是在查找上效率则不如顺序表,下面简单介绍一下链表以及链表的一些基本操作 所有代码: #include<iostream> //这里实现几个基本的线性表操作 //1.初始化操作 //2.检测线性表是否为空 //3.将.
2.3 数据结构——线性表的链式表示和实现
weixin_45523296的博客
08-21 259
线性表链式存储的定义、线性表链式表示与实现
链表
AWA124的博客
05-22 443
/* 2.链式线性表的建立、插入及删除。*/ #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;malloc.h&gt; #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 typedef int ElemType; typedef struc...
数据结构-线性表的链式存储
最新发布
09-17
数据结构——线性表的链式存储。 一篇文章带你快速了解！
数据结构--线性表--思维导图.pdf
08-29
数据结构--线性表--思维导图.pdf 该资源主要讲解了数据结构中的线性表，包括线性表的定义、基本操作、顺序表和链表的存储方式、操作效率比较等。 线性表的定义： 线性表是一种逻辑结构，表示元素之间一对一相邻的...
漫话数据结构-线性表的链式存储.pptx
11-03
漫话数据结构
数据结构学习--线性表及其应用--链表
06-25
本程序的主要目的在于帮助同学熟练掌握线性表的基本操作在链式存储结构上的...通过本实验， 对链表基本操作及其组合应用的演练，加深对链表存储方法及其基本操作的理解，为以后进 一步学习更复杂的数据结构打下基础。
数据结构教学课件：第3-2讲 线性表的链式存储结构-2.pdf
06-01
数据结构教学课件：第3-2讲 线性表的链式存储结构-2.pdf
2.2 线性表的链式表示和实现（单链表）
蓝天的博客
04-24 620
一、前言 学习了线性表的顺序表示，我们知道顺序表示可以随机存取元素，意味着逻辑上相邻的两个元素在物理位置上也相连，但是我们可以看到插入和删除元素需要移动大量元素，而且还需要事先分配好一定量的空间。 二、链式表示介绍 链式存储结构意味着逻辑上相邻的元素在物理位置上不一定也相邻，在删除和插入元素时不需要移动大量元素，同时不支持随机存取，必须找到直接前驱和直接后继才能操作相应的元素。 对于单链表...
用c语言实现在带头结点的单链线性表l中的第i个位置之后插入元素e,（1）线性表...
weixin_39889788的博客
05-23 4710
(一)线性表一、线性表的定义1、线性结构的特点在数据元素的非空有限集中，(1)存在唯一的一个被称作“第一个”的数据元素；(2)存在惟一的一个被称作“最后一个”的数据元素；(3)除第一个之外，集合中的每个数据元素均只有一个前驱；(4)出最后一个之外，集合中每个数据元素均只有一个后继。2、线性表一个线性表n个数据元素(或结点)的有序序列：a0，a1，a2，•••，an-1其中a0是开始结点，an-1是...
线性表的链式存储
qq_51308373的博客
03-07 584
前言 紧承上篇顺序存储，这一篇来说说链式存储。链式存储在线性表中运用比较多。 我们先来说说顺序存储的优缺点，以此引出单链表的定义。 顺序存储结构的评价： 优点： （1）是一种随机存取结构，存取任何元素的时间是一个常数，速度快 （2）结构简单，逻辑上相邻的元素在物理上也是相邻的 （3）不需要使用指针，节省存储空间 缺点： （1）插入和删除元素要移动大量元素，消耗时间 （2）需要一块连续的空间 （3）插入元素可能发生
线性表链式存储实现
qq_63913499的博客
10-17 418
线性表存储实现
《数据结构》线性表——链式存储结构
执着&你
04-01 2299
线性表链式存储结构简称链表，与顺序不同的是链表中的结点不仅包含有元素本身的信息，还包含有元素之间的逻辑关系的信息！！！
线性表的顺序存储和链式存储
m0_59073956的博客
10-05 270
线性表的顺序存储
【数据结构】链表元素查找、插入和删除-线性表的链式存储
BUG从入门到精通
11-07 6566
目录 头指针和头结点 代码 查找元素 插入元素 删除元素 头指针和头结点 线性链表的存储结构，整个链表的存取必须从头结点开始。 头指针指向头结点，头结点的数据域不存放任何数据，也可以存储线性表长度等信息，头结点的指针域存储指向第一个节点的指针。 头结点的作用： 防止单链表是空的而设的，当链表为空的时候,带头结点的头指针就指向头结点，如果当链表为空的时候,单链表没有带头结点,那么它的头指针就为NULL。 是为了方便单链表的特殊操作，能有效减少代码量，在插入在表头或者删除第一个结点时不
复习笔记3_数据结构线性表/顺序表新增：在第i个位置插入元素e（动态表+静态表）
weixin_43700565的博客
04-14 5481
数据结构线性表/顺序表新增：在第i个位置插入元素e（动态表+静态表）
6-2 线性链表的插入、删除
qq_51935763的博客
10-31 466
6-2 线性链表的插入、删除
数据结构 - 线性表
09-13
线性表是一种常见的数据结构，它表示具有相同数据类型的一组元素的有序序列。线性表中的元素之间存在一种顺序关系，每个元素都有一个前驱和一个后继（除了第一个元素没有前驱，最后一个元素没有后继）。线性表可以用顺序存储结构或链式存储结构实现。 在顺序存储结构中，线性表的元素按照顺序存储在连续的内存空间中，可以通过元素的下标来访问和操作元素。插入或删除元素时，需要移动其他元素，因此操作的时间复杂度较高。 链式存储结构中，线性表的每个元素都包含一个数据域和一个指针域，指针指向下一个元素。通过指针的链接，元素可以按照任意顺序存储在内存中，插入和删除操作只需要改变指针的指向，因此时间复杂度较低。 线性表常见的操作包括插入、删除、查找、获取长度等。其中插入和删除操作需要注意保持线性表的顺序关系。 常见的线性表有数组、链表、栈和队列。数组是最简单的线性表，通过下标可以直接访问元素；链表是动态存储结构，插入和删除操作方便，但访问元素需要遍历链表；栈是一种特殊的线性表，只允许在表的一端进行插入和删除操作；队列也是一种特殊的线性表，只允许在表的一端进行插入操作，在另一端进行删除操作。这些数据结构在实际应用中都有各自的应用场景和优缺点。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

爱吃香菜的斌斌

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

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

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

打赏作者

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

抵扣说明：

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

余额充值