【C语言数据结构】线性表和单链表

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

线性表

1. 数据结构的划分

数据结构按逻辑划分为线性结构与非线性结构。

1.1 线性结构

有限的序列；序列中的每一个元素都有唯一的前驱和后继，除了开头和结尾两个节点。
线性表主要由顺序表或链表表示。在实际应用中，常以栈、队列、字符串等特殊形式使用。
它们共同的特点就是数据之间的线性关系，除了头结点和尾结点之外，每个结点都有唯一的前驱和唯一的后继，也就是所谓的一对一的关系。

1.11 顺序表

顺序表中每个元素被分配的内存空间是连续的，我们的编程语言中的数组就是顺序表。

优点：无须为元素逻辑关系而增加额外的存储空间，可以快速取其中某个元素。
缺点：

  1. 顺序表的长度相对固定，当定义长度过大，有可能会浪费空间，过小则可能发生溢出。
  2. 插入和删除元素时，如果要保持有序的话，需要移动大量的数据。

1.12 链表

内存是不连续的，各个元素分配的内存不一样，内存和内存之间用指针进行相连，内存空间可以动态分配，解决了顺序表的缺点。

1.2 非线性结构

对应于线性结构，非线性结构也就是每个结点可以有不止一个直接前驱和直接后继。常见的非线性结构包括：树、图等。

2. 单链表

（线性链式表，简称链表，特点是用一组任意的存储单元存储线性表的数据元素。因此为了表示当前元素和逻辑上的下一个元素之间的关系，除了存储本身的数据之外，还要存储一个指示其直接后继的信息。由这两个信息组成的单元叫做结点。）
所以链表需要定义一个数据域和一个指针域，指针域用于存放逻辑上的下一个节点的地址，即指向下一个节点。
在这里插入图片描述
头节点的数据域存储了节点的个数（除去头节点和尾节点），指针域指向链表的第一个节点。

2.1 单链表数据节点类型的定义

typedef struct LinkListNode
{
    ElemType                data; /* 数据域存储数据 */
    struct  LinkListNode    *next; /* 指针域存储下一个节点的地址 */
}LLNode;

其中宏定义ElemType便于修改元素类型，data是数据域，next是指针域。此处我们定义了一个next指针，而没有pre，指向上一个节点的指针，因此是单向链表（单链表），链表最后的节点指向NULL。

2.2 初始化单链表

Status initlist(LLNode *L)
{
    if(!L)
    {
        printf("%s Invalid input argument\n",__func__);
        return  ERROR;   
    }

    L->data = 0;    /* 头节点的数据域记录链表中有多少个节点,现在为0,即一个都没有 */
    L->next = NULL; 

    return SUCCESS;
}

链表的初始化时代表了头节点的初始化。

2.3 头插法

在这里插入图片描述

/* 在链表头插入新的节点 */
Status HeadInsert(LLNode *L,ElemType data)
{
    if(!L)
    {
        printf("%s Invalid input argument\n",__func__);
        return  ERROR;   
    }

    LLNode *newnode = (LLNode *)malloc(sizeof(LLNode));

    newnode->data = data; /* 把数据放入新的节点的数据域中 */
    newnode->next = L->next; /* 新的节点指向头结点的下一个节点（第一个节点） */

    L->next = newnode; /* 头结点指向新插入的节点 */
    L->data ++; /* 头结点的数据域+1，表示有新的一个节点插入 */

    return SUCCESS;
}

在链表的表头插入新的节点，让头节点指向新的节点。

2.4 尾插法

在这里插入图片描述

/* 在链表尾插入新的节点 */
Status TailInsert(LLNode *L,ElemType data)
{
    LLNode  *cur;

    if(!L)
    {
        printf("%s Invalid input argument\n",__func__);
        return  ERROR;   
    } 

    LLNode *newnode = (LLNode *)malloc(sizeof(LLNode));

    newnode->data = data; /* 把数据放入新的节点的数据域中 */
    newnode->next = NULL; /* 新的节点指向NULL(尾节点) */

    cur = L;
    while(cur->next) /* 遍历到最后一个节点 */
    {
        cur = cur->next;
    }    

    cur->next = newnode; /* 链表尾部插入新节点 */
    L->data ++; /* 头结点的数据域+1，表示有新的一个节点插入 */

    return SUCCESS;
}

在链表的尾部插入新的节点，让新节点指向NULL。

2.5 判空

/* 判断是否为空链表 */
Status JudgeNull(LLNode *L)
{
    if(!L)
    {
        printf("%s Invalid input argument\n",__func__);
        return  ERROR;       
    }

    if(0 == L->data || NULL == L->next) /* 链表头结点的数据域为记录多少个实际节点 */
    {
        printf("LinkList is NULL\n");
        return TRUE;
    }

    return FALSE;
}

判断链表是否为空链表，防止对空指针进行删除等操作，会导致段错误，主要是利用了头结点的特性，头结点记录了链表有多少个实际节点。

2.6 打印链表的全部数据

/* 遍历打印链表中所有的数据 */
Status PrintfList(LLNode *L)
{
    LLNode  *cur;
    Status  rv;

    if(!L)
    {
        printf("%s Invalid input argument\n",__func__);
        return  ERROR;   
    }

    rv = JudgeNull(L);
    if(rv == TRUE || rv == ERROR) /* 栈空或者出错 */
        return ERROR;

    cur = L->next;
    while(cur)
    {
        printf("%d->",cur->data);
        cur = cur->next;
    }
    printf("NULL\n");

    return SUCCESS;
}

打印前先判空，链表不为空的情况下，打印数据。

2.7 头删法

/* 从链表的头部删除一个节点 */
Status HeadDelete(LLNode *L)
{
    Status      rv;

    if(!L)
    {
        printf("%s Invalid input argument\n",__func__);
        return  ERROR;   
    } 

    rv = JudgeNull(L);
    if(rv == TRUE || rv == ERROR) /* 栈空或者出错 */
        return ERROR;

    LLNode *cur = L->next;
    L->next = cur->next; /* 让头结点指向原来第一个节点的后一个节点，即删除了原来第一个节点 */
    L->data --; /* 头结点的数据域-1，表示有新的一个节点删除 */

    free(cur); /* 删除后释放内存 */

    return SUCCESS;
}

让头结点指向原来第一个节点的后一个节点，并且释放掉第一个节点的内存空间，即删除了原来第一个节点。

2.8 尾删法

/* 从链表的尾部删除一个节点 */
Status TailDelete(LLNode *L)
{
    Status      rv;
    LLNode      *cur; /* 表示当前节点 */
    LLNode      *pre; /* 表示前一个节点 */

    if(!L)
    {
        printf("%s Invalid input argument\n",__func__);
        return  ERROR;   
    } 

    rv = JudgeNull(L);
    if(rv == TRUE || rv == ERROR) /* 栈空或者出错 */
        return ERROR;

    pre = L;
    cur = pre->next;
    while(cur->next) /* 遍历到最后一个节点 */
    {
        pre = cur;
        cur = pre->next;
    }   

    pre->next = NULL;
    free(cur); /* 释放内存空间 */

    L->data --;

    return SUCCESS;
}

把链表最后一个实际节点删除，前一个节点指向NULL，并且释放掉最后一个实际节点的内存空间。

2.9 删除链表中数据域 data 的节点

在这里插入图片描述

/* 删除链表中数据域 data 的节点 */
Status ApoDelete(LLNode *L,ElemType data)
{
    Status      rv;
    LLNode      *cur; /* 表示当前节点 */
    LLNode      *pre; /* 表示前一个节点 */
    int         i = 0;

    if(!L)
    {
        printf("%s Invalid input argument\n",__func__);
        return  ERROR;   
    } 

    rv = JudgeNull(L);
    if(rv == TRUE || rv == ERROR) /* 栈空或者出错 */
        return ERROR;
    
    pre = L;
    cur = pre->next;
    while(cur) /* 遍历到最后一个节点 */
    {
        if(data == cur->data)
        {
            pre->next = cur->next;
            free(cur);
            i++;
            cur = pre->next; /* 让cur指向删除节点的下一个节点，继续判断是否还有满足条件的节点 */
            continue;
        }

        pre = cur;
        cur = pre->next;
    }   

    L->data -= i;

    return SUCCESS;
}

删除链表中任意一个或多个数据域为data的节点。

2.10 清空链表

/* 清除链表 */
Status ClearList(LLNode *L)
{
    Status      rv;
    LLNode      *cur; /* 表示当前节点 */
    LLNode      *temp; /* 表示当前节点 */

    if(!L)
    {
        printf("%s Invalid input argument\n",__func__);
        return  ERROR;   
    } 

    rv = JudgeNull(L);
    if(rv == TRUE || rv == ERROR) /* 栈空或者出错 */
        return ERROR;  

    cur = L->next;
    while(cur)
    {
        temp = cur;
        cur = cur->next;
        free(temp);
    }

    L->data = 0; 
    L->next = NULL;

    return SUCCESS;
}

清除链表中的全部实际节点。

整体代码实现

/*********************************************************************************
 *      Copyright:  (C) 2022 Li Rongquan<2962837290@qq.com>
 *                  All rights reserved.
 *
 *       Filename:  LinkList.c
 *    Description:  This file is LinkList ctl. 
 *                 
 *        Version:  1.0.0(08/15/2022)
 *         Author:  Li Rongquan <2962837290@qq.com>
 *      ChangeLog:  1, Release initial version on "08/15/2022 01:21:16 AM"
 *                 
 ********************************************************************************/
#include <stdio.h>
#include <stdlib.h>

#define SUCCESS 0
#define ERROR -1
#define TRUE 1
#define FALSE 0

typedef int Status; /* Status 是函数的类型，其值是函数结果状态代码，如OK等 */
typedef int ElemType; /* ElemType类型根据实际情况而定，这里取int整型 */

typedef struct LinkListNode
{
    ElemType                data; /* 数据域存储数据 */
    struct  LinkListNode    *next; /* 指针域存储下一个节点的地址 */
}LLNode;

//typedef struct LinkListNode *LinkList; /* 定义一个别名Linklist(指针) 

Status initlist(LLNode *L)
{
    if(!L)
    {
        printf("%s Invalid input argument\n",__func__);
        return  ERROR;   
    }

    L->data = 0;    /* 头节点的数据域记录链表中有多少个节点,现在为0,即一个都没有 */
    L->next = NULL; 

    return SUCCESS;
}

/* 在链表头插入新的节点 */
Status HeadInsert(LLNode *L,ElemType data)
{
    if(!L)
    {
        printf("%s Invalid input argument\n",__func__);
        return  ERROR;   
    }

    LLNode *newnode = (LLNode *)malloc(sizeof(LLNode));

    newnode->data = data; /* 把数据放入新的节点的数据域中 */
    newnode->next = L->next; /* 新的节点指向头结点的下一个节点（第一个节点） */

    L->next = newnode; /* 头结点指向新插入的节点 */
    L->data ++; /* 头结点的数据域+1，表示有新的一个节点插入 */

    return SUCCESS;
}

/* 判断是否为空链表 */
Status JudgeNull(LLNode *L)
{
    if(!L)
    {
        printf("%s Invalid input argument\n",__func__);
        return  ERROR;       
    }

    if(0 == L->data || NULL == L->next) /* 链表头结点的数据域为记录多少个实际节点 */
    {
        printf("LinkList is NULL\n");
        return TRUE;
    }

    return FALSE;
}

/* 遍历打印链表中所有的数据 */
Status PrintfList(LLNode *L)
{
    LLNode  *cur;
    Status  rv;

    if(!L)
    {
        printf("%s Invalid input argument\n",__func__);
        return  ERROR;   
    }

    rv = JudgeNull(L);
    if(rv == TRUE || rv == ERROR) /* 栈空或者出错 */
        return ERROR;

    cur = L->next;
    while(cur)
    {
        printf("%d->",cur->data);
        cur = cur->next;
    }
    printf("NULL\n");

    return SUCCESS;
}

/* 在链表尾插入新的节点 */
Status TailInsert(LLNode *L,ElemType data)
{
    LLNode  *cur;

    if(!L)
    {
        printf("%s Invalid input argument\n",__func__);
        return  ERROR;   
    } 

    LLNode *newnode = (LLNode *)malloc(sizeof(LLNode));

    newnode->data = data; /* 把数据放入新的节点的数据域中 */
    newnode->next = NULL; /* 新的节点指向NULL(尾节点) */

    cur = L;
    while(cur->next) /* 遍历到最后一个节点 */
    {
        cur = cur->next;
    }    

    cur->next = newnode; /* 链表尾部插入新节点 */
    L->data ++; /* 头结点的数据域+1，表示有新的一个节点插入 */

    return SUCCESS;
}

/* 从链表的头部删除一个节点 */
Status HeadDelete(LLNode *L)
{
    Status      rv;

    if(!L)
    {
        printf("%s Invalid input argument\n",__func__);
        return  ERROR;   
    } 

    rv = JudgeNull(L);
    if(rv == TRUE || rv == ERROR) /* 栈空或者出错 */
        return ERROR;

    LLNode *cur = L->next;
    L->next = cur->next; /* 让头结点指向原来第一个节点的后一个节点，即删除了原来第一个节点 */
    L->data --; /* 头结点的数据域-1，表示有新的一个节点删除 */

    free(cur); /* 删除后释放内存 */

    return SUCCESS;
}

/* 从链表的尾部删除一个节点 */
Status TailDelete(LLNode *L)
{
    Status      rv;
    LLNode      *cur; /* 表示当前节点 */
    LLNode      *pre; /* 表示前一个节点 */

    if(!L)
    {
        printf("%s Invalid input argument\n",__func__);
        return  ERROR;   
    } 

    rv = JudgeNull(L);
    if(rv == TRUE || rv == ERROR) /* 栈空或者出错 */
        return ERROR;

    pre = L;
    cur = pre->next;
    while(cur->next) /* 遍历到最后一个节点 */
    {
        pre = cur;
        cur = pre->next;
    }   

    pre->next = NULL;
    free(cur); /* 释放内存空间 */

    L->data --;

    return SUCCESS;
}

/* 删除链表中数据域 data 的节点 */
Status ApoDelete(LLNode *L,ElemType data)
{
    Status      rv;
    LLNode      *cur; /* 表示当前节点 */
    LLNode      *pre; /* 表示前一个节点 */
    int         i = 0;

    if(!L)
    {
        printf("%s Invalid input argument\n",__func__);
        return  ERROR;   
    } 

    rv = JudgeNull(L);
    if(rv == TRUE || rv == ERROR) /* 栈空或者出错 */
        return ERROR;
    
    pre = L;
    cur = pre->next;
    while(cur) /* 遍历到最后一个节点 */
    {
        if(data == cur->data)
        {
            pre->next = cur->next;
            free(cur);
            i++;
            cur = pre->next; /* 让cur指向删除节点的下一个节点，继续判断是否还有满足条件的节点 */
            continue;
        }

        pre = cur;
        cur = pre->next;
    }   

    L->data -= i;

    return SUCCESS;
}

/* 清除链表 */
Status ClearList(LLNode *L)
{
    Status      rv;
    LLNode      *cur; /* 表示当前节点 */
    LLNode      *temp; /* 表示当前节点 */

    if(!L)
    {
        printf("%s Invalid input argument\n",__func__);
        return  ERROR;   
    } 

    rv = JudgeNull(L);
    if(rv == TRUE || rv == ERROR) /* 栈空或者出错 */
        return ERROR;  

    cur = L->next;
    while(cur)
    {
        temp = cur;
        cur = cur->next;
        free(temp);
    }

    L->data = 0; 
    L->next = NULL;

    return SUCCESS;
}


int main(int argc, char **argv)
{
    LLNode          L;
    Status          rv = 0;
    int             i;
    ElemType        insert_data = 0;
    ElemType        del_data = 0;

    rv = initlist(&L);
    if(rv != SUCCESS)
    {
        printf("Init list failure\n");
        return -1;
    }
    printf("after Init list length is: %d\n",L.data);

    for(i=1; i<=10; i++)
    {
        insert_data = i;
        if(HeadInsert(&L,insert_data) != SUCCESS)
        {
            printf("HeadInsert  error\n");
            return -2;            
        }
    }

    printf("插入数据后的链表为：\n");
    if(PrintfList(&L) != SUCCESS)
    {
        printf("Printf List faliure\n");
        return -3;
    }
    printf("after HeadInsert list length is: %d\n",L.data);

    for(i=1; i<=10; i++)
    {
        insert_data = i;
        if(TailInsert(&L,insert_data) != SUCCESS)
        {
            printf("TailInsert  failure\n");
            return -2;            
        }
    }

    printf("插入数据后的链表为：\n");
    if(PrintfList(&L) != SUCCESS)
    {
        printf("Printf List faliure\n");
        return -3;
    }
    printf("after TailInsert list length is: %d\n",L.data);

    if(HeadDelete(&L) != SUCCESS)
    {
        printf("HeadDelete List faliure\n");
        return -4;
    }

    printf("从链表头部删除数据后的链表为：\n");
    if(PrintfList(&L) != SUCCESS)
    {
        printf("Printf List faliure\n");
        return -3;
    }
    printf("after HeadDelete list length is: %d\n",L.data);

    if(TailDelete(&L) != SUCCESS)
    {
        printf("TailDelete List faliure\n");
        return -5;
    } 

    printf("从链表尾部删除数据后的链表为：\n");
    if(PrintfList(&L) != SUCCESS)
    {
        printf("Printf List faliure\n");
        return -6;
    }
    printf("after TailDelete list length is: %d\n",L.data);

    del_data = 1;
    if(ApoDelete(&L,del_data) != SUCCESS)
    {
        printf("OneDelete List faliure\n");
        return 6;
    }

    printf("从链删除某一个数据后的链表为：\n");
    if(PrintfList(&L) != SUCCESS)
    {
        printf("Printf List faliure\n");
        return -6;
    }
    printf("after OneDelete list length is: %d\n",L.data);  

    del_data = 2;
    if(ApoDelete(&L,del_data) != SUCCESS)
    {
        printf("OneDelete List faliure\n");
        return -6;
    }

    printf("从链删除某一个数据后的链表为：\n");
    if(PrintfList(&L) != SUCCESS)
    {
        printf("Printf List faliure\n");
        return -7;
    }
    printf("after OneDelete list length is: %d\n",L.data); 

    if(ClearList(&L) != SUCCESS)
    {
        printf("ClearList List faliure\n");
        return -8;
    } 

    printf("清除链表后的链表为：\n");
    if(PrintfList(&L) != SUCCESS)
    {
        printf("Printf List faliure\n");
        return -7;
    }
    printf("after ClearList list length is: %d\n",L.data); 

    return 0;
}

    ```
6号小兔
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
线性表---单链表
qq_43216283的博客
06-15 145
/数据域 struct LinkList * next;//指针域 } LTNode;
【数据结构与算法学习】线性表（顺序表、单链表、双向链表、循环链表）
Gefangenes的博客
06-09 1087
12345。
数据结构--线性表（顺序表、单链表、双链表、循环链表、静态链表）
最新发布
weixin_46858088的博客
07-03 1193
线性表是具有相同数据类型的n (n>=0）个数据元素的有限序列，其中n为表长，当n = 0时线性表是一个空表。若用 L 命名线性表，则其一般表示为注1.Ai 是线性表中的 “第 i 个” 元素线性表中的位序(位序从1开始,数组下标从0开始2.A1是表头元素;an是表尾元素。3.除第一个元素外，每个元素有且仅有一个直接前驱;除最后一个元素外，每个元素有且仅有一个直接后继顺序表――用顺序存储的方式实现线性表顺序存储。
线性表和单链表有什么区别
weixin_35755562的博客
02-14 722
线性表和单链表是两种常见的数据结构。 线性表是一种线性的数据结构，元素从头到尾依次存储，每个元素在内存中占据固定的位置。查询某个元素的时间复杂度是O(1)，但是当需要插入或删除某个元素时，因为需要移动其他元素的内存位置，因此时间复杂度是O(n)。 单链表也是一种线性的数据结构，元素通过指针将其相邻的元素连接在一起，元素的内存位置不必固定。查询某个元素的时间复杂度是O(n)，但是当需要插入或删除某个...
数据结构实验--线性表和单链表
m0_72747430的博客
02-26 968
数据结构
数据结构C语言版-线性表的单链表存储结构表示和实现优质资料.doc
12-02
数据结构C语言版-线性表的单链表存储结构表示和实现优质资料.doc
数据结构C语言版-线性表的单链表存储结构表示和实现.doc
07-13
数据结构C语言版-线性表的单链表存储结构表示和实现.doc
数据结构线性表的C语言代码
06-27
适合学习数据结构的同学
数据结构---线性表之单链表（C语言）
03-28
数据结构---线性表之单链表，包括单链表的创建、插入、删除等，C语言编写
c语言数据结构线性表实验（包括顺序表和链表）
11-28
c语言数据结构线性表实验（包括顺序表和链表）
数据结构 (三) 线性表_单向链表
Fioman_GYM的博客
04-21 685
文章目录一. 链表的定义① 基本概念② 单链表③ 概念解释④ 优缺点 一. 链表的定义 ① 基本概念 链表首先也是一个线性表 存储空间可以是非连续的 链表由一系列的节点组成,每个节点包含两个域,一个是数据域,一个是指针域 ② 单链表 线性表的链式存储中,每个节点只包含一个指针域,这样的链表叫单链表 通过每个节点的指针域将线性表的数据元素按其逻辑次序链接在一起 ③ 概念解释 表头节点 链表中的第一个节点,包含指向第一个数据元素的指针以及链表自身的一些信息,头结点是不保存数据信息的.
线性表和链表的区别
weixin_33810006的博客
02-14 238
线性表，和链表。 线性表在内存中是一块连续的存储空间；如：一个表中的内容是：【1，2，3】则它在内存中可能是如下存储的： 1 2 3 通过这个结构可以看出，只要知道了第一个元素在内存中所在的位置。就可以很容易的知道其他元素的位置。因为每一个元素占的空间是一样的。所以，如果我们知道第一个元素：1在内存号：1000；而每一个元素占8个内存空间；则第二个元素：2所在的内存空间为：1000 + ...
数据结构与算法——线性表（链表篇）
小田是个程序员的博客欢迎你的到来呀~
06-20 2万+
本篇文章，主要详细解读和总结线性表的链式存储结构——链表，包括单链表、双链表、静态链表以及循环链表，讲解较为全面，图文并茂，总结各链表的特性以及基本操作，干货满满，各位小伙伴们请细细品读，你会收获你想要的知识的！.........
线性表—单链表
qq_39172845的博客
03-16 1111
C++模板类实现单链表以及常用操作
线性表之顺序表与单链表的区别及优缺点
热门推荐
ljx_5489464的博客
03-23 3万+
这里比较的是基于C语言实现的顺序表与单链表，与其他语言的实现可能会有差异，但我相信语言是相通的，它们的实现机制应该也差不多。 1、What 什么是顺序表和单链表 ①顺序表： 顺序表是在计算机内存中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。只要确定了起始位置，表中任一元素的地址都通过下列公式得到：LOC（ai）=LOC（a1）+（i-1）*L 　1≤i≤
线性表的相关概念
fakerth的博客
06-02 642
线性表一、线性表的定义和基本操作1.线性表的定义注意：2.线性表的基本操作：二、线性表的顺序表示1.顺序表的定义：注意：2.顺序表上基本操作的实现①插入操作②删除操作③按值查找 一、线性表的定义和基本操作 1.线性表的定义 线性表是具有相同数据类型的n(n≥0)个数据元素的有限序列，其中n为表长，当n=0时，该线性表是一个空表。若用L命名线性表，则其一般表示为 L=(a1，a2，a3，.……，an) 式中，a1是唯一的“第一个”数据元素，又称表头元素；an是唯一的“最后一个”数据元素，又称表尾元素。得出线性
线性表：顺序表和链表的定义，接口实现，功能讲解，二者区别，分别适用于什么场景。
qq_39487033的博客
08-20 2681
线性表 顺序表的定义 顺序表，我把它简单的理解为一个结构体里，存了两个成员，一个数组data（为了保存数据），一个整型sz（记录数组中数据的个数）。因为顺序表有连续排列的顺序，所以用数组保存数据更方便。定义代码如下： typedef int DATA_TYPE; typedef struct PSeqList { DATA_TYPE data[MAX]; int sz...
数据结构：线性表中顺序表和单链表的比较
鄙人kunzhi96，感恩遇见！
03-16 3135
看到一道选择题是线性表中顺序表与单链表的区别对比，感觉对于这二者的区别了解不是很全面，决定来一波总结。至于什么是线性表，可以参考该博客。 线性表中顺序表和单链表的比较 一、什么是顺序表和单链表 顺序表： 顺序表是在计算机内存中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。 单链表： 单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。...
C语言数据结构如何从线性表得到单链表
03-31
线性表是一种数据结构，它包含一组有序的元素，每个元素都有一个唯一的编号。线性表可以使用数组或链表来实现。而单链表是一种链式存储结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。 如果要...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值