第二章 线性表——链表

已于 2024-01-05 13:21:53 修改
阅读量87 收藏
点赞数 1
分类专栏： 数据结构 文章标签： 链表 数据结构 1024程序员节
于 2023-10-23 20:42:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2203_75646004/article/details/133997002
版权

目录

1.单链表

（1）定义

（2）链表的创建

（3）链表的初始化

（4）链表的查找

查找位置

查找元素

 (5)链表的插入

 (6)链表的增加

（8)链表的输出

补充：

链表的指针

 (7)链表顺序表的优缺点

（9）小结

2.双向链表

（1）定义

（2）创建

（3）插入

（4）删除

1.单链表

（1）定义

1.采用链式存储结构的线性表称为线性链表。

2.结点包含数据域和指针域两部分。

3.元素节点前通常加头结点，链表名指向头结点(头指针),尾结点指针域值为NULL。

4.头指针标识整个链表, 链表名即头指针；

db7add226d5b47eb80665cdaf499aae9.jpeg

（2）链表的创建

typedef struct LNode{//LNode类似user
ElemType data;//数据域
struct LNode *next;//指针域
}LNode,*Linklist;
//这里的LNode等于struct LNode，结构体名称，类似xiaoming
//命名方式：表名创建LNode T=>T.data   T.next
//这里的*Linklist等于struct LNode*,指向整个结构体的指针
//命名方式：指针创建Linklist T=>T->data  T->next

（3）链表的初始化

Status Listcreate_(Linklist &L,int n)
{
    LNode *rearptr,*curptr;//一个尾指针，一个指向结点的指针
    L=(LNode*)malloc(sizeof(LNode));
    //开辟头结点，其数据域一般不做赋值。
    if(!L)
        exit(OVERFLOW);
    L->next=NULL;//指针域指向空，先建立一个头结点的单链表
    rearptr=L;//初始头结点为尾结点
    for(int i=1;i<n;i++)
    {//每次循环一次开辟一个新节点，并把新节点拼到尾结点
    curptr=(LNode*)malloc(sizeof(LNode));//开辟一个新结点
    if(!curptr)
        exit(OVERFLOW);
    scanf("%d",&curptr->data);//输入元素值
    curptr->next=NULL;
    rearptr->next=curptr;
    rearptr=curptr;
    }
}

  

（4）链表的查找

查找位置

//查找位置
Status ListLocate_L(Linklist &L,ElemType e)
{
    LNode *temp=L->next;//临时指针指向第一个结点
    int pos=0;
    while(temp!=NULL)
    {
        pos++;
        if(temp->data==e)
            return pos;//当指向e时，返回pos并结束循环
        else temp=temp->next;
    }
    return 0;
}

查找元素


Status GetElem_L(Linklist &L,int pos,ElemType &e)
{
    //L为带头结点的单链表的头指针。
//第i个元素存在时,其值赋给e并返回OK,否则返回ERROR
//设遍历指针和相应计数器,从头开始后移至计数器为i停.i异常
    LNode *p=L;
    int j=0;//p指向”第0个”元素结点，j是该结点的位序
    while(p&&j<pos) //顺序查找，只要p不空且未到第i结点就前进
    {
        p=p->next;
        ++j;
    }
    if(!p||pos<1)return ERROR;    //第i个元素不存在 或 i<1,
    e=p->data;                   //取第i个元素
    return OK;
}

 (5)链表的插入


Status ListInsert_L(Linklist &L, int i, ElemType e){
//定位到第i-1个结点，在其后插入一个新开辟的结点.注意i异常
  LNode *p=L;  int j=0;  /*p始终指向第j个结点*/
//找到插入位置
  while(p&&j<i-1)
    {p=p->next; ++j;}//只要不空且未到第i-1个
   if(!p||i<1) return  ERROR;  //第i-1个节点不存在或者i<1
//连接插入结点
   LNode *q;
   q= (LNode *)malloc(sizeof(LNode)); //或q=new LNode;
   if(!q)exit(OVERFLOW);
   q->data=e;
   q->next=p->next;
   p->next=q;
   return(OK);
}

 (6)链表的删除


Status ListDelete_L(Linklist &L, int i, ElemType &e){
//寻找第i-1个结点 ,若其后继结点存在则带回其data并删除
  LNode *p=L,*q;  int j=0;  /*p始终指向第j个结点*/
  while(p&&j<i-1){p=p->next; ++j;}//寻找第i-1个结点
                                             // j 最终为i-1,除非p空
  if(!p||!p->next||i<1) return  ERROR;//第i个或更前结点不存在,
  q=p->next;
  e=q->data;
  p->next=q->next;
  free(q);
  return(OK);
}

（8)链表的输出


void printfLinklist(Linklist &L){
    LNode *p=L->next;
while (p!= NULL)
	{
		printf("%d ",p->data) ;
		p=p->next;
	}
	printf("%d",p->data) ;
}
//库函数头文件包含
#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>

//函数状态码定义
#define TRUE        1
#define FALSE       0
#define OK          1
#define ERROR       0
#define INFEASIBLE -1
#define OVERFLOW   -2
typedef int  ElemType;
typedef int  Status;
#define LIST_INIT_SIZE  100
#define LISTINCREMENT   10
typedef struct LNode //LNode类似user
{
    ElemType data;//数据域
    struct LNode *next;//指针域
    //数据域用来存放数据元素，指针域用来存放下一个数据结点的地址
} LNode,*Linklist;
//这里的LNode等于struct LNode，结构体名称，类似xiaoming
//命名方式：表名创建LNode T=>T.data
//这里的*Linklist等于struct LNode*,指向整个结构体的指针
//命名方式：指针创建Linklist T=>LinkList->data
Status Listcreate_L(Linklist &L,int n)
{
    LNode *rearptr,*curptr;//一个尾指针，一个指向结点的指针
    L=(LNode*)malloc(sizeof(LNode));
    //开辟头结点，其数据域一般不做赋值。
    if(!L)
        exit(OVERFLOW);
    L->next=NULL;//指针域指向空，先建立一个头结点的单链表
    rearptr=L;//初始头结点为尾结点
    for(int i=1; i<=n; i++)
    {
        //每次循环一次开辟一个新节点，并把新节点拼到尾结点
        curptr=(LNode*)malloc(sizeof(LNode));//开辟一个新结点
        if(!curptr)
            exit(OVERFLOW);
        scanf("%d",&curptr->data);//输入元素值
        curptr->next=NULL;
        rearptr->next=curptr;
        rearptr=curptr;
    }
    return OK;
}
//查找位置
Status ListLocate_L(Linklist &L,ElemType e)
{
    LNode *temp=L->next;//临时指针指向第一个结点
    int pos=0;
    while(temp!=NULL)
    {
        pos++;
        if(temp->data==e)
            return pos;//当指向e时，返回pos并结束循环
        else temp=temp->next;
    }
    return 0;
}
Status GetElem_L(Linklist &L,int pos,ElemType &e)
{
    //L为带头结点的单链表的头指针。
//第i个元素存在时,其值赋给e并返回OK,否则返回ERROR
//设遍历指针和相应计数器,从头开始后移至计数器为i停.i异常
    LNode *p=L;
    int j=0;//p指向”第0个”元素结点，j是该结点的位序
    while(p&&j<pos) //顺序查找，只要p不空且未到第i结点就前进
    {
        p=p->next;
        ++j;
    }
    if(!p||pos<1)return ERROR;    //第i个元素不存在 或 i<1,
    e=p->data;                   //取第i个元素
    return OK;
}
Status ListInsert_L(Linklist &L, int i, ElemType e){
//定位到第i-1个结点，在其后插入一个新开辟的结点.注意i异常
  LNode *p=L;  int j=0;  /*p始终指向第j个结点*/
  while(p&&j<i-1)
    {p=p->next; ++j;}//只要不空且未到第i-1个
   if(!p||i<1) return  ERROR;  //第i-1个节点不存在或者i<1
   LNode *q;
   q= (LNode *)malloc(sizeof(LNode)); //或q=new LNode;
   if(!q)exit(OVERFLOW);
   q->data=e;
   q->next=p->next;
   p->next=q;
   return(OK);
}
Status ListDelete_L(Linklist &L, int i, ElemType &e){
//寻找第i-1个结点 ,若其后继结点存在则带回其data并删除
  LNode *p=L,*q;  int j=0;  /*p始终指向第j个结点*/
  while(p&&j<i-1){p=p->next; ++j;}//寻找第i-1个结点
                                             // j 最终为i-1,除非p空
  if(!p||!p->next||i<1) return  ERROR;//第i个或更前结点不存在,
  q=p->next;
  e=q->data;
  p->next=q->next;
  free(q);
  return(OK);
}
void printfLinklist(Linklist &L){
    LNode *p=L->next;
while (p!= NULL)
	{
		printf("%d ",p->data) ;
		p=p->next;
	}
	printf("%d",p->data) ;
}
int main()
{
    Linklist L;
    int n;
    scanf("%d",&n);
   Listcreate_L(L,n);
   // printfLinklist(L);
    int pos;
    scanf("%d",&pos);
     //ListInsert_L(L,pos,e);
      ElemType e;
     GetElem_L(L,pos,e);
     printf("%d",e);
      //printfLinklist(L);
}

补充：

链表的指针

83fbea2f27f941649db93eb84717e861.jpg

#include<stdio.h>
typedef struct LNode
{
      int data;
      LNode *p;
} Node;
int main()
{
    Node a,b;
    a.data=123;
    b.data=124;
    a.p=&b;//指向b的头结点
    a.p->data=1212;
    b.p=&a;//地址=地址
    b.p->data=807;//等于a.data
    printf("%d\n",b.data);
    printf("%d",a.data);
}

 (7)链表顺序表的优缺点

优点：空间利用好,插入删除不需移动数据,表头操作快。

缺点：顺序访问,位序概念淡化, 表尾操作、求前驱、求表长慢，存储密度低。例如，为方便求前驱可引入双向链表，为方便表尾操作可引入尾指针和循环链表，为实用改进结构定义如添加表长成员和尾指针的改进单链表等

（9）小结

219b6f63281e41ada358d6a4bad27605.png

2.双向链表

（1）定义

单向链表特点：

      1.我们可以轻松的到达下一个节点, 但是回到前一个节点是很难的.
  2.只能从头遍历到尾或者从尾遍历到头(一般从头到尾)
双向链表特点
  1.每次在插入或删除某个节点时, 需要处理四个节点的引用, 而不是两个. 实现起来要困难一些
  2.相对于单向链表, 必然占用内存空间更大一些.
  3.既可以从头遍历到尾, 又可以从尾遍历到头
双向链表的定义:
  双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。下图为双向链表的结构图。b82542c6826c426da114fa990f31fe51.png

  从上中可以看到，双向链表中各节点包含以下 3 部分信息：
  指针域：用于指向当前节点的直接前驱节点；
  数据域：用于存储数据元素。
  指针域：用于指向当前节点的直接后继节点；

63a63985407745f599991071f52da4b1.png

双向循环链表的定义:
  双向链表也可以进行首尾连接，构成双向循环链表,如下图所示

da6dfb501dba4a2ab7561c460697a1a5.png
在创建链表时，只需要在最后将收尾相连即可（创建链表代码中已经标出）。其他代码稍加改动即可。

（2）创建

//---线性表的双向(循环)链表存储结构---
typedef struct DuLNode{
   ElemType     data;
   struct DuLNode *prior;
   struct DuLNode *next;
}DuLNode,*DuLinkList;
//双向链表有利于访问前驱结点，复杂度多少？

（3）插入

p=GetElemP_DuL(L,i-1); //确定插入位置

s=new DuLNode;

 s->data=e;

s->prior=p;  

s->next=p->next;

p->next->prior=s;  

p->next=s;

  Status ListInsert_DuL(DuLinkList &L,int i,ElemType &e){
  DuLNode *p=L; int j=0;
  while(p&&j<i-1){p=p->next;++j;}
  if(!p||i<1) return ERROR;
  s=new  DuLNode;   if(!s)exit(OVERFLOW);
  s->data=e;
  s->prior=p; s->next=p->next;   //注意分析指针改变次序
  p->next->prior =s;  p->next=s; 
  return OK;
}//ListDelete_DuL

（4）删除

(1)p->prior->next=p->next; (2)p->next->prior=p->prior; (3)  free(p); p=NULL

Status ListDelete_DuL(DuLinkList &L,int i,ElemType &e){
//删除带头结点的双向链表L的第i个元素,1≤i≤ListLength(L)
 if(!(p=GetElemP_Dul(L,i))) return ERROR;
  e=p->data;
  p->prior->next=p->next;
  p->next->prior=p->prior;
  free(p);p=NULL;  //教材未写p=NULL，容易引起内存泄露;
  return OK;
}//ListDelete_DuL

单链表的反转

988f1b696d0947aba856367cb0139d78.jpeg

程序小冰
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【第二节】线性表--链表
风铃的博客
12-12 577
????链表许多结构 单链表，单循环链表，双链表，双循环链表，带头节点的单链表，不带头节点的双向链表...... 1.线性表的链式存储结构的特点是用一组任意的存储单元存储线性表的数据元素（这组存储单元可以是连续的，也可以是不连续的） 2.一个结点包括两个域：其中存储数据元素的叫数据域，存储直接后继存储位置的域叫指针域 3.用线性链表表示线性表时，数据元素之间的逻辑关系是由结点中的指针指示的，指针为数据元素之间的逻辑关系映像，所以逻辑上相邻的两个数据元素其存储的物理位置不要求相邻 ???
第二章—线性表
m0_73756332的博客
10-23 331
线性表的更新啦
初阶数据结构——线性表——链表——不带头单向链表
dtxew love c++
10-20 2849
????????想快速入门数据结构，推荐订阅作者的初阶数据结构专栏！此专栏预计更新：顺序表，链表，栈，队列，二叉树，排序算法等等 ????????初阶数据结构我们通过c语言实现，所以此专栏也可以帮助大家巩固大家的c语言知识 知识回顾 在前一章中我们已经介绍了顺序表，相信大家对顺序表的实现已经有所了解了吧！ 但是，这种数据结构，难免会有以下的缺陷 我们在中间位置插入或删除数据的话，可能需要挪动后面的所有数据，时间复杂度较高==(O(n))== 我们的空间是按照2倍的常数开辟的，可能会造成空间的浪费，比
数据结构总结 第二章 线性表——双向链表
weixin_44498400的博客
01-04 114
双向链表的存储结构 //Double Linked List typedef struct DuLNode { ElemType data; struct DuLNode *prior; struct DuLNode *next; }DuLNode, *DuLinkList; 插入 Status ListInsert_DuL(DuLNode *L, int i, ElemType e) { //在带头结点的双向链表L中第i个位置之前插入元素e if(!(p=GetElem_DuL(L,i))
数据结构课后习题答案第二章 线性表.docx
11-12
本章主要探讨了线性表的两种常见存储结构——顺序表和链表，以及它们各自的特点和适用场景。 首先，头指针、头结点和首元结点是链表中的关键概念。头指针是一个变量，它存储了链表中第一个结点的地址，用来标识整个...
第二章++线性表.ppt
07-28
在本章中，我们深入探讨线性表的概念、类型定义以及其两种主要的实现方式——顺序表示和链式表示。 线性表的数据元素之间遵循线性关系，意味着每个元素除了第一个和最后一个，都有一个直接的前驱和一个直接的后继。...
第02章 线性表(Java版).zip_Java编程_Java_
08-10
例如，多项式2x^3 + 3x^2 - x + 5 可以表示为一个链表，第一个节点代表项2x^3，第二个节点代表3x^2，以此类推。基于线性表的多项式可以方便地进行加法、减法和乘法运算。在Java中，我们可以创建一个`Polynomial`类，...
数据结构：第二章栈.ppt
09-17
首先，栈可以被视为一个只能在一端进行插入（压栈）和删除（弹栈）操作的线性表。这个特殊的端被称为栈顶，而相对的一端则是栈底。栈的操作特点是新加入的元素（最近插入的）会最先被移除，这就是LIFO的含义。例如，...
数据结构（耿国华，高等教育出版社）第二章线性表课后习题第5题答案
04-01
标题中的“数据结构（耿国华，高等教育出版社）第二章线性表课后习题第5题答案”指的是一个关于数据结构课程的经典教材——耿国华编著的《数据结构》中的一个问题。此书通常会深入讲解各种数据结构，如线性表、栈、...
数据结构--二叉树遍历
binhyun的博客
07-15 692
（1）前序遍历 （2）定义结构体 （3）前序遍历实现 （4）中序遍历实现 （5）二叉树的节点个数 （6）二叉树树叶节点个数 （7）二叉树的高度 （8）二叉树节点的开辟 （9）建立一个测试二叉树 （10）测试二叉树相关函数的功能 （11）第k层的数据个数 （12）二叉树里面查找节点
数据结构（初阶3.单链表）
2401_83968713的博客
07-14 656
一、单链表1.1概念与结构1.2结点1.3链表的性质1.4链表的打印二、实现单链表SList.hSList.c申请新节点尾插头插尾删头删在指定位置之前插入数据在指定位置之后插入数据删除指定位置结点删除指定位置之后的结点销毁结点test.c。
数据结构第35节 性能优化 算法的选择
hummhumm的专栏
07-18 385
算法的选择对于优化程序性能至关重要。不同的算法在时间复杂度、空间复杂度以及适用场景上有着明显的差异。下面我将结合具体的代码示例，来讲解几种常见的算法选择及其优化方法。
数据结构(5.1)——树的性质
m0_65240792的博客
07-16 210
1%29%5D。
24暑假算法刷题 | Day16 | LeetCode 513. 找树左下角的值，112. 路径总合，106. 从中序和后序遍历序列构造二叉树
最新发布
weixin_54468359的博客
07-18 800
24暑假刷题day15打卡 二叉树进阶
【数据结构】二叉树-1
m0_46676283的博客
07-15 862
现实中我们通常把堆(一种二叉树)使用顺序结构的数组来存储，需要注意的是这里的堆和操作系统虚拟进程地址空间中的堆是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。也就是说，如果一个二叉树的层数为K，且结点总数是 ，则它就是满二叉树。双亲节点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点；孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点；
【排序算法】—— 归并排序
2302_80105876的博客
07-15 823
归并排序，排序，归并排序非递归，有序数组排序，外排序算法
【数据结构】手写快速排序
qq_59143106的博客
07-14 306
什么是快速排序？首先确立pivot，比如下图位于末尾然后i遍历3到6在3的时候，j指向i前面一位如果3
【Java--数据结构】栈的应用
2301_80898480的博客
07-14 756
如有错误，欢迎指出~
数据结构第二章：线性表详解
本PPT详细讲解了计算机科学与技术专业中的核心课程——数据结构的第二章内容，即线性表。线性表是一种基本且重要的数据结构，它由一个有序的数据元素集合组成，每个元素在集合中都有唯一的前后关系。 线性表的四个...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值