【数据结构】线性表的链式表示

最新推荐文章于 2022-10-13 15:46:11 发布
最新推荐文章于 2022-10-13 15:46:11 发布
阅读量1.6k 收藏 18
点赞数 1
CC 4.0 BY-SA版权
分类专栏： 温故知新 【专题】数据结构
本文为博主原创文章，未经博主允许不得转载。
本文链接：https://blog.csdn.net/wingrez/article/details/97929944

参考资料：《数据结构（C语言版）严蔚敏著》
版权说明：未经作者允许，禁止转载。如引用本文内容，需标明作者及出处。如本文侵犯了您的权益，请联系我删除并致歉。
文章说明：如文章中出现错误，请联系我更改。如您对文章的内容有任何疑问，也欢迎来与我讨论。
本文正在施工中...请稍等...
专题介绍

线性表的链式表示

线性表的链式表示即用一组任意的存储单元存储线性表的数据元素（这组存储单元可以是连续的，也可以是不连续的）。为了建立数据元素间的逻辑关系，对于每个数据元素，除了存储自身信息。还需要存储一个指示其直接后继的信息（即直接后继的存储位置）。这两部分信息组成了数据元素的存储映像，称为结点。通常第一个数据元素的结点称为首结点，最后一个数据元素的结点称为尾结点。结点包括两个域：存储数据元素信息的域称为数据域，存储直接后继存储位置信息的域称为指针域。指针域中存储的信息称作指针或链。n个结点的链依次连接起来，即为线性表的链式存储结构，称为链表。

通常，设置一个指针，称之为头指针，头指针指示链表中首结点的存储位置，用来标识一条链表。为了简化插入和删除操作，有时在首结点前附加一个结点，称之为头结点，头结点的数据域可以不存储任何信息，指针域存储指向首结点的指针，当设置头结点时，头指针指向头结点。

单链表

当链表中的每个结点只包含一个指针域时，指针指向直接后继，此链表称为单链表或线性链表。

描述单链表：

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

双链表

当链表中的每个结点包含两个指针域时，其一指向直接后继，另一指向直接前驱，此链表称为双链表或双向链表。

描述双向链表：

typedef struct DLNode{
    ElemType data;
    struct DLNode *prior;
    struct DLNode *next; 
}DLNode, *DLinkList;

循环链表

单循环链表 

当单链表中尾结点的指针域指向链表的第一个结点（首结点，如有头结点则为头结点）时，此链表称为单循环链表。其描述方法与单链表相同。

双循环链表

当双链表中尾结点的指针域之一指向链表的第一个结点（首结点，如有头结点则为头结点），第一个结点的指针域之一指向尾结点时，此链表称为双循环链表。其描述方法与双链表相同。

静态链表

使用数组来描述链表，结点中使用数组下标来指示直接后继在数组中的存储位置。其也分为静态单链表、静态双链表、静态单循环链表、静态双循环链表。（此处只介绍静态单链表）

描述静态链表：

//静态链表
#define MXASIZE　1000    //链表的最大长度
typedef struct{
    ElemType data;
    int next;
}component, SLinkList[MAXSIZE];

链表上基本操作的实现

（以下操作中，链表均带头结点）

1、创建

//单链表 (头插法)
Stutus CreateList(LinkList &L, int n){
    //头插法：逆位序输入n个元素的值，建立带头结点的单链表L。
    L=(LinkList)malloc(sizeof(LNode));
    L->next=NULL;       //先建立一个带头结点的单链表
    for(i=n; i>0; --i){
        p=(LinkList)malloc(sizeof(LNode));  //生成新结点
        scanf(&p->data);                    //输入元素值
        p->next=L->next; L->next=p;         //插入到表头
    }
    return OK;
}

//单链表 （尾插法）
Status CreateList(LinkList &L, int n){
    //顺位序输入n个元素的值，建立带头结点的单链表L。
    L=(LinkList)malloc(sizeof(LNode));
    L->next=NULL;       //先建立一个带头结点的单链表
    r=L;                //表尾指针
    for(i=0; i<n; ++i){
        p=(LinkList)malloc(sizeof(LNode));  //生成新结点
        scanf(&s->data);                    //输入元素值
        r->next=p;                          //插入到表尾
        r=p;                                //r指向新的表尾结点
    }
    r->next=NULL;                           //尾结点指针置空
    return OK;
}

//双链表 (头插法)
Stutus CreateList(DLinkList &L, int n){
    //逆位序输入n个元素的值，建立带头结点的双链表L。
    L=(LinkList)malloc(sizeof(LNode));
    L->prior=L->next=NULL;       //先建立一个带头结点的双链表
    for(i=n; i>0; --i){
        p=(LinkList)malloc(sizeof(LNode));  //生成新结点
        scanf(&p->data);                    //输入元素值
        L->next->prior=p;                         //更新首结点的前驱
        p->prior=L; p->next=L->next; L->next=p;   //插入到表头      
    }
    return OK;
}

//单循环链表 (头插法)
Status CreateList(LinkList &L, int n){
    //逆位序输入n个元素的值，建立带头结点的单链表L。
    L=(LinkList)malloc(sizeof(LNode));
    L->next=L;       //先建立一个带头结点的单链表
    for(i=n; i>0; --i){
        p=(LinkList)malloc(sizeof(LNode));  //生成新结点
        scanf(&p->data);                    //输入元素值
        p->next=L->next; L->next=p;         //插入到表头
    }
    return OK;
}

//双循环链表 (头插法)
Stutus CreateList(DLinkList &L, int n){
    //逆位序输入n个元素的值，建立带头结点的双链表L。
    L=(LinkList)malloc(sizeof(LNode));
    L->prior=L->next=L;       //先建立一个带头结点的双链表
    for(i=n; i>0; --i){
        p=(LinkList)malloc(sizeof(LNode));  //生成新结点
        scanf(&p->data);                    //输入元素值
        L->next->prior=p;                         //更新首结点的前驱
        p->prior=L; p->next=L->next; L->next=p;   //插入到表头      
    }
    return OK;
}

//静态链表
Status CreateList(SLinkList &L, int n){
    //顺位序输入n个元素的值，建立带头结点的单链表L。
    if(n>MAXSIZE-1) return ERROR; 
    for(i=0; i<=n; ++i){
        scanf(L[i+1].data);
        L[i].cur=i+1;
    }
    L[n].cur=0;
    return OK;
}

2、销毁

//单链表 （双链表类似）
Status DestroyList(LinkList &L){
    p=L;
    while(p){
        q=L->next;
        free(p);
        p=q; 
    }
    L=NULL;
    return OK;
}

//单循环链表 （双循环链表类似）
Status DestroyList(LinkList &L){
    if(L->next=L){
        free(L); L=NULL;
        return OK;
    }
    p=L;
    while(p->next!=L){
        q=L->next;
        free(p);
        p=q; 
    }
    L=NULL;
    return OK;
}

//静态链表 无需手动销毁

3、清空

//单链表 （双链表类似）
Status ClearList(LinkList &L){
    p=L->next;
    while(p){
        q=p->next;
        free(p);
        p=q;
    }
    L->next=NULL;
    return OK;
}

//单循环链表 （双循环链表类似）
Status ClearList(DLinkList &L){
    if(L->next=L) return OK;
    p=L->next;
    while(p!=L){
        q=p->next;
        free(p);
        p=q;
    }
    L->next=L; //双循环链表：L->prior=L->next=L;
    return OK;
}

//静态链表
Status ClearList(SLinkList &L){
    SLinkList[0].cur=0;
    return OK;
}

4、判空

//单链表 （双链表类似）
Status ListEmpty(LinkList L){
    if(!L->next) return TRUE;
    return FALSE;
}

//单循环链表 （双循环链表类似）
Status ListEmpty(LinkList L){
    if(L->next==L) return TRUE;
    return FALSE;
}

//静态链表
Status ListEmpty(SLinkList L){
    if(L[0].cur==0) return TRUE;
    return FALSE;
}

5、计算表长

//单链表 （双链表类似）
int ListLength(LinkList L){
    p=L->next; i=0;
    while(p){
        p=p->next; ++i;
    } 
    return i;
}

//单循环链表 （双循环链表类似）
int ListLength(LinkList L){
    p=L->next; i=0;
    while(p!=L){
        p=p->next; ++i;
    } 
    return i;
}

//静态链表
int ListLength(SLinkList L){
    p=L[0].cur; i=0;
    while(p!=0){
        p=L[p].cur; ++i;
    }
    return i;
}

6、获取元素

//单链表 （双链表类似）
Status GetElem(LinkList L, int i, ElemType &e){
    //L为带头节点的单链表的头指针。
    //当第i个元素存在时，其值赋给e返回OK，否则返回ERROR
    p=L->next; j=1;        //初始化，p指向首结点，j为计数器
    while(p && j<i){       //顺着指针向后查找，直到p指向第i个元素或p为空 
        p=p->next; ++j;
    }
    if(!p || j>i) return ERROR;    //第i个元素不存在
    e=p->data;      //取第i个元素
    return OK; 
}

//单循环链表 （双循环链表类似）
Status GetElem(LinkList L, int i, ElemType &e){
    //L为带头节点的单链表的头指针。
    //当第i个元素存在时，其值赋给e返回OK，否则返回ERROR
    p=L->next; j=1;        //初始化，p指向首结点，j为计数器
    while(p!=L && j<i){       //顺着指针向后查找，直到p指向第i个元素或p为空 
        p=p->next; ++j;
    }
    if(p==L || j>i) return ERROR;    //第i个元素不存在
    e=p->data;      //取第i个元素
    return OK; 
}

//静态链表
Status GetElem(SLinkList L, int i, ElemType &e){
    p=L[0].cur; j=1;
    while(p && j<i){
        p=L[p].cur; ++j;
    }
    if(!p || j>i) return ERROR;
    e=L[p].data;
    return OK;
}

7、定位元素

//单链表 （双链表类似）
int LocateElem(LinkList L, ElemType e, Status (*compare)(ElemType, ElemType)){
    p=L->next; i=1;
    while(p && !(*compare)(p->data, e)){
        p=p->next; ++i;
    }
    if(p) return i;
    return 0;
}

//单循环链表 （双循环链表类似）
int LocateElem(LinkList L, ElemType e, Status (*compare)(ElemType, ElemType)){
    p=L->next; i=1;
    while(p!=L && !(*compare)(p->data, e)){
        p=p->next; ++i;
    }
    if(p!=L) return i;
    return 0;
}

//静态链表
int LocateElem(SLinkList L, ElemType e, Status (*compare)(ElemType, ElemType)){
    p=L[0].cur;
    while(p && !(*compare)(p->data, e)){
        p=p->next;
    }
    return p;
}

8、获取前驱元素

//单链表
Status PriorElem(LinkList L, ElemType cur_e, ElemType &pre_e){
    p=L->next; q=L;
    while(p && p->data!=cur_e){
        q=p;    
        p=p->next;
    }
    if(!p || q==L) return ERROR;
    pre_e=q->data;
    return OK;
}

//双链表
Status PriorElem(LinkList L, ElemType cur_e, ElemType &pre_e){
    p=L->next;
    while(p && p->data!=cur_e){
        p=p->next;
    }
    if(!p || p->prior==L) return ERROR;
    pre_e=p->prior->data;
    return OK;
}

//单循环链表
Status PriorElem(LinkList L, ElemType cur_e, ElemType &pre_e){
    p=L->next; q=L;
    while(p!=L && p->data!=cur_e){
        q=p;    
        p=p->next;
    }
    if(p==L || q==L) return ERROR;
    pre_e=q->data;
    return OK;
}

//双循环链表
Status PriorElem(LinkList L, ElemType cur_e, ElemType &pre_e){
    p=L->next;
    while(p!=L && p->data!=cur_e){
        p=p->next;
    }
    if(p==L || p->prior==L) return ERROR;
    pre_e=p->prior->data;
    return OK;
}

//静态链表
Status PriorElem(SLinkList L, ElemType cur_e, ElemType &pre_e){
    p=L[0].cur; q=0;
    while(p && L[p].data!=cur_e){
        q=p;    
        p=L[p].cur;
    }
    if(!p || q==0) return ERROR;
    pre_e=L[q].data;
    return OK;
}

9、获取后继元素

//单链表 （双链表类似）
Status NextElem(LinkList L, ElemType cur_e, ElemType &next_e){
    p=L->next;
    while(p && p->data!=cur_e){
        p=p->next;
    }
    if(p==NULL || p->next=NULL) return ERROR;
    next_e=p->next->data;
    return OK;
}

//单循环链表 （双循环链表类似）
Status NextElem(LinkList L, ElemType cur_e, ElemType &next_e){
    p=L->next;
    while(p!=L && p->data!=cur_e){
        p=p->next;
    }
    if(p==L || p->next=L) return ERROR;
    next_e=p->next->data;
    return OK;
}

//静态链表
Status NextElem(SLinkList L, ElemType cur_e, ElemType &next_e){
    p=L[0].cur;
    while(p && L[p].data!=cur_e){
        p=L[p].cur;
    }
    if(!p || L[p].cur==0) return ERROR;
    next_e=L[L[p].cur].data;
    return OK;
}

10、插入元素

//单链表
Status ListInsert(LinkList &L, int i, ElemType e){
    //将元素e插入到带头结点的单链表L中的第i个位置
    p=L; j=0;
    while(p && j<i-1){
        p=p->next; ++j;    //寻找第i-1个结点
    } 
    if(!p || j>i-1) return ERROR;          //i小于1或者大于表长加1
    s=(LinkList)malloc(sizeof(LNode));     //生成新结点
    s->data=e; s->next=p->next;            //插入L中
    p->next=s;
    return OK; 
}

//双链表
Status ListInsert(DLinkList &L, int i, ElemType e){
    p=L->next; 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; s->prior=p->prior;
    p->prior->next=s; p->prior=s;
    return OK; 
}

//单循环链表
Status ListInsert(LinkList &L, int i, ElemType e){
    //将元素e插入到带头结点的单链表L中的第i个位置
    p=L; q=p->next; j=1;
    while(q!=L && j<i){
        p=q; q=p->next ++j;
    } 
    if(!q || j>i) return ERROR;          //i小于1或者大于表长加1
    s=(LinkList)malloc(sizeof(LNode));     //生成新结点
    s->data=e; s->next=p->next;            //插入L中
    p->next=s;
    return OK; 
}


//双循环链表
Status ListInsert(DLinkList &L, int i, ElemType e){
    //将元素e插入到带头结点的双循环链表L中的第i个位置
    //i的合法值为1<=i<=表长+1。
    if(!(p=GetElemPos(L,i)))      //在L中确定插入位置的指针p
        return ERROR;             //p=NULL，即插入位置不合法
    if(!(s=(DLinkList)malloc(sizeof(DLNode))))
        return ERROR;
    s->data=e;
    s->prior=p->prior; p->prior->next=s;
    s->next=p; p->prior=s;
    return OK; 
}

11、删除元素

//单链表
Status ListDelete(LinkList &L, int i, ElemType &e){
    //在带头结点的单链线性表L中，删除第i个元素，并由e返回其值
    p=L; j=0; 
    while(p->next && j<i-1){    //寻找第i个结点，并令p指向其前驱
        p=p->next; ++j;
    }
    if(!(p->next) || j>i-1) return ERROR;  //删除位置不合理 
    q=p->next; p->next=q->next;    //删除并释放结点 
    e=q->data;
    free(q);  
    return OK;
}

//双链表
Status ListDelete(DLinkList &L, int i, ElemType &e){
    p=L->next; j=1;
    while(p && j<i){
        p=p->next; ++j;
    }
    if(!p || j>i) return ERROR;
    q=p->prior; q->next=p->next; p->next->prior=q;
    e=p->data;
    free(p);
    return OK; 
}

//单循环链表
Status ListDelete(LinkList &L, int i, ElemType &e){
    p=L; j=0;
    while(p->next!=L && j<i-1){
        p=p->next; ++j;
    }
    if(p->next==L || j>i-1) return ERROR;
    q=p->next; p->next=q->next;
    e=q->data; free(q);
    return OK;
}

//双循环链表
Status ListDelete(DLinkList &L, int i, ElemType &e){
    //删除带头结点的双循环链表L的第i个元素
    //i的合法值为1<=i<=表长
    if(!(p=GetElemPos(L,i)))       //在L中确定第i个元素的位置指针p
        return ERROR;              //p=NULL，即第i个元素不存在
    e=p->data;
    p->prior->next=p->next;
    p->next->prior=p->prior;
    free(p);
    return OK; 
}

//静态链表
Status ListDelete(SLinkList &L, int i, ElemType &e){
    p=0; j=0; 
    while(L[p].cur && j<i-1){    //寻找第i个结点，并令p指向其前驱
        p=L[p].cur; ++j;
    }
    if(!(L[p].cur) || j>i-1) return ERROR;  //删除位置不合理 
    L[p].cur=L[L[p].cur].cur;
    e=L[L[p].cur].data;
    return OK;
}

12、遍历表

//单链表 （双链表类似）
Status ListTraverse(LinkList L, Status (*visit)(ElemType e)){
    p=L->next;
    while(p){
        (*visit)(p->data);
        p=p->next;
    }
    return OK;
}

//单循环链表 （双循环链表类似）
Status ListTraverse(LinkList L, Status (*visit)(ElemType e)){
    p=L->next;
    while(p!=L){
        (*visit)(p->data);
        p=p->next;
    }
    return OK;
}

//静态链表
Status ListTraverse(SLinkList L, Status (*visit)(ElemType e)){
    p=L[0].cur;
    while(p){
        (*visit)(L[p].data);
        p=L[p].cur;
    }
    return OK;
}

 

线性表的链式表示
m0_60128287的博客
04-29 319
链表用一组任意的存储单元存储线性表的数据元素，每个数据元素ai和指向后继的信息组成的存储映像称为结点，每个结点包含数据域和指针域。 目录 1.老师的代码 1.1结构体 1.2初始化 1.3打印链表 1.4链表尾部加入元素 1.5在指定位置后加入元素 1.6删除结点 1.7测试函数 1.8打印地址函数 1.9运行结果 2.自己的代码 ...
数据结构（python）----线性表的链式表示和实现
最新发布
2503_90864622的博客
02-28 999
结点在存储器中的位置是任意的，即逻辑上相邻的数据元素在物理上不一定相邻线性表的链式表示又称为非顺序映像或链式映像。每一个头指针对应一个单链表。
线性表的链式结构
01-12
线性表的链式结构的基本操作：包括创建、销毁、置空，删除和插入元素，查找等等
数据结构---线性表的链式表示
qq_63976098的博客
10-13 921
单链表，线性表的链式表示。
数据结构线性表的链式表示和实现.pdf
09-30
数据结构线性表的链式表示和实现 一、链式表示的基本概念 链式表示是一种数据结构，它使用链表来存储数据。链表是一种动态的数据结构，它由多个结点组成，每个结点包含了一个数据元素和一个指针，指向下一个结点。...
用C语言实现数据结构中的线性表（链式表示）
11-15
本人在学习数据结构时使用的是严蔚敏的《数据结构》，并根据课本内容完成了这个头文件，这个头文件把课本中的线性表的链式表示和实现都囊括在内了。部分实现中也做了相应的优化处理。如果想看线性表的顺序表示表示和...
数据结构实验报告2线性表的链式存储结构.pdf
09-30
线性表作为一种常见的数据结构，其特点是元素之间存在一对一的线性关系。线性表中数据元素之间的关系可以用序号表示，从而实现数据元素的快速访问。线性表可以是顺序存储，也可以是非顺序存储。在非顺序存储中，链式...
数据结构线性表的链式存储结构.pdf
09-30
数据结构线性表的链式存储结构 线性表是一种基本的数据结构，链式存储结构是线性表的一种常见的存储结构。链式存储结构指的是将数据元素存储在一个链表中，每个数据元素对应一个结点，结点中包含数据元素和指向下一...
数据结构——线性表——链式结构
communication_en的博客
07-05 839
对链表的理解和初始化通过一段代码示例展示：
线性表链式表示详解
educationer的博客
04-24 450
线性表的链式表示(链表数据结构)： 相对于线性表的顺序存储，线性表的链式存储结构，逻辑上相邻的元素在物理位置上不相邻，便于进行插入和删除操作，但同时也失去了顺序表可以随机存取的优点。 线性表的链式表示分为三种：单链表，循环链表和双向链表 （1） 单链表 元素的存储单元可以是连续的，也可以不是连续的 每一个结点有两部分组成：数据域和指针域 数据域：存储该数据元素的信息 指针域：存储直接后继元素位置的...
线性表：链式结构
m0_72941237的博客
09-05 233
线性表是链式结构也称作链表，那什么是链表？你可以把它想象成一串项链，数据就像是项链上的珠子，我们要做的就是用线把这些珠子串起来形成“链表”。当然，这样形容十分不准确，链表可比“项链”高级多了。
数据结构——线性表的链式表示
Tyler_Zx的博客
07-17 3718
线性表的定义 线性表是具有相同数据类型的n(n >= 0)个数据元素的有限序列。其中n为表长，当n = 0时，该线性表是一个空表。若用L命名线性表，其一般表示为：L = (a1, a2, ..., ai, ai+1, ..., an)。其中a1是唯一的”第一个”数据元素，an是唯一的”最后一个”数据元素。除第一个元素外，每个元素有且仅有一个直接前驱。除最后一个元素外，每个元素有且仅有一个直...
数据结构-线性表的链式表示
weixin_46441425的博客
04-12 1199
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

wingrez

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

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

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

打赏作者

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

抵扣说明：

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

余额充值