线性表的链式存储结构

最新推荐文章于 2024-04-09 19:53:40 发布
最新推荐文章于 2024-04-09 19:53:40 发布
阅读量289 收藏 4
点赞数 2
分类专栏： 数据结构详解 文章标签： 链表 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/haijv/article/details/129716177
版权

3.2 线性表的链式存储结构

之前我们学习过线性表的顺序结构，最大的缺点是，插入和删除操作需要移动大量元素，所以引入线性表的链式存储结构。

文章目录

3.2.1 线性表链式存储结构的定义

n个结点链结成一个链表，即为线性表(a1,a2,a3,···,an)的链式存储结构。

一个结点包含：数据域和指针域

  • 数据域：存储数据元素的信息。
  • 指针域：存储直接后继元素，其中存储的信息称作指针或域。

我们把链表中第一个结点的存储位置叫做头指针。最后一个结点的指针为“空”。（通常用==^,或NULL==）

为了方便操作链表，在单链表的第一个结点前引入头结点，其数据域不存储任何信息，指针域指向链表的第一个结点的指针。

代码如下：

/*线性表的单链表存储结构*/
typedef struct Node{
    ElemType data;
    struct Node *next;
}Node;
typedef struct Node *LinkList; /*定义LinkList*/

3.2.2 单链表的读取

实现一个GetElem(L,i,&e)函数，通过索引寻找第i个数据值，并且值存入指针e中。

获得链表第i个数据的算法思路：

  1. 声明一个指针p指向链表第一个结点，初始化j从1开始；
  2. 当j<i时，就遍历链表，让p的指针向后移动，不断指向下一结点，j累加1；
  3. 若到链表末尾p为空，则说明第i个结点不存在；
  4. 否则查找成功，返回结点p的数据。

代码如下：

/*初始条件：链式线性表L已存在，1<=i<=ListLength(L)*/
/*操作结果：用e返回L中第i个数据元素的值*/
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不为空或者计数器还没有等于i 循环继续*/
        p = p->next;
        ++j;
    }
    if( !p || j>i)
        return ERROR;	/*第i个元素不存在*/
    *e = p->data;	    /*取第i个元素的数据*/
    return OK;
}

3.2.3 单链表的插入

我们要实现将s结点插入到p和p->next之间的操作，如图：

在这里插入图片描述
在这里插入图片描述

只需要让s->next和p->next的指针做一点改变即可。

s->next = p->next;
p->next = s;

注意：这两行代码顺序是不能更改的，若先让p->next = s，则p->next会被s的地址覆盖，会让真正拥有ai+1元素数据的结点没有上级，这样插入操作是失败的。

而对于表头，表尾的操作都是一样的。

单链表第i个数据处插入结点的算法思路：

  1. 声明一指针p指向链表头结点，初始化j从1开始。
  2. 当j<i时，就遍历链表，让p的指针向后移动，不断指向下一结点，j累加1。（p会指向要插入位置的前一个位置）
  3. 若到链表末尾p为空，说明第i个结点不存在。
  4. 否则查找成功，在系统中生成一个空结点s。
  5. 将数据元素e赋值给s->data。
  6. 单链表的插入语句 s->next = p->next; p->next = s;
  7. 返回成功

代码如下：

/*初始条件：链式线性表L已存在，1<=i<=ListLength(L)*/
/*操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1*/
Status ListInsert(LinkList *L,int i,ElemType e){
    int j;
    LinkList p,s;
    p = *L;
    j = 1;
    while (p && j<i){                      /*寻找第i个结点*/
        p = p->next;
        ++j;
    }
    if (!p || j>i)                         /*第i个元素不存在*/
        return ERROR;
    
    s = (LinkList)malloc(sizeof(Node));    /*生成新结点，malloc分配空间*/
    s->data = e;
    s->next = p->next;                     /*将p的后继赋值给s的后继*/
    p->next = s;                           /*将s赋值给p的后继*/
    return OK;
}

3.2.4 单链表的删除

设存储元素ai的结点q，要实现删除结点q的操作，如图：
在这里插入图片描述
在这里插入图片描述

这样就完成了删除操作，删除操作代码：

q = p->next;
p->next = q->next;

其实也可以用一步完成：

p->next = p->next->next;

对于删除链表最后一个结点也是适用的。

单链表第i个数据删除结点的算法思路：

  1. 声明一指针p指向链表头结点，初始化j从1开始。
  2. 当j<i时，就遍历链表，让p的指针向后移动，不断指向下一个结点，j累加1。
  3. 若到链表末尾为空，则说明第i个结点不存在。
  4. 否则查找成功，将欲删除的结点p->next赋值给q。
  5. 单链表删除语句：p->next = q->next;
  6. 将q结点中的数据赋值给e，作为返回。
  7. 释放q结点。
  8. 返回成功。

代码如下：

/*初始条件：链式线性表L已存在，1<=i<=ListLength(L)*/
/*操作结果：删除L的第i个数据元素，并用e返回其值，L长度减1*/
Status ListDelete(LinkList *L,int i,ElemType *e){
    int j;
    LinkList p,q;
    p = *L;
    j = 1;
    while (p->next && j<i){           /*遍历寻找第i个元素*/
        p = p->next;
        ++j;
    }
    if (!(p->next) || j>i)
        return ERROR;                 /*第i个元素不存在*/
    
    q = p->next;                     
    p->next = q->next;                /*将q的后继赋值给p的后继*/
    *e = q->data;                     /*将q结点的数据给e*/
    free(q);                          /*回收q结点，释放内存*/
    return OK;
}

假设我们要完成在i个位置插入10个结点的操作，对于顺序结构线性表每一次插入和删除都需要移动n-i个结点，每次都是O(n)，而对于单链表来说，在第一次，找到第i个位置的指针，时间复杂度为O(n)，但之后仅仅是赋值移动指针而已，时间复杂度都是O(1)。

显然，对于插入或删除数据越频繁的操作，单链表的效率优势就越明显。

3.2.5 单链表的整表创建

对于单链表来说，他所占用的空间大小和位置是不需要预先分配划定的，可以根据系统情况和实际需求即时生成。

所以创建单链表的过程是一个动态生成链表的过程。即从空表的初始状态起，依次建立各元素结点，并逐个插入链表。

单链表整表创建思路：

  1. 声明一指针p和计数器变量i。

  2. 初始化一空链表L。

  3. 让L的头结点的指针指向NULL，即建立一个带头结点的单链表。

  4. 循环：

    • 生成一新结点赋值给p。

    • 随机生成一数字赋值给p的数据域p->data。

    • 将p插入到头结点与前一新结点之间

/*随机产生n个元素的值，建立带表头结点的单链线性表L（头插法）*/
void CreateListHead(LinkList *L,int n){
    LinkList p;
    int i;
    srand(time(0));                            /*初始化随机数种子*/
    *L = (LinkList)malloc(sizeof(Node));

    (*L)->next = NULL;                         /*先建立一个带头结点的单链表*/
    for(i=0; i<n; i++){
        p = (LinkList)malloc(sizeof(Node));    /*生成新结点*/
        p->data = rand()%100+1;                /*随机生成100以内的数字*/
        p->next = (*L)->next;
        (*L)->next = p;                        /*插入到表头*/ 
    }
}

插入部分的图解：

在这里插入图片描述

还有一种比较符合正常思维的插入法，就是从后面插入新的结点，称为尾插法。

代码如下：

/*随机产生n个元素的值，建立带表头结点的单链线性表L（尾插法）*/
void CreateListTail(LinkList *L,int n){
    LinkList p,r;                                       
    int i;
    srand(time(0));                                     /*初始化随机数种子*/
    *L = (LinkList)malloc(sizeof(Node));                /*L为整个线性表*/
    r=*L;                                               /*r指向表尾*/
    for(i=0; i<n; i++){
        p = (LinkList)malloc(sizeof(Node));
        p->data = rand()%100+1;
        r->next = p;
        r = p;                                          /*将新插入的结点设置为表尾终端结点*/
    }
    r->next = NULL;                                     /*表示当前链表结束*/
}

图解：
在这里插入图片描述

3.2.6 单链表的整表删除

当我们不需要使用链表时，我们需要把他销毁，也就是在内存中将其释放。

单链表整表删除的算法思路如下：

  1. 声明一指针p和q。
  2. 将第一个结点赋值给p。
  3. 循环：
    • 将下一结点赋值给q。
    • 释放p。
    • 将q赋值给p。

实现代码：

/*初始条件：链式线性表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;
}

3.2.7 单链表初始化，获取长度等

(1)初始化链表：

/*初始化单链表*/
Status InitList(LinkList *L){
    *L = (LinkList)malloc(sizeof(Node));     /* 产生头结点,并使L指向此头结点 */
    if (!(*L))
        return ERROR;
    (*L)->next = NULL;                       /*指针域为空*/

    return OK;
}

(2)判断链表是否为空：

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

(3)获取链表长度：

/* 初始条件：链式线性表L已存在。操作结果：返回L中数据元素个数 */
int ListLength(LinkList L){
    int i = 0;
    LinkList p = L->next;    /*p指向L第一个结点*/
    while (p){
        i++;
        p = p->next;
    }
    return i;
}

(4)根据值找位置

/* 初始条件：链式线性表L已存在 */
/* 操作结果：返回L中第1个与e满足关系的数据元素的位置。 */
/* 若这样的数据元素不存在，则返回值为0 */
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;
    }
}

(5)遍历链表并输出

Status visit(ElemType c){
    printf("%d ",c);
    return OK;
}

/* 初始条件：链式线性表L已存在 */
/* 操作结果：依次对L的每个数据元素输出 */
Status ListTraverse(LinkList L){
    LinkList p = p->next;
    while (p){
        visit(p->data);
        p = p->next;
    }
    printf("\n");
    return OK;
}

3.2.8 测试

代码如下：

int main(){        
    LinkList L;
    ElemType e;
    Status i;
    int j,k;
    i=InitList(&L);
    printf("==================TEST==================\n");
    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为表长 */
    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); 

    j=5;
    ListDelete(&L,j,&e); /* 删除第5个数据 */
    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,20);
    printf("整体创建L的元素(尾插法)：");
    ListTraverse(L); 

    system("pause");

    return 0;
}

运行结果：

==================TEST==================
初始化L后：ListLength(L)=0
在L的表头依次插入1～5后：L.data=5 4 3 2 1
ListLength(L)=5
L是否空：i=0(1:是 0:否)
清空L后：ListLength(L)=0
L是否空：i=1(1:是 0:否)
在L的表尾依次插入1～10后：L.data=1 2 3 4 5 6 7 8 9 10
ListLength(L)=10
在L的表头插入0后：L.data=0 1 2 3 4 5 6 7 8 9 10
ListLength(L)=11
第5个元素的值为：4
第4个元素的值为3
第5个元素的值为4
删除第12个数据失败
删除第11个的元素值为：10
依次输出L的元素：0 1 2 3 4 5 6 7 8 9
删除第5个的元素值为：4
依次输出L的元素：0 1 2 3 5 6 7 8 9

清空L后：ListLength(L)=0
整体创建L的元素(头插法)：54 55 3 11 44 31 71 31 15 88 56 79 45 40 29 59 23 30 10 83

删除L后：ListLength(L)=0
整体创建L的元素(尾插法)：83 10 30 23 59 29 40 45 79 56 88 15 31 71 31 44 11 3 55 54
请按任意键继续. . .

运行结果图：

在这里插入图片描述

3.2.9 完整代码

#include<stdio.h>
#include<stdlib.h>
#include<ctype.h>
#include<string.h>

#include<math.h>
#include<time.h>

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAXSIZE 20


typedef int Status;         /*函数返回状态码*/
typedef int ElemType;


/*线性表的单链表存储结构*/
typedef struct Node{
    ElemType data;
    struct Node *next;
}Node;
typedef struct Node *LinkList; /*定义LinkList*/

/*初始化单链表*/
Status InitList(LinkList *L){
    *L = (LinkList)malloc(sizeof(Node));     /* 产生头结点,并使L指向此头结点 */
    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中数据元素个数 */
int ListLength(LinkList L){
    int i = 0;
    LinkList p = L->next;    /*p指向L第一个结点*/
    while (p){
        i++;
        p = p->next;
    }
    return i;
}

/* 初始条件：链式线性表L已存在 */
/* 操作结果：返回L中第1个与e满足关系的数据元素的位置。 */
/* 若这样的数据元素不存在，则返回值为0 */
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;
    }
}


Status visit(ElemType c){
    printf("%d ",c);
    return OK;
}

/* 初始条件：链式线性表L已存在 */
/* 操作结果：依次对L的每个数据元素输出 */
Status ListTraverse(LinkList L){
    LinkList p = L->next;
    while (p){
        visit(p->data);
        p = p->next;
    }
    printf("\n");
    return OK;
}

/*初始条件：链式线性表L已存在，1<=i<=ListLength(L)*/
/*操作结果：用e返回L中第i个数据元素的值*/
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不为空或者计数器还没有等于i 循环继续*/
        p = p->next;
        ++j;
    }
    if( !p || j>i)
        return ERROR;   /*第i个元素不存在*/
    *e = p->data;       /*取第i个元素的数据*/
    return OK;
}


/*初始条件：链式线性表L已存在，1<=i<=ListLength(L)*/
/*操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1*/
Status ListInsert(LinkList *L,int i,ElemType e){
    int j;
    LinkList p,s;
    p = *L;
    j = 1;
    while (p && j<i){                      /*寻找第i个结点*/
        p = p->next;
        ++j;
    }
    if (!p || j>i)                         /*第i个元素不存在*/
        return ERROR;
    
    s = (LinkList)malloc(sizeof(Node));    /*生成新结点，malloc分配空间*/
    s->data = e;
    s->next = p->next;                     /*将p的后继赋值给s的后继*/
    p->next = s;                           /*将s赋值给p的后继*/
    return OK;
}

/*初始条件：链式线性表L已存在，1<=i<=ListLength(L)*/
/*操作结果：删除L的第i个数据元素，并用e返回其值，L长度减1*/
Status ListDelete(LinkList *L,int i,ElemType *e){
    int j;
    LinkList p,q;
    p = *L;
    j = 1;
    while (p->next && j<i){           /*遍历寻找第i个元素*/
        p = p->next;
        ++j;
    }
    if (!(p->next) || j>i)
        return ERROR;                 /*第i个元素不存在*/
    
    q = p->next;                     
    p->next = q->next;                /*将q的后继赋值给p的后继*/
    *e = q->data;                     /*将q结点的数据给e*/
    free(q);                          /*回收q结点，释放内存*/
    return OK;
}

/*随机产生n个元素的值，建立带表头结点的单链线性表L（头插法）*/
void CreateListHead(LinkList *L,int n){
    LinkList p;
    int i;
    srand(time(0));                            /*初始化随机数种子*/
    *L = (LinkList)malloc(sizeof(Node));

    (*L)->next = NULL;                         /*先建立一个带头结点的单链表*/
    for(i=0; i<n; i++){
        p = (LinkList)malloc(sizeof(Node));    /*生成新结点*/
        p->data = rand()%100+1;                /*随机生成100以内的数字*/
        p->next = (*L)->next;
        (*L)->next = p;                        /*插入到表头*/ 
    }
}

/*随机产生n个元素的值，建立带表头结点的单链线性表L（尾插法）*/
void CreateListTail(LinkList *L,int n){
    LinkList p,r;                                       
    int i;
    srand(time(0));                                     /*初始化随机数种子*/
    *L = (LinkList)malloc(sizeof(Node));                /*L为整个线性表*/
    r=*L;                                               /*r指向表尾*/
    for(i=0; i<n; i++){
        p = (LinkList)malloc(sizeof(Node));
        p->data = rand()%100+1;
        r->next = p;
        r = p;                                          /*将新插入的结点设置为表尾终端结点*/
    }
    r->next = NULL;                                     /*表示当前链表结束*/
}


/*初始条件：链式线性表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;
}

int main(){        
    LinkList L;
    ElemType e;
    Status i;
    int j,k;
    i=InitList(&L);
    printf("==================TEST==================\n");
    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为表长 */
    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); 

    j=5;
    ListDelete(&L,j,&e); /* 删除第5个数据 */
    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,20);
    printf("整体创建L的元素(尾插法)：");
    ListTraverse(L); 

    system("pause");

    return 0;
}
压力小子呀
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构（四） — 线性表之链式存储
dashifu11111的博客
03-26 2903
一、线性表的链式存储结构 1、线性表链式存储结构定义 线性表的链式存储结构的特点是用一组任意的存储单元存储线性表的数据元素，这组存储单元可以是连续的，也可以是不连续的。这就意味着，这些数据元素可以存在内存未被占用的任意位置。 以前在顺序结构中，每个数据元素只需要存数据元素信息就可以了。现在链式结构中，除了要存数据元素信息外， 还要存储它的后继元素的存储地址。 因此，为了...
2.3 线性表的链式存储结构(链表)
jsxyg63的博客
09-20 1297
基本概念和特点 链表的定义 -线性表的链式存储结构称之为链表(linked list)。链表包括两部分构成：数据域和指针域。数据域保存数据元素，指针域描述数据元素的逻辑关系。 - 链表通常使用带头结点的表示。指向头结点的指针称之为头指针(head pointer)，指向最后一个结点（也就是尾结点）的指针称之为尾指针(tail pointer)。 - 链表不具备随机存取特性。 - 存储密度
数据结构——线性表的链式存储
weixin_46272350的博客
08-11 4949
通常采用链式存储结构的线性表称为线性链表。从链式方式的角度看，链表可以分为单链表，循环链表和双链表。 1.单链表 链表是用一组任意存储单元来存放线性表的结点，这组存储单元可以是连续的，也可以是非连续的，甚至是零散分布在内存的任何位置上。因此，链表中结点的逻辑顺序和物理顺序不一定相同。 结点包括两个域：数据域用来存储结点的值，指针域用来存储数据元素的直接后继的地址。线性链表正是通过每个结点的指针域将线性表的n个结点按其逻辑顺序连接在一起。又因为线性链表的每个结点只有一个next指针域，所以这...
数据结构——线性表链式存储
weixin_51785373的博客
10-14 1580
线性表的存储方式分为顺序存储和链式存储。其中链式存储是指将线性表中的元素按照一定的次序链接起来，每个元素包含两个部分：数据域和指针域。其中，数据域用于存储元素的值，指针域用于指向下一个元素的地址。通过指针域之间的链接，可以将线性表中的元素连接成一条链式结构。结点在存储器中的位置是任意的，即逻辑上相邻的数据元素在物理上不一定相邻。访问时只能通过头指针进入链表，并通过每个结点的指针域依次向后顺序扫描其余结点，所以寻找到一个结点和最后一个结点所花费的时间不等。1、链表分为单链表、循环链表、双向链表。
数据结构——线性表（链式存储结构）
最新发布
qq_55869380的博客
04-09 1504
链表的13种操作 实现思路和代码
线性表的链式存储结构..
07-11
实验二 线性表的链式存储结构 题目：设计并实现以下算法：给出用单链表存储多项式的结构，利用后接法生成多项式的单链表结构，实现两个多项式相加的运算，并就地逆置相加后的多项式链式。1. 用户可以根据自己的需求...
数据结构实验报告2线性表的链式存储结构.pdf
09-30
数据结构实验报告2线性表的链式存储结构 本实验报告的主要内容是介绍线性表的链式存储结构，并通过编程实验来掌握线性表的逻辑结构和链式存储结构，以及单链表的基本算法。 一、线性表的概念 线性表是最基本的...
数据结构实验报告2线性表的链式存储结构.doc
07-11
学院： 专业： 班级： "姓名 " "学号 " "实验组" " "实验时间 "2011-11-11 "指导教师" "成绩 " " "实验项目名称"线性表的链式存储结构 " "实"了解和掌握线性表的逻辑结构和链式存储结构，掌握单链表的基本算法" "验...
线性表的链式存储和实现
12-22
存储结构分为两种，线性表的这两种存储结构在时间复杂度上各有特色，若在操作中涉及遍历、查找较多的话，则宜用顺序存储结构；若涉及插入、删除较多的话，则宜用链式存储；具体选择哪一种存储结构要根据需要进行的...
线性表的链式存储_线性表的链式存储_
10-02
这套资料是实现了WindowC++中的数据结构的线性表的链式存储
关于线性表的顺序存储和链式存储结构的实验报告
06-15
该文档饱含了数据结构课程中关于线性表的十二个基本操作的实现。对于不同的线性表的存储结构，利用C语言分别实现相应的算法
线性表的链式存储结构设计.doc
07-06
线性表的链式存储结构设计 线性表是计算机科学中的一种基本数据结构，链式存储结构是线性表的一种常见实现方式。链式存储结构的设计是线性表的基本操作的实现的基础。 实验一：设计算法求 A 和 B 的并集 C，使用...
java线性表的存储结构及其代码实现
08-29
Java 线性表是一种基本的数据结构，它的存储结构可以分为顺序存储结构和链式存储结构两种。在 Java 中，ArrayList 类就是线性表的数组实现。下面是 Java 线性表的存储结构和代码实现。 一、顺序存储结构 顺序存储...
线性表的链式存储结构.doc
09-13
线性表的链式存储结构.doc 线性表的链式存储结构.doc 线性表的链式存储结构.doc
【数据结构】线性表的链式存储
DAY I 的成长之路
05-08 2464
💯针对顺序存储的缺点，我们可以进行优化，也就得到了链式存储结构，它通过链建立起数据元素之间的逻辑关系，头指针：L，用来标识一个单链表，头指针为NULL时表示一个空表头结点：放在单链表的第一个元素之前，不存放信息，只是起到利于操作的作用（一般不计入表长），头结点的指针域指向线性表的第一个元素
初学数据结构——从零开始的数据结构学习第五天（线性表的链式存储方式）
Lazy_ChessPlayer的博客
04-10 2207
本博客为本人在学习数据结构路途上的知识整理，如觉得对有你有所帮助，还希望留下一个赞。由于博主只是一名大一新生，如果博文中出现错误，欢迎指正。如果想要转载，附上链接就行。线性表中各个数据元素在存储器中的位置是任意的，即逻辑上相邻的数据元素在物理上不一定相邻。线性表的链式表示又称为非顺序映像或链式映像。一种头尾相接的链表（即：表中最后一个结点的指针域指向头结点，整个链表形成一个环）在单链表的每个结点单再增加一个指向其直接前驱的指针域prior，这样链表中就形成了有两个方向不同的链，故称为双向链表。
链式存储结构的线性表
徐永赛的博客
07-18 1293
链式存储结构的线性表

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

压力小子呀

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

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

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

打赏作者

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

抵扣说明：

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

余额充值