第2章_线性表

最新推荐文章于 2022-05-21 12:37:52 发布
最新推荐文章于 2022-05-21 12:37:52 发布
阅读量1.5k 收藏 9
点赞数 4
分类专栏： C语言版数据结构 文章标签： 线性表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/wwww_com/article/details/77230778
版权

线性结构的特点是除第一个和最后一个数据元素外每个数据元素只有一个前驱数据元素和一个后继数据元素。线性表是一种最简单的线性结构。线性表的操作特点主要是可以在任意 位置插入和删除一个数据元素。线性表可以用顺序存储结构和链式存储结构存储。用顺序存储结构实现的线性表称作顺序表，用链式存储结构实现的线性表称作链表。链表主要有单链表、循环单链表和双向循环链表三种。顺序表和单链表各有优缺点，并且优缺点刚好相反。

线性表的顺序表示和实现

线性表的抽象数据类型瑶池示了线性表的数据元素、数据元素间的逻辑关系以及线性表的操作集合。任何需要计算机进行管理和处理的数据元素都必须首先按某种方式存储在计算机中。线性表的抽象数据类型有两种存储结构：一种是顺序存储结构；另一种是链式存储结构。一旦确定了线性表的存储结构，线性表操作集合中的所有操作就可以具体实现。

typedef struct {
    DataType list[MaxSize];
    int size;
}SeqList;

//顺序表操作实现
//1.初始化
void ListInitiate(SeqList*L)
{
    L->size = 0;//定义初始数据元素个数
}

//2.求当前数据元素个数
int ListLength(SeqList L)
{
    return L.size;//返回顺序表L的当前数据元素个数
}

//3.插入数据元素
int ListInsert(SeqList*L,int i,DataType x)
{
    /*
    在顺序表L的第i(0<=i<=size)个位置前插入数据元素值x
    插入成功返回1，插入失败返回0
    */
    int j;
    if(L->size >= MaxSize)
    {
        printf("顺序表已满无法插入！\n");
        return 0;
    }
    else if(i < 0 || i > L->size)
    {
        printf("参数i不合法！\n");
        return 0;
    }
    else
    {
        /*为插入做准备*/
        for(j=L->size;j > i; j--)
        {
            L->list[j] = L->list[j-1];
        }
        L->list[i] = x; /*插入元素x*/
        L->size++;      /*元素个数加1*/
        return 1;
    }
}

//4.删除数据元素
int ListDelete(SeqList*L,int i,DataType*x)
{
    /*
    删除顺序表L中位置为i(0<=i<=size-1)的数据元素并存放到x中
    删除成功返回1，删除失败返回0
  */
    int j;
    if(L->size <= 0)
    {
        printf("顺序表已空无数据元素可删！\n");
        return 0;
    }
    else if(i < 0 || i > L->size - 1)
    {
        printf("参数i不合法\n");
        return 0;
    }
    else
    {
        *x = L->list[i];    /* 保存删除的元素到x中*/
        for(j = i;j < L->size-1; j++)
        {
            L->list[j] = L->list[j+1];
        }
        L->size--;          /*数据元素个数减1*/
        return 1;
    }
}

//5.取数据元素
int ListGet(SeqList L,int i,DataType* x)
{
    /* 取顺序表L中第i个数据元素存于x中，成功返回1，失败返回0*/
    if(i < 0 || i > L.size - 1)
    {
        printf("参数i不合法！\n");
        return 0;
    }
    else
    {
        *x=L.list[i];
        return 1;
    }
}
/* 
例：编程实现如下任务：建立一个线性表，首先依次输入数据元素1，2，3，...,10，然后删除数据元素5，最后依次显示当前线性表中的数据元素。假设该线性表的数据元素个数在最坏情况下不会超过100个。
设计：用顺序表实现建立线性表的任务。因该线性表数据元素最坏情况下不会超过100个，所以定义顺序表的MaxSize为100；因该设计任务中数据元素的数据类型是int类型，所以定义顺序表的DataType为int;该任务要求的插入、删除、取元素等操作可通过调用顺序表的插入、删除、取元素等函数来实现。
*/

#include<stdio.h>           /* 该文件包含printf函数*/
#define MaxSize 100         /* 定义MaxSize为100*/
typedef int DataType;       /* 定义DataType为int*/
#include "SeqList.h"        /* 包含顺序表文件*/


int main(int argc, char* argv[])
{
    SeqList myList;
    int i,x;
    ListInitiate(&myList);  /* 初始化函数调用*/
    for(i = 0;i < 10; i++)  /* 插入10个数据元素*/
    {
        if(ListInsert(&myList,i,i+1) == 0)  /*插入函数调用*/
        {
            printf("错误！\n");
            return ;
        }
    }

    /* 显示顺序表当前的数据元素*/
    for(i = 0;i < ListLength(myList); i++)
    {
        if(ListGet(myList,i,&x) == 0)   /* 取元素函数调用*/
        {
            printf("错误！\n");
            return ;
        }
        else
        {
            printf("%d ",x);
        }
    }
    printf("\n");

    if(ListDelete(&myList,4,&x) == 0)   /* 删除函数调用*/
    {
        printf("错误！\n");
        return ;
    }

    /* 显示顺序表当前的数据元素*/
    for(i = 0;i < ListLength(myList); i++)
    {
        if(ListGet(myList,i,&x) == 0)   /* 取元素函数调用*/
        {
            printf("错误！\n");
            return ;
        }
        else
        {
            printf("%d ",x);
        }
    }
    printf("\n");
    return 0;
}
/*
1 2 3 4 5 6 7 8 9 10
1 2 3 4 6 7 8 9 10
Press any key to continue
*/

这里写图片描述

/*
2.编程实现如下任务：建立一个如下所示的学生情况表，要求先依次输入数据元素然后依次显示当前表中的数据元素。假设该表元素个数在最坏情况下不会超过100个。要求使用顺序表。
  学号        姓名      性别      年龄
 2000001    张三      男       20
 2000002    李四      男       21
 2000003    王五      女       22
 设计：
 因该表数据元素个数在最坏情况下不会超过100个，所以我们定义顺序表的MaxSize为100；该设计任务的表元素为学生，从表2-1可知，每个学生数据元素包括学号、姓名、性别和年龄四个数据项。
*/
#include<stdio.h>           /* 该文件包含printf函数*/
#define MaxSize 100         /* 定义MaxSize为100*/
typedef struct Student{     /* 定义Student类型*/
    long number;            /* 学号数据项*/
    char name[10];          /* 姓名数据项*/
    char sex[3];            /* 性别数据项*/
    int age;                /* 年龄数据项*/
}StudentType;               /* 结构体StudentType*/

typedef StudentType DataType; /* 定义DataType为StudentType数据类型*/
#include "SeqList.h"        /* 包含顺序表文件*/

int main(int argc, char* argv[])
{
    SeqList myList;
    int i;
    StudentType x[3] = {
        {
            2000001,"张三","男",20
        },
        {
            2000002,"李四","男",21
        },
        {
            2000003,"王五","女",22
        }
    };
    StudentType s;

    ListInitiate(&myList);      /* 初始化函数调用*/
    for(i = 0;i < 3; i++)
    {
        if(ListInsert(&myList,i,x[i]) == 0) /*插入函数调用*/
        {
            printf("错误！\n");
            return ;
        }
    }

    /* 显示顺序表当前的数据元素*/
    for(i = 0;i < ListLength(myList); i++)
    {
        if(ListGet(myList,i,&s) == 0)   /* 取元素函数调用*/
        {
            printf("错误！\n");
            return ;
        }
        else
        {
            printf("%d\t%s\t%s\t%d\n",s.number,s.name,s.sex,s.age);
        }
    }
    printf("\n");
    return 0;
}
/*
2000001 张三    男      20
2000002 李四    男      21
2000003 王五    女      22

Press any key to continue
*/

这里写图片描述

线性表的链式表示和实现

单向链表
链式存储结构存储线性表数据元素的方法，是把存放数据元素的结点用指针域构造成链。指针是指向物理存储单元地址的变量，由数据元素域和一个或若干个指针域组成的一个结构体称为一个结点。其中，数据域用来存放数据元素，指针域用来构造数据元素之间的关联关系。链式存储结构的特点是数据元素间的逻辑关系表现在结点的链接关系上。链式存储结构的线性表称为链表。根据指针域的不同和结点构造链的方法不同，链表主要有单链表、单循环链表和双向循环链表三种。

/************************************************************************/
/* 单链表应用举例：
建立一个表，首先依次输入数据元素1，2，3，...，10，然后删除 数据元素5，
最后依次显示当前表中的数据元素。要求使用链表
设计：
因要求数据元素是int类型，所以定义单链表的DataType为int.对表元素的插入，删除，
取元素等操作均可通过调用单链表的插入，删除，取元素等操作来实现。                                                                     
*/
/************************************************************************/
#include <stdio.h>      //包含printf()函数
#include <stdlib.h>     //包含exit()函数
#include <malloc.h>     //包含malloc()等函数

typedef int DataType;   //定义DataType为int
#include "LinList.h"    //包含单链表文件

int main(int argc, char* argv[])
{
    SLNode *head;   //定义头指针变量
    int i,x;

    ListInitiate(&head);    //初始化

    for(i = 0;i < 10; i++)      //插入10个数据元素
    {
        if(ListInsert(head,i,i+1) == 0)
        {
            printf("错误！\n");
            return ;
        }
    }

    for(i = 0;i < ListLength(head); i++)    //显示当前的数据元素中的值
    {
        if(ListGet(head,i,&x) == 0) //取元素值到x变量中
        {
            printf("错误！\n");
            return ;
        }
        else
        {
            printf("%d ",x);    //显示
        }
    }
    printf("\n");

    if(ListDelete(head,4,&x) == 0)  //删除下标为四(值为5)的数据元素
    {
        printf("错误！\n");
        return ;
    }

    for(i = 0;i < ListLength(head); i++)    //显示当前的数据元素中的值
    {
        if(ListGet(head,i,&x) == 0) //取元素值到x变量中
        {
            printf("错误！\n");
            return ;
        }
        else
        {
            printf("%d ",x);    //显示
        }
    }
    printf("\n");

    Destroy(&head);     //撤消单链表
    return 0;
}
/*
1 2 3 4 5 6 7 8 9 10
1 2 3 4 6 7 8 9 10
Press any key to continue
*/

这里写图片描述

双向链表
双向链表是每个结点除后继指针域外还有一个前驱指针域。与单链表类同，双向链表也有带头结点结构和不带头结点结构2种，带头结点的双向链表更为常用。
在双向链表中，每个结点包括三个域，分别是data域，next域和prior域，其中data域为数据域，next域为指向后继结点的指针，prior域为指向前驱结点的指针。

//双向链表的实现

typedef struct Node
{
    DataType data;
    struct Node *next;
    struct Node *prior;
}DLNode;

//1.初始化
void ListInitiate(DLNode** head)
{
    if((*head=(DLNode*)malloc(sizeof(DLNode))) == NULL) exit(0);
    (*head)->prior = *head; //构成前驱指针循环链
    (*head)->next = *head;  //构成后继指针循环链
}

//2.插入数据元素
int ListInsert(DLNode*head,int i,DataType x)
{
    //在带头结点的双向循环链表head的第i(0<=i<=size)个结点前
    //插入一个存放数据元素x的结点。插入成功时返回1，失败返回0
    DLNode*p,*s;
    int j;

    p = head->next;
    j = 0;
    while(p != head && j < i)
    {
        p = p->next;
        j++;
    }

    if(j != i)
    {
        printf("插入位置参数出错！");
        return 0;
    }

    if((s = (DLNode*)malloc(sizeof(DLNode))) == NULL) exit(0);
    s->data = x;

    s->prior = p->prior;    //修改新增结点 prior域指向
    p->prior->next = s;     //修改新增结点前一个结点的next域指向
    s->next = p;            //修改新增结点的next域
    p->prior = s;           //修改新增结点的下一个结点的prior域指向
    return 1;
}

//3.删除数据元素
int ListDelete(DLNode*head,int i,DataType*x)
{
    //删除带头结点双向循环链表head的第i(0<=i<=size-1)个结点
    //被删除结点的数据元素域值由x带回。删除成功时返回1，失败返回0
    DLNode*p;
    int j;
    p = head->next;
    j = 0;
    while(p->next != head && j < i) //寻找第i个结点
    {
        p = p->next;
        j++;
    }
    if(j != i)
    {
        printf("删除位置参数出错！");
        return 0;
    }

    p->prior->next = p->next;
    p->next->prior = p->prior;
    *x = p->data;
    free(p);

    return 1;
}

//4.求循环链表长度
int ListLength(SLNode*head)
{
    SLNode*p = head;
    int size = 0;
    while(p->next != head)
    {
        p = p->next;
        size++;
    }
    return size;
}

//5.撤消内存空间
void Destroy(DLNode**head)
{
    DLNode *p,*p1;
    int i,n = ListLength(*head);    //为求长度函数

    p = *head;
    for(i = 0;i <= n; i++)
    {
        p1 = p;
        p = p->next;
        free(p1);
    }
    *head = NULL;
}

静态链表

在链式存储结构中，实现数据元素之间的次序关系依靠指针。我们也可以用数组来构造链表，方法是：在数组中增加一个（或两个）指针域，这些指针域用来存放下一个（或上一个）数据元素在数组中的下标，从而构成用数组构造的单链表（或双向链表）。由于相对于申请结点内存空间的动态性来说数组内存空间的申请方式是静态的，所以这种存储结构称作静态链表。由于静态链表中增加的指针仿真了链式存储结构中的指针，所以静态链表中的指针也称作仿真指针。

算法举例

顺序表算法举例

/************************************************************************/
/*1.构造一个顺序表的删除算法，把顺序表L中数据元素x删除。
算法思想：此删除问题可通过一个循环比较过程来实现      
*/
/************************************************************************/
#include"SeqList.h"

int ListDataDelete(SeqList*L,DataType x)
{
    int i,j;
    for(i = 0;i < L->size; i++) //寻找元素x
        if(x == L->list[i]) break;
    if(i == L->size) return 0;  //未寻找到元素x
    else                        //寻找到元素x
    {
        for(j = i;j < L->size; j++)     //元素依次前移
            L->list[j] = L->list[j+1];
        L->size--;                      //元素个数减1
        return 1;
    }
}

/* 
2.构造一个顺序表的删除算法，把顺序表L中所有值相同的数据元素x全部删除
算法思想：删除算法的基础上，再增加一重循环来实现值相同数据元素x的全部删除。
*/
int ListMoreDataDelete(SeqList*L,DataType x)
{
    int i,j;
    int tag = 0;    //初始删除标记置为0

    for(i = 0;i < L->size; i++)
    {
        if(x == L->list[i])     //寻找到元素x
        {
            for(j = i;j < L->size; j++) //依次前移
                L->list[j] = L->list[j+1];
            L->size--;          //元素个数减1
            i--;                //保证2个相邻 的元素均为x时正确删除
            tag = 1;            //设置删除成功标记
        }
    }

    return tag;
}

单链表算法举例

/************************************************************************/
/* 1.设头指针为head,并设带头结点单链表中的数据元素递增有序，编写算法将数据
元素x插入到带头结点单链表的适当位置上，要求插入后保持单链表数据元素的递增有序。
算法思想：
从链表的第1个数据元素结点开始，逐个比较每个结点的data域值和x的值，当data小于等于x时，
进行下一个结点的比较；否则，就找到了插入结点的合适位置，此时申请新结点把x存入，
然后把新结点插入；当比较到最后一个结点仍有data小于等于x时，则把新结点插入单链表尾。
*/
/************************************************************************/
void LinListInsert(SLNode*head,DataType x)
{
    SLNode*curr,*pre,*q;
    //循环初始化
    curr = head->next;      //curr指向第一个数据元素结点
    pre = head;             //pre指向头结点
    //循环定位插入位置
    while(curr != NULL && curr->data <= x)
    {
        pre = curr;
        curr = curr->next;
    }
    //申请一个结点并把x存入data域
    if((q = (SLNode*)malloc(sizeof(SLNode))) == NULL) exit(1);
    q->data = x;

    //把新结点插入pre所指结点后
    q->next = pre->next;
    pre->next = q;
}

/*
2.设head为单链表的头指针，并设单链表带有头结点，编写
算法将单链表中的数据元素按照其值递增有序的顺序进行就地排序
*/
void LinListSort(SLNode *head)
{
    SLNode*curr,*pre,*p,*q;
    p = head->next;
    head->next = NULL;

    while(p != NULL)
    {
        curr = head->next;
        pre = head;
        while(curr != NULL && curr->data <= p->data)
        {
            pre = curr;
            curr = curr->next;
        }
        q = p;
        p = p->next;
        q->next = pre->next;
        pre->next = q;
    }
}
C语言数据结构——线性表
我想让你也是一个开心果！
10-09 958
今天又是活力满满的一天！加油呀！ 今天开始学习线性表啦！ 一、何为线性表？ 线性表就像我们买票排队一样，具有线一样性质的结构。 线性表的官方定义：由零个或多个数据元素组成的有限序列。 二、线性表的特点： ——元素之间有先来后到，具有一定的顺序。 ——若元素存在多个，（会牵扯到前驱后继的概念），则第一个元素无前驱，最后一个元素无后继，且其他元素都有且只有一个前驱和后继。 ——线性表强调的是有限的，无论计算机发展到多强大，它所处理的元素都是有限的。 例子如下： 所以线性表元素的个数n(n>=0)定义为线
c语言 学生信息管理系统
07-11
完成学生信息管理系统-顺序表的建立、查找、插入、删除、输出、退出等函数的功能，
C语言创建线性表
Aruko的博客
09-20 7280
动态分配而非数组的线性表 在VS2019中创建的，结构体里定义了默认的构造函数（不清楚这算不算C++的语法），线性表的长度是动态分配的。 Incream_List 线性表扩容函数 ListInsert 插入数据函数 ListInit 初始化时输入一批数据 ListDelete 删除某个位置的数据 ListSearch 查找某数据在什么位置 ListOutput 输出全部数据 这是头文件...
数据结构-线性表之顺序表
viafcccy的博客
12-15 369
定义 线性表（list/squencelist）是零个或多个数据元素的有限序列。 线性表的特点 1.数据元素是有序的 2.数据元素是一对一的   线性表的数据集合为{a1，a2，......，an}，每个元素类型均为datatype。其中除了第一个元素a1外，每个元素有且只有一个前驱元素，除an外，每个元素只有一个直接后继元素；数据元素之间是一对一的关系。   线性表的操作 初始...
【理解】顺序线性表（数组实现）
博客皆笔记
09-15 409
目录La，Lb按值非递减，归并为Lc编程实现:顺序线性表的操作 数据结构作业的两个应用题 La，Lb按值非递减，归并为Lc 应用1 代码片. //数据结构算法练习 //将类C转化成C //算法2.2 /*#include<iostream> using namespace std; int main() { int a[3]={1,3,3}; int b[2]={2,4};...
第2章_线性表.zip
12-05
在提供的"第2章_线性表.ppt"文件中，可能会详细讲解线性表的定义、基本操作的实现、不同存储方式的比较，以及实际应用案例。通过学习这一章，你将能够深入理解线性表的原理，并能灵活运用到实际编程问题中。
数据结构_第2章_线性表.pdf
04-01
例如，如果第一个元素地址是100，每个元素长度为2，那么第5个元素的地址是100 + (5 - 1) * 2 = 108。但是，顺序表在插入和删除操作时，如果插入点不是在末尾，可能需要大量移动元素。 2. 链式存储结构：链表的元素...
数据结构_第2章_线性表.docx
04-01
若在一个长度为n的顺序表中插入一个元素，尤其是在表的中间位置，平均需要移动n/2个元素，这样的操作效率是低下的。此外，顺序存储要求内存空间必须是连续的，这在内存碎片化严重的系统中可能会导致问题。当顺序表...
第2章_线性表.ppt
12-05
线性表是数据结构中的一个基础概念，它是由n（n>=0）个相同类型元素构成的有限序列，其中每个元素都有一个唯一的位置，除了最后一个元素外，每个元素都有一个直接后继，除了第一个元素外，每个元素都有一个直接前驱...
第2章_线性表1.pdf
09-30
2. 线性表的基本操作： - 初始化（InitList(&L)）：创建一个空的线性表。 - 销毁（DestroyList(&L)）：删除整个线性表，释放内存资源。 - 清空（ClearList(&L)）：将非空线性表中的所有元素删除，使之成为空表。 ...
5.完成课本P35例2-2： 建立一个如下表所示的学生情况表，要求先依次输入数据元素，然后依次显示当前表中的数据元素。假设该表元素个数在最坏的情况下不会超过 100 个。要求使用顺序表。 学号 姓名
AKK188888881的博客
10-26 740
5.完成课本P35例2-2： 建立一个如下表所示的学生情况表，要求先依次输入数据元素，然后依次显示当前表中的数据元素。假设该表元素个数在最坏的情况下不会超过 100 个。要求使用顺序表。 学号 姓名 性别 年龄 20000001 张三 男 20 20000002 李四 男 21 20000003 王五 女 22 头文件：SeqList.h #include<stdio.h> #define MaxSize 100 typedef struct Student { long number;
P32 例2-3 编程实现和例2-1相同的任务，即建立一个线性表，首先依次输入数据元素1，2，3，...，10，然后删除数据元素5，最后依次显示当前表中的数据元素。要求使用单链表。
AKK188888881的博客
10-08 2601
P32 例2-3 编程实现和例2-1相同的任务，即建立一个线性表，首先依次输入数据元素1，2，3，…，10，然后删除数据元素5，最后依次显示当前表中的数据元素。要求使用单链表。 头文件：LinList.h #include<stdio.h> #include<stdlib.h> typedef int DataType; typedef struct Node { DataType data; struct Node *next; }SLNode; void ListIni
顺序表：现有一学生情况一览表，要求依次输入学生信息并依次显示，假设元素个数不超过100。...
weixin_34255793的博客
03-22 321
package seq; interface List { public void insert(int i,Object obj)throws Exception; public Object getData(int i)throws Exception; public int size(); } class SeqList implements L...
9,给定一个带表头结点的单链表,设head为头指针,结点结构为(data, next), data 为整型元素, next为指针,试写出算法:按递增次序输出单链表中各结点的数据元素, 并释放结点所占的
Anthony_4926
06-27 6396
9,给定一个带表头结点的单链表,设head为头指针,结点结构为(data, next), data为整型元素, next为指针,试写出算法:按递增次序输出单链表中各结点的数据元素,并释放结点所占的存储空间(要求:不允许使用数组作为辅助空间)。 思路：插入法从小到大排序，然后输出 排序见“6,有一个带头结点的单链表1,设计一个算法使其元素递增有序。” ...
数据结构实验一(2) 链表的基本操作
Code_流苏：在代码中寻诗意
05-21 2338
数据结构实验一(2) 链表的基本操作
数据结构实验课：实验一、顺序表的实现及应用
热门推荐
listboy的博客
05-19 1万+
一、实验目的 了解和掌握线性表的顺序存储结构；掌握用C语言上机调试线性表的基本方法；掌握线性表的基本操作：插入、删除、查找以及线性表合并等运算在顺序存储结构和链接存储结构上的运算，以及对相应算法的性能分析。 二、实验要求 给定一段程序代码，程序代码所完成的功能为：（1）建立一个线性表；（2）依次输入数据元素1,2,3,4,5,6,7,8,9,10；（3）删除数据元素5；（4）依次显示当前线性表中的数据元素。假设该线性表的数据元素个数在最坏情况下不会超过100个，要求使用顺序表。 程序中有3处错误的地方，有标
数据结构与算法实验-实验一：线性表基本操作
soul_mingling的博客
04-01 2677
线性表基本操作 文章目录线性表基本操作题目1题目2题目3 题目1 线性表是最常见和常用的ADT。假设线性表的元素为整数，请基于顺序存储结构实现线性表ADT。 基本功能包括： （1）建立线性表； 输入有两行，第一行是一个整数n，线性表的长度； 第二行是n和数据元素 （2）插入： 输入两个整数，即元素插入的位置和元素值 （3）删除： 输入一个整数，即要删除的元素 （4）搜索： 输入一个整数，即搜索元素...
小白算法积累——单链表9#带表头结点单链表+按值的递增顺序操作
aprilzj123的博客
02-18 1164
题目：给定一个带表头结点的单链表，设head为头指针，结点结构为（data，next），data为整型数据，next为指针，试写出算法：按递增次序输出单链表中各结点的数据元素，并释放结点所占的存储空间。（要求：不允许使用数组作为辅助空间）。 关键字：带头结点的单链表+按序输出 思路 关注：递归算法的设计重点在于找到“递归”的部分，即重复调用函数，改变部分相关变量 设f(L,x)的功能是：删除以L为...
数据结构第二章-线性表详解
"本章小结-数据结构第二章，主要涵盖了线性表的基本概念、顺序存储和链式存储的特点，以及单链表、双向链表和循环链表的介绍。" 在数据结构中，线性表是一个重要的基础概念，它是由n个数据元素构成的有限序列，每个...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值