2.1 线性表的逻辑结构与存储结构

已于 2023-07-17 11:33:35 修改
阅读量1.4k 收藏 8
点赞数
分类专栏： # 线性表 文章标签： 算法 c++ 考研 数据结构
于 2023-07-12 12:06:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/oncruise/article/details/131655051
版权

        在之前的数据结构知识铺垫2：物理结构与逻辑结构一文中, 我们介绍了物理结构与逻辑结构, 物理结构即存储结构. 本篇文章我们着重探讨一下线性表的逻辑结构与存储结构. 

1. 线性表的逻辑结构

        

 图1. 线性表的逻辑结构

        线性表是具有相同特性的数据元素的有限序列, 每个元素至多有一个前驱和一个后继. 

2. 线性表的存储结构

        说到存储结构, 我们就要想到计算机中的内存的特点, 数据元素存储在计算机的内存中, 就只有连续存储和非连续存储两种方式. 线性表的存储结构也可以按照这两种方式分类. 

1. 线性表的顺序存储结构

        数组是典型的顺序存储结构的线性表. 

#include <iostream>

const int MAX_SIZE = 10;

int main()
{
    int number[MAX_SIZE];       //为数组开辟的存储空间的大小为MAX_SIZE
    int length = 6;             //length为数组中的元素个数, length <= MAX_SIZE
    for (int i = 0; i < length; i++)
    {
        number[i] = i;
        printf("%d\n", number[i]);
    }
}

代码1: 线性表的顺序存储

2. 线性表的链式存储结构

1. 单链表

        这里我们引入一个概念: 头结点. 头结点是不含任何数据信息的结点. 因此单链表又可以分为没有头结点的单链表和有头结点的单链表. 

        我们先回顾一下如何定义一个结构体: 

typedef struct LNode {
    int data;
    struct LNode *next;
}LNode;

代码2: 定义一个结构体

        再来看一下这段代码: 

#include <iostream>

typedef struct LNode {
    int data;
    struct LNode* next;
}LNode;

int main()
{
    LNode* A;
    LNode B;
}

代码3: A是指针类型, B是LNode类型的变量

        A和B有什么区别? (以下内容来自Chat GPT)

        1. A是一个指针类型，指向LNode结构体的地址，而B是一个LNode类型的变量。

        2. A需要通过动态内存分配来进行创建和初始化，而B是一个静态变量，不需要额外的内存分配。

        3. A可以通过操作指针来访问和修改LNode结构体中的数据和指针，而B直接访问和修改LNode结构体中的数据和指针。

        4. A可以指向一个链表的第一个节点，从而对整个链表进行操作，而B只能表示一个节点，不能表示整个链表。

        两种定义方式哪种更好?(以下内容来自Chat GPT)

        哪种方式更好取决于具体的需求和场景。

        如果需要创建一个链表，进行动态的插入、删除操作，并且需要在不同的函数之间传递链表的头指针，那么使用指针类型的变量（如A）更合适，因为它可以通过指针操作来方便地修改链表的指针和数据，同时在函数之间传递链表的头指针也更方便。

        如果只需要创建一个简单的节点，不需要进行复杂的链表操作，并且节点的生命周期在一个函数内，不需要在函数之间传递，那么使用普通的结构体变量（如B）更简洁和方便，不需要进行动态内存分配和释放。

        综上所述，根据具体的需求和场景来选择合适的方式更好。

        LNode* A; 与LNode *A; 有什么区别?(以下内容来自Chat GPT)

        在C语言中，LNode* A; 和LNode *A;是等效的，都表示定义了一个指针变量A，指向LNode类型的对象。

        C语言中的指针声明可以采用两种方式，即“指针型修饰符在前”和“指针型修饰符在后”的写法，它们的区别仅仅是语法风格上的差异。

        在LNode* A;中，指针型修饰符*位于类型名LNode之后，这种写法更符合C++中的风格习惯。

        而在LNode *A;中，指针型修饰符*位于变量名A之前，这种写法更符合C语言中的传统写法。

        总之，LNode* A;和LNode *A;都可以正确地定义一个指向LNode类型的指针变量A，具体使用哪种写法取决于个人的编程风格和习惯。

        由于我们后面的学习中会大量地使用对链表的插入删除等操作, 因此我们以后均采用LNode *A;这样的方式. 仅仅是定义结点还不够, 我们还需要给结点分配内存空间. 看下面的代码: 

#include <iostream>

typedef struct LNode {
    int data;
    struct LNode* next;
}LNode;

int main()
{
    LNode *A;
    A = (LNode*)malloc(sizeof(LNode));
    LNode* B;
    B = new LNode;
}

代码4: 分配内存空间的两种方式(前者为C, 后者为C++)

        A = (LNode*)malloc(sizeof(LNode));什么意思? (以下内容来自Chat GPT)

        A = (LNode*)malloc(sizeof(LNode)); 的意思是动态地分配了一块内存空间，大小为LNode所占的字节数，并将其起始地址赋值给指针变量A。

具体解释如下： 

        sizeof(LNode)用来获取结构体LNode所占的字节数。sizeof是C语言中的运算符，用于获取变量、类型或表达式所占用的字节数。

        malloc函数用于在堆内存中分配一块指定大小的内存空间。它的参数是所需分配的内存大小（以字节为单位）。在这里，我们分配了sizeof(LNode)个字节的内存空间。

        (LNode*)是类型转换操作符，将malloc返回的通用指针（void*类型）强制转换为LNode类型的指针。因为malloc返回的是通用指针，需要进行类型转换才能将其赋值给LNode指针。

        A是指针变量，它存储了malloc分配的内存空间的起始地址。通过将malloc的返回值赋给A，可以使A指向所分配的内存空间。

        总之，这行代码的作用是动态地分配了一块内存空间，用于存储一个LNode类型的对象，并将其起始地址赋值给指针变量A。这样，通过A可以访问到这块内存空间，并对其中的数据进行操作。

        需要注意的是，这段代码使用了C语言的malloc函数，而不是C++的new操作符。因此，为了正确释放分配的内存空间，应该在适当的时候使用free(A)来释放A所指向的内存空间free(A)new。

       A = (LNode*)malloc(sizeof(LNode));和A = new LNode;哪种方式更好?(以下内容来自Chat GPT)

         A = (LNode*)malloc(sizeof(LNode)); 和 A = new LNode; 这两种方式都可以用来分配内存空间，不同之处在于它们的使用方式和特点。

        malloc函数是C语言标准库中的函数，而new操作符是C++的运算符。

        malloc函数分配的是一块原始的内存空间，需要通过类型转换将其转换为所需的类型。
        new操作符分配的是一个完整的对象，返回的是指向该对象的指针，不需要进行类型转换。
        malloc函数需要手动指定所需的内存空间大小，而new操作符会根据对象的类型自动计算所需的内存空间大小。

        malloc函数分配的内存空间需要使用free函数手动释放，而new操作符分配的内存空间会在对象被销毁时自动释放。

        综上所述，A = new LNode; 更符合C++的风格和习惯，更安全可靠，因为它能够自动计算所需的内存空间大小，并在对象销毁时自动释放内存。因此，在C++中，使用new操作符来分配内存空间是更好的选择。

        这里Chat GPT说的有问题, C++用new创建对象时返回的是一个对象指针，object指向一个ClassName的对象，C++分配给object的仅仅是存放指针值的空间。而且，用new 动态创建的对象必须用delete来撤销该对象。只有delete对象才会调用其析构函数。在C中是指由malloc,free运算产生释放的存储空间，在C++中就是指new和delete运算符作用的存储区域。来源: https://blog.csdn.net/qq_41951658/article/details/107595801. 因此,  malloc与free需要成对出现, 

new和delete需要成对出现. 所以说不要盲目相信Chat GPT. 

        这里我们使用new操作符来分配内存空间.

        先看没有头结点的单链表. 

 没有头结点的单链表

        图中的Head即为代码的指针p, 并非头结点. 

#include <iostream>

typedef struct LNode {
    int data;
    struct LNode* next;
}LNode;

/// <summary>
/// 遍历输出链表各个结点的值
/// </summary>
/// <param name="firstNode"></param>
void traverseLinkedList(LNode *p) {
    while (p != NULL) {
        // 对当前节点进行操作，打印节点的数据
        printf("%d\n", p->data);

        // 移动到下一个节点
        p = p->next;
    }
}

/// <summary>
/// 判断链表是否非空
/// </summary>
/// <param name="p"></param>
bool linkedListIsNotNull(LNode *p) {
    if (p == NULL) {
        return false;
    }
    return true;
}

int main()
{
    LNode *A;
    A = new LNode;
    LNode *B;
    B = new LNode;
    LNode *C;
    C = new LNode;

    A->data = 10;
    B->data = 20;
    C->data = 30;

    A->next = B;
    B->next = C;
    C->next = NULL;

    LNode *p = A;        //p即为图中的Head
    bool isNotNull = linkedListIsNotNull(p);
    if (isNotNull) {
        traverseLinkedList(p);
    }
    else {
        printf("链表为空!");
    }
}

代码5: 没有头结点的单链表

没有头结点的单链表的判空条件: LNode *p = A; 若p == NULL; 则链表为空. 

       

        再看有头结点的单链表. 

 有头结点的单链表

        图中的Head即为代码的指针p, 并非头结点, Head指向的结点才是头结点. 

#include <iostream>

typedef struct LNode {
    int data;
    struct LNode* next;
}LNode;

/// <summary>
/// 遍历输出链表各个结点的值
/// </summary>
/// <param name="firstNode"></param>
void traverseLinkedList(LNode *p) {
    p = p->next;
    while (p != NULL) {
        // 对当前节点进行操作，打印节点的数据
        printf("%d\n", p->data);

        // 移动到下一个节点
        p = p->next;
    }
}

/// <summary>
/// 判断链表是否非空
/// </summary>
/// <param name="p"></param>
bool linkedListIsNotNull(LNode *p) {
    if (p->next == NULL) {
        return false;
    }
    return true;
}

int main()
{
    LNode* H;
    H = new LNode;
    LNode *A;
    A = new LNode;
    LNode *B;
    B = new LNode;
    LNode *C;
    C = new LNode;

    H->data = NULL;
    A->data = 10;
    B->data = 20;
    C->data = 30;

    H->next = A;
    A->next = B;
    B->next = C;
    C->next = NULL;

    LNode *p = H;        //p即为图中的Head
    bool isNotNull = linkedListIsNotNull(p);
    if (isNotNull) {
        traverseLinkedList(p);
    }
    else {
        printf("链表为空!");
    }
}

代码6: 有头结点的单链表

有头结点的单链表的判空条件: LNode *p = H; 若p->next == NULL; 则链表为空. 

2. 双链表

        先看没有头结点的双链表: 

 没有头结点的双链表

        图中的Head即为代码的指针p, 并非头结点. 

#include <iostream>

typedef struct LNode {
    int data;
    struct LNode* next;
    struct LNode* prior;
}LNode;

/// <summary>
/// 遍历输出链表各个结点的值
/// </summary>
/// <param name="firstNode"></param>
void traverseLinkedList(LNode *p) {
    while (p != NULL) {
        // 对当前节点进行操作，打印节点的数据
        printf("%d\n", p->data);

        // 移动到下一个节点
        p = p->next;
    }
}

/// <summary>
/// 判断链表是否非空
/// </summary>
/// <param name="p"></param>
bool linkedListIsNotNull(LNode *p) {
    if (p == NULL) {
        return false;
    }
    return true;
}

int main()
{
    LNode *A;
    A = new LNode;
    LNode *B;
    B = new LNode;
    LNode *C;
    C = new LNode;

    A->data = 10;
    B->data = 20;
    C->data = 30;

    A->next = B;
    B->next = C;
    C->next = NULL;

    A->prior = NULL;
    B->prior = A;
    C->prior = B;

    LNode *p = A;        //p即为图中的Head
    bool isNotNull = linkedListIsNotNull(p);
    if (isNotNull) {
        traverseLinkedList(p);
    }
    else {
        printf("链表为空!");
    }
}

代码7: 没有头结点的双链表

没有头结点的双链表的判空条件: LNode *p = A; 若p == NULL; 则链表为空. 

       

        再看有头结点的双链表: 

 有头结点的双链表

        图中的Head即为代码的指针p, 并非头结点, Head指向的结点才是头结点. 

#include <iostream>

typedef struct LNode {
    int data;
    struct LNode* next;
    struct LNode* prior;
}LNode;

/// <summary>
/// 遍历输出链表各个结点的值
/// </summary>
/// <param name="firstNode"></param>
void traverseLinkedList(LNode *p) {
    p = p->next;
    while (p != NULL) {
        // 对当前节点进行操作，打印节点的数据
        printf("%d\n", p->data);

        // 移动到下一个节点
        p = p->next;
    }
}

/// <summary>
/// 判断链表是否非空
/// </summary>
/// <param name="p"></param>
bool linkedListIsNotNull(LNode *p) {
    if (p->next == NULL) {
        return false;
    }
    return true;
}

int main()
{
    LNode* H;
    H = new LNode;
    LNode *A;
    A = new LNode;
    LNode *B;
    B = new LNode;
    LNode *C;
    C = new LNode;

    H->data = NULL;
    A->data = 10;
    B->data = 20;
    C->data = 30;

    H->next = A;
    A->next = B;
    B->next = C;
    C->next = NULL;

    H->prior = NULL;
    A->prior = H;
    B->prior = A;
    C->prior = B;

    LNode *p = H;        //p即为图中的Head
    bool isNotNull = linkedListIsNotNull(p);
    if (isNotNull) {
        traverseLinkedList(p);
    }
    else {
        printf("链表为空!");
    }
}

代码8: 有头结点的双链表

        有头结点的双链表的判空条件: LNode *p = H; 若p->next == NULL; 则链表为空. 

3. 循环链表

1. 单循环链表

        先看没有头结点的单循环链表: 

 没有头结点的单循环链表

        图中的Head即为代码的指针p, 并非头结点. 

#include <iostream>

typedef struct LNode {
    int data;
    struct LNode* next;
}LNode;

/// <summary>
/// 遍历输出链表各个结点的值
/// </summary>
/// <param name="firstNode"></param>
void traverseLinkedList(LNode *p) {
    int *address = &p->data;        //记录首个结点的数据的存放地址, 注意这里要取的是&p->data而不是&p, 因为p只是一个指针, 它的内存地址&p是不会改变的
    while (p != NULL) {
        // 对当前结点进行操作，打印结点的数据
        printf("%d\n", p->data);

        // 移动到下一个结点
        p = p->next;

        if (address == &p->data) {  //当p指向的数据的存放地址等于address时, 说明完成了一次遍历, 则跳出循环
            break;
        }
    }
}

/// <summary>
/// 判断链表是否非空
/// </summary>
/// <param name="p"></param>
bool linkedListIsNotNull(LNode *p) {
    if (p == NULL) {
        return false;
    }
    return true;
}

int main()
{
    LNode *A;
    A = new LNode;
    LNode *B;
    B = new LNode;
    LNode *C;
    C = new LNode;

    A->data = 10;
    B->data = 20;
    C->data = 30;

    A->next = B;
    B->next = C;
    C->next = A;

    LNode *p = A;        //p即为图中的Head
    bool isNotNull = linkedListIsNotNull(p);
    if (isNotNull) {
        traverseLinkedList(p);
    }
    else {
        printf("链表为空!");
    }
}

代码9: 没有头结点的单循环链表

        其中address记录首个结点的数据的存放地址. 注意这里address要取的是&p->data而不是&p, 因为p只是一个指针, 它的内存地址&p是不会改变的. 

没有头结点的单循环链表的判空条件: LNode *p = A; 若p == NULL; 则链表为空. 

       

        再看有头结点的单循环链表: 

 有头结点的单循环链表

        图中的Head即为代码的指针p, 并非头结点, Head指向的结点才是头结点. 

#include <iostream>

typedef struct LNode {
    int data;
    struct LNode* next;
}LNode;

/// <summary>
/// 遍历输出链表各个结点的值
/// </summary>
/// <param name="firstNode"></param>
void traverseLinkedList(LNode* p) {
    p = p->next;
    int* address = &p->data;        //记录首个结点的数据的存放地址, 注意这里要取的是&p->data而不是&p, 因为p只是一个指针, 它的内存地址&p是不会改变的
    while (p != NULL) {
        // 对当前结点进行操作，打印结点的数据
        printf("%d\n", p->data);

        // 移动到下一个结点
        p = p->next;

        if (address == &p->data) {  //当p指向的数据的存放地址等于address时, 说明完成了一次遍历, 则跳出循环
            break;
        }
    }
}

/// <summary>
/// 判断链表是否非空
/// </summary>
/// <param name="p"></param>
bool linkedListIsNotNull(LNode* p) {
    if (p->next == p) {
        return false;
    }
    return true;
}

int main()
{
    LNode* H;
    H = new LNode;

    LNode* A;
    A = new LNode;
    LNode* B;
    B = new LNode;
    LNode* C;
    C = new LNode;

    H->data = NULL;
    A->data = 10;
    B->data = 20;
    C->data = 30;

    H->next = A;
    A->next = B;
    B->next = C;
    C->next = H;

    LNode* p = H;        //p即为图中的Head
    bool isNotNull = linkedListIsNotNull(p);
    if (isNotNull) {
        traverseLinkedList(p);
    }
    else {
        printf("链表为空!");
    }
}

代码10: 有头结点的单循环链表        

有头结点的单循环链表的判空条件: LNode *p = H; 若p->next == p; 则链表为空. 

2. 双循环链表

        先看没有头结点的双循环链表: 

 没有头结点的双循环链表

        图中的Head即为代码的指针p, 并非头结点. 

#include <iostream>

typedef struct LNode {
    int data;
    struct LNode *next;
    struct LNode *prior;
}LNode;

/// <summary>
/// 遍历输出链表各个结点的值
/// </summary>
/// <param name="firstNode"></param>
void traverseLinkedList(LNode* p) {
    int* address = &p->data;        //记录首个结点的数据的存放地址, 注意这里要取的是&p->data而不是&p, 因为p只是一个指针, 它的内存地址&p是不会改变的
    while (p != NULL) {
        // 对当前结点进行操作，打印结点的数据
        printf("%d\n", p->data);

        // 移动到下一个结点
        p = p->next;

        if (address == &p->data) {  //当p指向的数据的存放地址等于address时, 说明完成了一次遍历, 则跳出循环
            break;
        }
    }
}

/// <summary>
/// 判断链表是否非空
/// </summary>
/// <param name="p"></param>
bool linkedListIsNotNull(LNode* p) {
    if (p == NULL) {
        return false;
    }
    return true;
}

int main()
{
    LNode* A;
    A = new LNode;
    LNode* B;
    B = new LNode;
    LNode* C;
    C = new LNode;

    A->data = 10;
    B->data = 20;
    C->data = 30;

    A->next = B;
    B->next = C;
    C->next = A;

    A->prior = C;
    B->prior = A;
    C->prior = B;

    LNode* p = A;        //p即为图中的Head
    bool isNotNull = linkedListIsNotNull(p);
    if (isNotNull) {
        traverseLinkedList(p);
    }
    else {
        printf("链表为空!");
    }
}

代码11: 没有头结点的双循环链表

 没有头结点的双循环链表的判空条件: LNode *p = A; 若p == NULL; 则链表为空. 

       

        再看有头结点的双循环链表: 

 有头结点的双循环链表. 

        图中的Head即为代码的指针p, 并非头结点, Head指向的结点才是头结点. 

#include <iostream>

typedef struct LNode {
    int data;
    struct LNode *next;
    struct LNode *prior;
}LNode;

/// <summary>
/// 遍历输出链表各个结点的值
/// </summary>
/// <param name="firstNode"></param>
void traverseLinkedList(LNode* p) {
    p = p->next;
    int* address = &p->data;        //记录首个结点的数据的存放地址, 注意这里要取的是&p->data而不是&p, 因为p只是一个指针, 它的内存地址&p是不会改变的
    while (p != NULL) {
        // 对当前结点进行操作，打印结点的数据
        printf("%d\n", p->data);

        // 移动到下一个结点
        p = p->next;

        if (address == &p->data) {  //当p指向的数据的存放地址等于address时, 说明完成了一次遍历, 则跳出循环
            break;
        }
    }
}

/// <summary>
/// 判断链表是否非空
/// </summary>
/// <param name="p"></param>
bool linkedListIsNotNull(LNode* p) {
    if (p->next == p || p->prior == p) {
        return false;
    }
    return true;
}

int main()
{
    LNode* H;
    H = new LNode;
    LNode* A;
    A = new LNode;
    LNode* B;
    B = new LNode;
    LNode* C;
    C = new LNode;

    H->data = NULL;
    A->data = 10;
    B->data = 20;
    C->data = 30;

    H->next = A;
    A->next = B;
    B->next = C;
    C->next = H;

    H->prior = C;
    A->prior = H;
    B->prior = A;
    C->prior = B;

    LNode* p = H;        //p即为图中的Head
    bool isNotNull = linkedListIsNotNull(p);
    if (isNotNull) {
        traverseLinkedList(p);
    }
    else {
        printf("链表为空!");
    }
}

代码12: 有头结点的双循环链表

         

有头结点的双循环链表的判空条件: LNode *p = H;若p->next == p 或 p->prior == p; 则链表为空. 

        不管是单链表, 双链表还是循环链表, 只要不含头结点, 判空条件均为Head == NULL为真.

oncruise
关注
专栏目录
【数据结构-浙大-陈越】2.1 线性表、顺序存储及其操作
wayaya112的博客
09-21 722
线性表简介，使用数组实现线性表的顺序存储
线性表的逻辑结构
bingXxx的博客
12-11 7795
线性表的定义:用数据元素的有限序列表示的表,我们称之为线性表 比如 a1,a2,a3,a4…an,其中a1就是线性表的起点,而a1中的下标1表示的就是元素的序号,它表示了这个元素在线性表中的位置,而相对a2来说它的直接前驱就是a1,而它的直接后继就是a3,而an中n表示的就是这个线性表的长度. 注意:同一个线性表具有相同的特性,相邻的数据元素之间是序偶关系(表示的就是有序成对的意思) 比如上面这...
数据结构(03)：线性表的逻辑结构
最新发布
qq_42279379的博客
08-15 258
线性表的逻辑结构：介绍了线性表的逻辑结构，并阐述了线性表的基本特征，即线性表的抽象数据类型
线性表(逻辑结构)
weixin_39280437的博客
07-12 1771
线性表定义（逻辑结构）值得注意的特性重要术语基本运算创销、增删改查判空、判长、打印输出其它值得注意的点 定义（逻辑结构） 线性表是具有相同数据类型的n个数据元素的有限序列，其中n为表长，当n=0时线性表是一个空表。若用L表示线性表，则一般表示为 几个概念： a_i表示线性表中第i个元素的位序；（程序中下标从零开始） a_0表示线性表的表头元素； a_n表示线性表的表尾元素； 除第一个元素外，每个元素有且仅有一个直接前驱；除最后一个元素外，每个元素有且仅有一个直接后继 值得注意的特性 数据元素同类型、
数据结构学习笔记——线性表逻辑结构和顺序存储结构
weixin_62440328的博客
10-26 2386
用顺序存储方法存储的线性表。所谓顺序存储方法存储的线性表就是把线性表的结点按逻辑次序依次存放在一组地址连续的存储单元里的方法。
2.1 线性表1
08-03
顺序存储结构，也称为顺序表，是将线性表的元素按逻辑顺序依次存储在一片连续的内存空间中。这种结构具有随机访问特性，但插入和删除操作需要移动大量元素，效率较低。顺序表的空间分配通常是静态的，一旦分配，无法...
数据结构讲义：线性表逻辑结构与实现
教学内容涵盖2.1线性表的逻辑结构，2.2线性表的顺序存储及运算实现，以及2.3线性表的链式存储和实现。在顺序表上，插入和删除操作通常涉及到元素的移动，而在链表上，这些操作主要通过改变指针来完成。链表分为...
（浙大陈越版）数据结构 第二章 线性结构 2.1 线性表及其实现
m0_56661338的博客
03-25 722
讲解了线性结构、线性表、线性表的顺序存储和链式存储及其实现方法，补充了广义表、多重链表。引入多项式、矩阵等实际问题讲解相关概念。部分实现采用了C语言代码。
2.1 线性表
居于幽暗而自己努力 的博客
12-21 1009
线性表抽象数据类型定义 //参考西北大学耿国华教授的《数据结构》第二版 ADT LinerList{ 数据元素：D = {ai | ai ∈ D0 , i = 1,2,…,n , n>=0 , D0 为某一数据类型} 结构关系：R = {<ai,aj> | ai,ai+1 ∈D0,i = 1,2,…，n - 1} 基本操作： 1 InitList(L) 2 ListLength(L) 3 GetData(L,i) 4 InsList(L,i,e) 5 DelList(L,i
第三章 数据结构 线性表的逻辑结构 和 线性表的顺序存储结构，链式存储结构
weixin_43960370的博客
03-12 1284
线性表是最简单的数据结构，是由0个或多个类型相同的数据元素组成的有限序列。 线性表中的元素是一 一对应的。 引用 集合与线性表的区别在于元素是否可以重复。 ...
线性表逻辑结构
gsh1075035316的博客
08-10 452
按元素的特性分类 再按元素的不同组织关系分类 如一对一、一对多、多对多 先强调元素的相同特性 再强调元素的不同组织关系 上面这些话的意思是 不只线性表要强调相同特性 图 树等等 都要强调相同特性 ...
七 线性表及其逻辑和存储结构
weixin_30791095的博客
10-23 123
线性表及其定义：n个类型相同的有限序列，通常记做(a0,a1,......an-1) 1.相同数据类型：比如都是数字，或者都是字符，都是学生，都是商品。只能一类 相同的数据类型意味着在内存存储时，每个元素占用相同的空间，便于查询。 2序列（顺序性）：在线性表的相邻元素之间存在着序偶关系。 ...
线性表的存储结构
qq_37361514的博客
06-25 1012
线性表的存储结构分为顺序存储和链式存储 顺序存储 指用一组地址连续的存储单元依次存储线性表中的数据元素，从而使得逻辑上相邻的两个数据元素在物理位置上也相邻。 用例：数组 优点：能随机存储线性表中的任意一个结点 缺点：①数组的大小通常是固定的，不利于随意增加或减少线性表中的结点个数 ②插入和删除线性表中的结点时，要移动数组中的其他元素，操作复杂 在顺序存储线性表中，...
【数据结构】线性表的逻辑结构
weixin_34381666的博客
12-28 740
1. 基本特征 　　线性结构是一个数据元素有序（次序）集 2. 特点 　　1.每一个线性表有唯一的第一元素 　　2.每一个线性表有唯一的最后元素 　　3.除了最后一个元素外的每一个元素都有唯一后继 　　4.除了第一个元素外的每一个元素都有唯一前驱 3. 抽象数据类型 　　抽象数据类型线性表定义 　　基本操作： 　　　　结构初始化操作（构造一个空的线性表） 　　　　　　Init...
1.1 线性表的逻辑结构：
L158943041的博客
06-02 774
例一：有两个集合A和B分别用两个线性表La和Lb表示，即：线性表中的数据元素即为集合中的成员；分析：上述问题演绎为：要求对线性表作如下操作：扩大线性表La,将存于线性表Lb中而不存与线性表La中的数据元素插入到La中去。线性集合A和B的合并：A：把B中的元素加入A中首先： Len_Lb = ListbLength(Lb);(Len_La = ListLength(La))取得线性表Lb的长度，为下...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值