数据结构第二章 线性表

已于 2024-09-16 12:16:28 修改
阅读量723 收藏 28
点赞数 26
文章标签： 数据结构 算法
于 2024-09-16 00:27:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_48218436/article/details/142291304
版权

第二章 线性表

2.1 线性表的定义和基本操作

2.1.1 线性表的定义

  1. 线性表是具有相同数据类型的n（n>=0)个数据元素的有限序列，n为表长，当n=0时，是一个空表
  2. L=(a1,a2,…ai,ai+1,…,an)，其中a1是唯一的第一个数据元素，又称表头元素，an是唯一的最后一个数据元素，又称表尾元素
  3. 除表头元素外，每个元素有且仅有一个直接前驱，除表尾元素外，每个元素有且仅有一个直接后继
  4. 线性表的特点如下：
    • 表中元素个数有限
    • 表中元素具有逻辑上的顺序性，表中元素有其先后次序
    • 表中元素都是数据元素，每个元素都是单个元素
    • 表中元素的数据类型相同，这意味着某每个元素占据相同大小的存储空间
    • 表中元素具有抽象性，仅讨论元素间的逻辑关系
  5. 线性表是一种逻辑结构，表示元素之间一对一的相邻关系，顺序表和链表是指存储结构

2.1.2 线性表的基本操作

  • InitList(&L) 初始化表，构造一个空的线性表

  • Length(L) 求表长，返回线性表L的长度，即L中数据元素的长度

  • LocateElem(L,e) 按值查找操作，在表L中查找具有给定关键字值的元素

  • GetElem(L,i) 按位查找操作，获取表L中第i个位置的元素的值

  • ListInsert(&L,i,e) 插入操作，在表L中的第i个位置上插入指定元素e

  • ListDelete(&L,i,&e) 删除操作，删除表L中第i个位置上的元素，并用e返回删除元素的值

  • PrintList(L) 输出操作，按前后顺序输出表L的所有元素的值

  • Empty(L) 判空操作，若L为空表，返回true，若表L不为空，返回false

  • DestroyList(&L) 销毁操作，销毁线性表，并释放线性表L所占的内存空间

2.2 线性表的顺序表示

2.2.1 顺序表的定义

  1. 线性表的顺序存储又称顺序表，它是用一组地址连续的存储单元依次存储线性表中的数据元素，从而使逻辑上相邻的两个元素在物理位置上也相邻

  2. 顺序表的特点是表中元素的逻辑顺序与其存储的物理顺序相同

  3. 顺序表的任意一个元素可以随机存取，所以线性表的顺序存储结构是一种随机存取的存储结构，通常用数组来描述线性表的顺序存储结构

    线性表中的元素位序从1开始，而数组元素的下标从0开始

2.2.1.1 一维数组的静态分配

对数组进行静态分配时，因为数组的大小和空间已经事先固定，所以一旦空间占满，再加入新的数据就会产生溢出，进而导致程序崩溃

#define MaxSize 50 //定义线性表的最大长度
typedef struct{
    ElemType data[MaxSize];//顺序表的元素
    int length;//顺序表当前长度
}SqList;//顺序表定义类型
2.2.1.2 一维数组的动态分配

动态分配中，存储数组的空间是在程序执行过程中通过动态存储分配语句分配的，一旦数据空间占满，就开辟一块更大的存储空间，将原表中的元素全部拷贝到新空间，从而达到扩充数组存储空间的目的

#define Initsize 100 //表长的初始定义为100
typedef struct{
    ElemType *data;//指示动态分配数组的指针
    int MaxSize,length;//数组的最大容量的当前个数
}SqList;//动态分配数组顺序表的定义类型

C语言的初始动态分配语句

L.data=(ElemType*)malloc(sizeof(ElemType) *InitSize);
2.2.1.3 顺序表的主要优点
  1. 可以进行随机访问，即可通过首地址和元素序号在O（1）时间内找到指定元素
  2. 存储密度高，每个结点只存储数据元素
2.2.1.4 顺序表的主要缺点
  1. 元素的插入和删除需要移动大量的元素，插入操作平均需要移动n/2个元素，删除操作平均需要移动（n-1)/2个元素
  2. 顺序存储分配需要一段连续的存储空间，不够灵活

2.2.2 顺序表的基本操作

2.2.2.1 顺序表的初始化

  1. 静态分配在声明一个顺序表时，就已经为其分配了数组空间，因此初始化时，只需将顺序表当前的长度设为0

    #define MaxSize 50 //定义线性表的最大长度
typedef struct{
    ElemType data[MaxSize];//顺序表的元素c
    int length;//顺序表当前长度
}SqList L;//顺序表定义类型,声明一个顺序表
void InitList(SqList L){
    L.length=0;//顺序表初始长度为0
}

  2. 动态分配的初始化为顺序表分配一个预定义大小的数组空间，并将当前长度设为0，MaxSize指示顺序表当前分配的存储空间大小，一旦因为插入元素空间不足，就进行再分配

    void InitSize(SeqList &L){
    L.data=(ElemType *)malloc(InitSize*sizeof(ElemType));//分配存储空间
    L.length=0;//顺序表初始化长度为0
    L.MaxSize=InitSize;//初始存储容量
}
2.2.2.2 插入操作

  1. 在顺序表L的第i个（1<=i<=L.length+1)位置插入新元素e

    • i的位置不合法，则返回false，表示插入失败
    • i的位置合法，将第i个元素及其后的所有元素依次往后移动一个位置，腾出一个空位置插入新元素e，顺序表长度增加1，插入成功，返回true
    bool ListInsert (SqList &L,int i,ElemType e){
    if(i<1||i>L.length+1){//判断i的位置是否合法
        return false;//不合法，返回false
    }
    if(L.length>=MaxSize){//当前存储空间已满
        return false;//不合法，返回false
    }
    for(int j=L.length;j>=i;j--){//将第i个元素以及之后的元素往后移
        L.data[j]=L.data[j-1];
    }
    L.data[i-1]=e;//在位置i放上e
    L.length++;//线性表长度增加1
    return true;
}

  2. 最好情况：在表尾插入（i=n+1)，元素后移语句不执行，时间复杂度为O(1)

  3. 最坏情况：在表头插入(i=1) ,元素后移语句执行n次，时间复杂度为O(n)

  4. 平均时间复杂度为O(n)

2.2.2.4 删除操作

  1. 删除顺序表L中第i（1<=i<=L.length)个位置的元素，用引用变量e返回

    • 若i的输入不合法，返回false
    • i的输入合法，将被删元素赋给引用变量e，并将第i+1个元素及其后的所有元素依次往前移动一个位置
    bool ListDelete(SqList &L,int i,ElemType e){
    if(i<1||i>L.length+1){//判断i的位置是否合法
        return false;//不合法，返回false
    }
    e=L.data[i-1];//将被删除的元素赋给e
    for(int j=1;j<=L.length;j++){
        L.data[j-1]=L.data[j];
    }//将第i个位置后的元素往前移
    L.length--;//线性表长度减少1
    return true;
}

  2. 最好情况：删除表尾元素（i=n），无需移动元素，时间复杂度为O(1)

  3. 最坏情况：删除表头元素（i=1），需要移动除表头元素外所有的元素，时间复杂度为O(n)

  4. 平均时间复杂度为O(n)

2.2.2.5 按值查找（顺序查找）

  1. 在顺序表L中查找第一个元素值为e的元素，并返回其位序

    int LocateElem(SqList L,ElemType e){
    int i;
    for(i=0;i<L.length;i++){//查找值为e的元素
        if(L.data[i]==e){//下标为i的元素值为e，返回其位序i+1
            return i+1;
        }
    }
    return 0;//退出循环，查找失败
}

  2. 最好情况：查找元素在表头，仅需比较一次，时间复杂度为O(1)

  3. 最坏情况：查找元素在表尾，需要比较n次，时间复杂度为O(n)

  4. 平均时间复杂度为O(n)

2.2.2.6 按序号查找

直接根据数组下标访问数组元素，时间复杂度为O(1)

2.3 线性表的链式表示

2.3.1 单链表的定义

  1. 单链表结构：

    data为数据域，存放数据元素；next为指针域，存放其后继结点的地址

    | data | next |

  2. 单链表结点类型描述如下

    typedef struct LNode{//定义单链表结点类型
    ElemType data;//数据域
    struct LNode *next;//指针域
}LNode, *LinkList;//定义一个指针，指向LinkList

    强调一个单链表LinkList，强调一个结点LNode*

  3. 单链表的元素离散的分布在存储空间里，是非随机存储的存储结构，查找特定结点时，需要从表头开始遍历，依次查找

  4. 用头指针（head）标识一个单链表，指出链表的起始地址，头指针为NULL时表示一个空表，在单链表第一个数据结点前附加一个结点，称为头结点，头结点的数据域可以不设任何信息，也可以记录表长等信息，单链表带头结点时，头指针L指向头结点，单链表不带头结点时，头指针指向第一个数据结点，表尾结点的指针域为NULL，用^表示

  5. 头结点和头指针的关系：

    • 不管带不带头结点，头指针始终指向链表的第一个结点
    • 头结点是带头结点的链表的第一个结点，结点内通常不存储信息

  6. 头结点的优点：

    • 由于第一个数据结点的位置被放在头结点的指针域中，因此在链表的第一个位置上的操作和在表的其他位置上的操作一致，无须进行特殊处理
    • 无论链表是否为空，其头指针都是指向头结点的非空指针（空表中头结点的指针域为空），因此空表和非空表的处理得到统一

2.3.2 单链表的基本操作

2.3.2.1 单链表的初始化

  1. 带头结点的单链表初始化：需要创建一个头结点，并让头指针指向头结点，头结点的next域初始化为NULL

    bool InitList(LinkList &L){//带头结点的链表初始化
    L=(LNode*)malloc(sizeof(LNode));//创建头结点
    L->next=NULL;//头结点之后暂时没有元素，因此头结点的next域初始化时是null
    return true;
}

  2. 不带头结点的单链表初始化时，只需将头指针L初始化为NULL

    bool InitList(LinkList &L){
    L=NULL;
    return true;
}
2.3.2.2 单链表求表长

  1. 计算表长就是计算单链表中数据结点的个数，需要从第一个结点开始，依次访问表中每个结点，为此需要设计一个计数变量，每访问一个结点，其值+1，直到访问到空结点为止

  2. int Length(LinkList L){
    int len=0;
    LNode *p=L;
    while(p->next!=NULL){
        p=p->next;
        len++;
    }
    return len;
}

  3. 求表长操作的时间复杂度为O(n)

2.3.2.3 按序号查找结点（按位）

  1. 从单链表的第一个结点开始，沿着next域从前往后依次搜索，直到找到第i个结点为止，找到后返回该结点的值，若i的值大于单链表的表长，则返回NULL

  2. LNode *GetElem(LinkList L,int i){
    LNode *p=L;//指针p指向当前扫描到的结点
    int j=0;//记录当前结点的位序，头结点是第0个结点
    while(p!=NULL&&j<i){//循环找到第i个结点
        p=p->next;
        j++;
    }
    return p;
}

  3. 按序号查找的时间复杂度为O(n)

2.3.2.4 按值查找表结点

  1. 从单链表的第一个结点开始，从前往后依次比较表中各结点的数据域，若某结点的data域等于给定值e，则返回该结点的指针；若整个单链表中没有这样的结点，则返回NULL

  2. LNode *LocateElem(LinkList L,ElemType){
    LNode *p=L->next;
    while(p!=NULL&&p->data!=e){
        p=p->next;
    }
    return p;
}

  3. 按值查找的时间复杂度为O(n)

2.3.2.5 插入结点

  1. 插入结点操作是将值为X的新结点插入到单链表的第i个位置，先检查插入位置的合法性，然后找到待插入位置的前驱，即第i-1个结点，再在其后插入（后插法）

  2. 单链表插入操作过程：首先找到第i-1个结点，假设第i-1个结点为p，然后令新结点s的指针域指向p的后继，再令p的指针域指向新插入的结点s（为后插操作）

    bool ListInsert(LinkList &L,int i,ElemType e){//后插法
    LNode *p=L;//定义一个指针p，指向当前扫描到的结点L
    int j=0;//记录当前结点的位序，头结点是第0个结点
    while(p!=NULL&&j<i-1){//循环找到第i-1个结点
        p=p->next;
        j++;
    }
    if(p=NULL){//i值不合法
        return false;
    }
    LNode *s=(LNode*)malloc(sizeof(LNode));//创造结点s
    s->data=e;//新结点s的数据域为待插入的元素e
    s->next=p->next;
    p->next=s;
    return true;
}

  3. s->next=p->next;
    p->next=s;

    这两句代码顺序不能变

  4. 算法主要时间开销在查找第i-1个结点上，时间复杂度为O(n)

  5. 若在指定的结点后插入新结点，时间复杂度为O(1)

  6. 当链表不带头结点时，需要判断插入位置是不是为1，若是，则要做特殊处理——将头指针指向新的首结点；当链表带头结点时，若插入的位置为1，则不用做处理

  7. 对某一结点做前插操作

    • 前插操作是指在某结点的前面插入一个新结点

    • 设待插入结点为s，将s插入p的前面，方法为：仍然将s插入p的后面（用后插法），然后将p->data和s->data交换，这样做既满足了逻辑关系，又使得时间复杂度为O(1)

      bool ListInsert(LinkList &L,int i,ElemType e){
    LNode *p=L;//定义一个指针p，将p指向当前扫描到的结点L
    int j=0;//记录当前结点，头结点的位序为0
    while(p!=NULL&&j<i-1){
        p=p->1;
        j++;//循环找到第i-1个结点
    }
    if(p=NULL){
        return false;
    }
    LNode *s=(LNode)malloc(sizeof(LNode));//创建新结点s
    s->data=e;//新结点的数据域为插入的新元素e
    s->next=p->next;
    p->next=s;//后插法先将s插入
    temp=p->data;
    p->data=s->data;
    s->data=temp;//交换s和p的数据域部分，达到前插法
}
2.3.2.6 删除结点操作

  1. 将单链表中的第i个结点删除，先检查i的合法性，然后查找第i-1个结点，即被删结点的前驱，在删除第i个结点

  2. 操作过程：假设结点p为找到的被删结点的前驱， 为实现这一操作后的逻辑关系的变化，仅需修改p的指针域，将p->next指向q->next，然后释放q的存储空间

    bool ListDelete(LinkList &L,int i,ElemType e){
    LNode *p;//定义一个指针p，指向当前扫描到的结点
    int j=0;//记录当前结点，头结点的位序为0；
    while(p!=NULL&&j<i-1){//循环找到第i-1个结点
        p=p->next;
        j++;
    }
    if(p==NULL||p->next==NULL){
        return false;
    }
    LNode *q=p->next;// 将q指向被删除的结点
    e=q->data;//用e返回被删除的元素的值
    p->next=q->next;//将q结点从链中断开
    free(q);//释放q结点
    return true;
}

  3. 时间复杂度为O(n)，主要时间耗费在查找

  4. 当链表不带头结点时，需要判断被删结点是否为首结点，若是，则需将头指针L指向新的首结点；当链表带头结点时，删除任何结点操作都一样

  5. 删除指定结点p，可以通过将p的后继的值赋给p，任何删除后继，也能使得时间复杂度为O(1)

  6. 主要代码片段如下

    q=p->next;//令q指向p的后继
q->data=p->next->data;//将p的后继的值赋给q
p->next=q->next;//将q从链中断开
free(q);
2.2.3.7 采用头插法建立单链表

  1. 头插法可以实现元素逆置，即读入数据的顺序与生成的链表中的元素顺序是相反的

  2. 该方法从一个空表开始，生成新结点，并将读取到的数据存放到新结点的数据域中，然后将新结点插入到当前链表的表头，即头结点之后

    LinkList List_HeadInsert(LinkList &L){//逆向建立单链表
    LNode *s,int x;//设计元素为整型
    L=(LNode*)malloc(sizeof(LNode));//建立头结点
    L->next=NULL;//初始化链表
    scanf("%d",&x);//输入结点的值
    while(x!=9999){//输入9999结束
        s=(LNode)malloc(sizeof(LNode));//创建新的结点s
        s->data=x;//读取到的数据元素存储到s的数据域中
        s->next=L->next;//将L的后继赋给s，即将s插入到表中
        L->next=s;//L为头结点
        scanf("%d",&x);
    }
    return L;
}

  3. 每个结点插入的时间为O(1)，设单链表表长为n，则总时间复杂度为O(n)

2.3.2.8 采用尾插法建立单链表

  1. 输入数据的顺序与链表中元素的顺序一致

  2. 将新结点插入到当前链表的表尾，为此必须增加一个尾指针r，使其始终指向当前链表的尾结点

    LinkList List_TailInsert(LinkList &L){//正向建立单链表
    int x;//元素类型为整型
    L=（LNode)malloc(sizeof(LNode));//创建头结点
    LNode *s,*r=L;//定义指针s和r，r为尾指针
            scanf("%d",&x);
    while(x!=9999){//输入9999结束
       s=(LNode)malloc(sizeof(LNode));//创建新结点s
        s->data=x;//将输入的元素x赋值给新建立的结点s的数据域
        r->next=s;//将s结点插入到链表尾部
        r=s;//将r指向链表尾部
        scanf("%d",x);
    }
    r->next=NULL;//尾结点指针置空
  return L; 
}

  3. 因为附设了一个尾指针，所以时间复杂度为O(1)

2.3.3 双链表的定义

  1. 双链表结点中有两个指针，prior和next，分别指向直接前驱和直接后继

  2. 表头结点的prior域和表尾结点的next域都是NULL

  3. 双链表中结点类型的描述

    typedef struct DNode{
    ElemType data;
    struct DNode *prior,*next;
}DNode, *DLinklist;

  4. 双链表中增加了一个指向了其前驱的指针prior，因此双链表的按值查找和按位查找的操作和单链表相同

2.3.3.1 利用尾插法建立双链表
DLinkList List_TailInsert(DLinkList &L){
    int x;
    head=(DLNode*)malloc(sizeof(DLNode));//建立头结点
    DLNode *s,*r;//定义两个指针s和r
    head->prior=NULL;
    head->next=NULL;//初始化链表，链表此时为空，因此head（头结点）的前指针prior和后指针next都指向空
    DLNode *r=head;//指针r为表尾指针，链表为空时，头结点也是链表尾部
    scanf("%d",x);
    while(x!=9999){//输入9999结束
        s=(DLNode)malloc(sizeof(DLNode));//创建结点s
        s->data=x;//输入的x赋值在结点s的数据域
        r->next=s; //把现在r结点的next域指向s结点
        s->prior=r;//把s的后继指针指向r
        //通过上面操作，使得此时r结点在s结点之前
        r=s;//将s结点和r结点交换位置，r始终在表尾
        scanf("%d",x);
    }
    r->next=NULL//尾结点的next指针指向空
        return L;
}
2.3.3.2 在双链表中查找

  1. 按值查找：从第一个结点开始，依次扫描若发现某个结点的数据域中元素和给定值e相同，则返回结点指针，若找不到这样的结点，则返回NULL

    DNode* LocateElem(DLinklist D,int i){
    DNode *p=D->next;//D是头结点，指针p从头结点的next域起进行依次扫描
    while(p!=NULL&&p->data!=e){//循环找到数据域是e的指针
        p=p->next;
    }
    return p；
}

  2. 按位查找 ：从双链表的第一个结点开始，沿着next域从前往后依次搜索，直到找到第i个结点为止，如果查找成功，返回该结点 的指针，如果查找失败，（i大于表长）则返回NULL

    NLNode *GetElem(DLinkList D,int i){
    DLNode *p=D;//指针p指向当前扫描到的结点
    int j=0;//记录当前结点的位序，头结点是0
    while(p!=NULL&&j<i){
        p=p->next;
        j++;
    }//循环找到第i个结点
    return p;//返回第i个结点或者NULL
}
2.3.3.3 双链表的插入操作

  1. 在双链表中p所指的结点之后插入结点s，过程为：

    • 将s的next指针指向p的后继
    • 然后将p的后继的prior指针指向s
    • 将s的prior指向p
    • 将p的next指向s

  2. 插入操作代码片段

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

  3. 时间复杂度为O(1)

2.3.3.4 双链表的删除操作

  1. 删除双链表中 结点p的后继结点q

  2. 过程如下：

    • 将p的next指向q的后继

    • 将q的后继的prior指向p

      p->next=q->next;
q->next->prior=p;
free(q);

  3. 时间复杂度为O(1)

2.3.4 循环链表

2.3.4.1 循环单链表
  1. 循环单链表：单链表的最后一个结点的指针指向头结点，从而整个链表形成一个环，可以从任意一个结点找到任何一个结点
  2. 在循环单链表中，表尾结点r的next域指向L（头指针），因此表中没有指针域为NULL的结点，因此循环单链表的判空条件为尾指针是否等于头指针
  3. 循环单链表的初始化为L->next=L
  4. 循环单链表删除元素：
    • 循环单链表的插入、删除算法和单链表几乎一样，所不同的是，如果操作在表尾执行，则执行的操作不同，以便于保持链表的循环
    • 因为循环单链表是一个环，因此在任何位置上进行插入删除操作都是等价的，而无需判断是否在表尾
    • 循环单链表可以从任意一个结点开始遍历整个链表，有时对循环单链表仅设尾指针，以便操作效率更高，原因为：
      • 若设头指针，则在表尾插入元素的时间复杂度为O(n)
      • 若设尾指针r，r->next为头指针，在表头或者表尾插入元素时间复杂度为O(1)
2.3.4.2 循环双链表
  1. 循环双链表中，头结点的prior 指向尾结点，尾结点的next指向头结点
  2. 循环双链表为空表（包括初始化），头结点的prior和next都等于L
2.3.4.3 静态链表

  1. 静态链表是用数组描述线性表的链式存储结构，结点也有data域（数据域）和next域（指针域）

  2. 这里的指针是结点在数组中的相对地址（数组下标），又称游标

  3. 游标是下一个结点的数组下标

  4. 和顺序表一样，静态链表也需要预先分配一块连续的内存空间

  5. 静态链表结构类型的描述

    #define MaxSize 50//静态链表的最大长度为20
typedef struct{
    ElemType data;//存储数据元素
    int next;//下一个元素的数组下标
}SLinkList[MaxSize];//定义一个长度为MaxSize的Node数组

  6. 静态链表的初始化为：a[0]->next=-1

  7. 静态链表的结束标志：next==-1

  8. 静态链表的插入、删除操作与动态链表，只需修改指针，无需移动元素

  9. 查找的时间复杂度为O(n)

2.3.5 顺序表与链表的比较

  1. 两者比较

    顺序表链表
    存取（读/写）方式可以顺序存取也可以随机存取，在第i个位置上执行存取操作，顺序表仅需一次访问链表只能从表头开始依次存取，在第i个位置上执行存取的操作，链表需要从表头开始，依次访问i次
    逻辑结构与物理结构顺序表中，逻辑上相邻的元素，对应的物理存储地址也相邻链表中，对应的逻辑关系是通过指针链接表示的，与物理地址无关
    查找、插入和删除操作按值查找：顺序表无序时，时间复杂度为O(n)，有序时，可以采用折半查找，时间复杂度为O(log2n)；按序号查找时，顺序表支持随机访问，时间复杂度为O(1)；插入、删除操作时，平均需要移动半个表长的元素，时间复杂度为O(n)按值查找：时间复杂度为O(n)；按序号查找：时间复杂度为O(n)；插入、删除操作：仅需要修改相关结点的指针域，时间复杂度为O(n)；若在指定结点后插入或删除，时间复杂度为O(1)
    空间分配静态存储分配情况下，一旦存储空间装满，再加入新元素，则会发生溢出，若预先分配空间过大，会出现大量闲置；动态存储分配情形下，虽然存储空间可以扩充，但是需要移动大量元素，导致效率低，而且如果内存中没有更大块的连续存储空间，则会导致分配失败链式存储的结点空间只在需要时申请分配，只要内存有空间就可以分配，操作灵活高效，此外，由于链表的每个结点都带有指针域，因此存储密度不够大

  2. 如何选择存储结构

    • 基于存储考虑：

      • 难以估计线性表的长度或者规模，采用链表
      • 链表不用事先估计存储规模，但是链表存储密度低，链式存储结构的密度小于1

    • 基于运算考虑：

      • 经常做的运算是按位查找，则选择顺序表，时间复杂度为O(1)
      • 若是经常进行的操作是插入删除时，链表主要进行比较操作，因此选择；链表

    • 基于环境考虑：

      • 顺序表容易实现，因为任何高级语言中都有数组
      • 链表操作基于指针
阿芷芷
关注
数据结构——线性表的学习
ChenXiang_IT的博客
03-03 350
对于线性表我觉得只要牢牢抓住其连续空间分布的特点 注意其是否越界 注意空间位置变化就可以很好的掌握它  下面代码是对线性表的 构造 以及 增删查改  #include using namespace std; const int MaxSize = 100; template class SeqList { public: SeqList(){};//无参构造函
数据结构学习——线性表
Mr.Tong的博客
12-30 411
数据结构学习——线性表考试前复习下数据结构，把一些知识点整理在这！主要参考了殷人昆主编的《数据结构(用面向对象方法与C++语言描述)》这本书，以及中山大学刘聪老师的课件内容！ 概念与性质 存储方式 类的定义 概念与性质 线性表（Linear List）是由n（n≥0）个数据元素（结点）a[0]，a1，a2…，a[n-1]组成的有限序列。——[维基百科] 线性表是一个有限序列，意味着表中各个表项是
学习数据结构中的线性表
RuMR的博客
08-13 156
  先是数组实现 /*数组实现顺序表*/ #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #define MAXSIZE 100 typedef int ElementType; typedef struct { ElementType Data[MAXSIZE]; int Last; }List; List *Ma...
数据结构第二章线性表c++代码
07-14
本压缩包包含的数据结构第二章线性表的C++代码，重点展示了数据结构中的几个基本概念，如静态顺序表、动态顺序表、单链表和双链表。这些数据结构在实际编程中有着广泛的应用，例如在操作系统、数据库系统、编译器...
专升本数据结构第二章 线性表.pdf
最新发布
01-14
线性表是数据结构的基础部分，它是一种特殊的数据组织形式，由n（n>=0）个相同类型的数据元素构成的有限序列。线性表的每个元素都有一个直接前驱和直接后继，除了首元素（没有前驱）和尾元素（没有后继）。这种结构...
数据结构第二章线性表.pdf
09-30
数据结构第二章线性表.pdf 本章主要介绍了线性表的逻辑结构、顺序存储结构和链式存储结构，并对顺序表和链表进行了比较。学习目的要求学生能够熟悉线性表的逻辑结构和各种存储表示方法，以及定义在逻辑结构上的各种...
数据结构第二章线性表习题.doc
09-24
数据结构第二章线性表习题 本节习题涵盖了数据结构第二章线性表的主要知识点，包括线性表的定义、顺序表和链表的存储结构、插入、删除、查找等基本操作的时间复杂度分析，以及栈的实现和应用。 1. 线性表是有限...
数据结构第二章线性表
03-03
线性表的定义和基本操作 线性表的顺序存储结构 线性表的链式存储结构 线性表的应用举例
数据结构学习-线性表
qq_39751437的博客
10-08 184
文章目录一、线性表基础知识二、线性表的基本操作线性表的顺序存储线性表的链式存储三、线性表代码实现-参考资料（c++） 一、线性表基础知识 表是由同类型的数据元素构成有序序列的线性结构。表中元素个数称为表的长度，没有元素时称为空表，表的第一个位置称为表头，最后一个位置称为表尾。 二、线性表的基本操作 线性表可以由抽象数据类型来表示，包括数据对象集和操作集。线性表有两种实现方法，第一种为链表（链式存储...
数据结构学习笔记——线性表
MarcoAsensio的博客
02-23 647
1.定义 线性表（List）：零个或多个数据元素的有限序列。 首先它是一个序列。也就是说，元素之间是有顺序的，若元素存在多个，则第一个元素无前驱，最后一个元素无后继，其他每个元素都有且只有一个前驱和后继。 2.线性表的抽象数据类型 线性表作为一种数据结构我们在掌握了它的定义之后，接下来需要知道对这样的一种数据结构，我们可以提供哪些操作来将它应用于编程中，来实现各种各样的需求。 1.InitList...
数据结构（第二章线性表，学习笔记）
weixin_42645653的博客
07-12 675
线性表 1.1定义和基本操作   <1>线性表的定义(逻辑结构)：   具有相同数据类型的n（n≥0）个数据元素的有限序列。 PS:   n为表长，n=0为空表，位序（从1开始），表头元素，表位元素，直接前驱，直接后继。   <2>线性表的特点：     ①个数有限。     ②逻辑上顺序（先后次序）。     ③都是数据元素（单个元素）。     ④数据类型相同（存储空间同）。   <3>线性表的基本操作（基本操作）：     ①从无到有，从有到无：     InitL
线性表及其实现 数据结构学习
小渣渣的博客
01-21 285
课程是跟着MOOC 数据结构 陈越、何钦铭二位老师学的，这遍两个目的：1.复习，2.找找不同大学教学水平的差距       问题引入：一元多项式的表示及运算 如何表示？ （1）最容易想到的办法（顺序存储方式）：用结构体数组存储多项式的每一项的系数及指数。    但是这种结构有弊端，如下图： 很显然，我们要用一个空间为2001的数组仅仅存了3个有用的数据，其他项全为零，造...
数据结构学习之线性表笔记总结
m0_63094069的博客
09-07 521
线性表学习笔记
数据结构与算法——线性表（链表篇）
热门推荐
小田是个程序员的博客欢迎你的到来呀~
06-20 2万+
本篇文章，主要详细解读和总结线性表的链式存储结构——链表，包括单链表、双链表、静态链表以及循环链表，讲解较为全面，图文并茂，总结各链表的特性以及基本操作，干货满满，各位小伙伴们请细细品读，你会收获你想要的知识的！.........
数据结构学习1——线性表定义以及代码
m0_53552112的博客
06-29 1513
数据结构的线性表总代码——串联一章
线性表的两种实现方法-数据结构学习笔记2.1
凤凰涅磐
03-25 858
typedef int Position; typedef struct LNode *List; struct LNode { ElementType Data[MAXSIZE]; Position Last; }; /* 初始化 */ List MakeEmpty() { List L;
一个菜鸟的数据结构学习之路一（线性表篇，望大佬斧正！）
qq_42014895的博客
05-09 879
线性表：线性表的顺序储存结构是一种随机存取的储存结构 以下代码及注释则是其基本操作的简单实现： 线性表的动态分配顺序储存结构： struct list { ElemType *elem; //存放数据元素的基址 int length; //当前线性表的长度 int listsize; //当前分配的储存容量 }SqList; 相关宏定义： # define LIST_INI...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值