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

已于 2023-07-17 11:33:35 修改
阅读量1k 收藏 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
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2.1 线性表1
08-03
顺序存储结构，也称为顺序表，是将线性表的元素按逻辑顺序依次存储在一片连续的内存空间中。这种结构具有随机访问特性，但插入和删除操作需要移动大量元素，效率较低。顺序表的空间分配通常是静态的，一旦分配，无法...
【数据结构教程】线性表及其逻辑结构
m0_65431212的博客
10-22 1261
01
数据结构笔记—2.1线性表的逻辑结构
hhztian的博客
05-31 3057
2.1线性表本章概览线性表的概念线性表的特性线性表的功能概述纯虚函数在构造线性表中的意义类模板在构造线性表中的意义运算符重载在构造线性表中的意义线性表的存储表示 本章概览 线性表的逻辑结构 线性表的顺序存储及实现 线性表的链接存储及实现 顺序表和链表的应用 线性表的其他存储方法 线性表的概念 线性表（linear line）是最简单的数据结构。非空表记为：L＝（a1, a2 , …, ai-1...
线性表——(1)线性表的逻辑结构
一个正在学习C/C++的博主
11-27 1215
线性表的逻辑结构
数据结构学习笔记——线性表逻辑结构和顺序存储结构
weixin_62440328的博客
10-26 2223
用顺序存储方法存储的线性表。所谓顺序存储方法存储的线性表就是把线性表的结点按逻辑次序依次存放在一组地址连续的存储单元里的方法。
线性表的逻辑结构
bingXxx的博客
12-11 7748
线性表的定义:用数据元素的有限序列表示的表,我们称之为线性表 比如 a1,a2,a3,a4…an,其中a1就是线性表的起点,而a1中的下标1表示的就是元素的序号,它表示了这个元素在线性表中的位置,而相对a2来说它的直接前驱就是a1,而它的直接后继就是a3,而an中n表示的就是这个线性表的长度. 注意:同一个线性表具有相同的特性,相邻的数据元素之间是序偶关系(表示的就是有序成对的意思) 比如上面这...
数据结构第二章2.1-2.2
11-23
这些元素可以按逻辑顺序排列，它们在内存中的存储方式可以是顺序存储或链式存储。顺序存储结构通常用数组实现，而链式存储则用链表实现。线性表的基本操作包括插入、删除、查找和遍历。在顺序表中，由于元素位置固定...
数据结构：第2章 线性表.ppt
06-12
2.1 线性表的逻辑结构 线性表的定义是一个有限序列，由n（n ≥ 0）个具有相同特性的数据元素组成。当n=0时，线性表为空表。序列中的元素可以通过它们的位置来引用，例如，第一个元素称为表头元素，最后一个元素称为...
数据结构：第2章线性表.pdf
06-12
2.1 线性表及其逻辑结构 线性表是一种基本的数据结构，由n（n>=0）个数据元素（结点）组成的有限序列。线性表的逻辑结构可以用二元组表示为：L=（D，R），其中D={ai|1≤i ≤n,n≥0,ai属ElemType类型}，R={r}r={, ai...
数据结构概述（逻辑结构与存储结构概念详解）
王青宇的博客
03-23 9053
目录 一.一些基本概念 二.逻辑结构 1.集合结构： 2.线性结构： 1）线性表： 2）栈 3）队列 4）串 3.非线性结构： 1）数组 2）广义表 3）树 4）堆 5）图 三.物理结构/存储结构 1.顺序结构： 2.链式结构： 3.索引结构： 数据结构就是研究数据的逻辑结构和物理结构以及它们之间的相互关系，并对这种结构定义相应的运算，且确保经过这些运算后所得到的新结构仍然是原来的结构类型。简单来说，就是计算机存储、组织数据的方式。 一.一些基本概念 程序=数据结构
数据结构——线性结构（线性表）
热门推荐
巧克力布丁的博客
10-24 1万+
定义把所有的结点用一根直线穿起来详细定义线性表是具有相同数据类型的n（n≥0）个数据元素的有限序列，其中n为表长，n=0是一个空表。用L表示线性表a1是唯一的第一个数据元素，又称表头元素；an是唯一的最后一个元素，又叫表尾元素。除了第一个元素之外，每个元素有且仅有一个直接前驱。除了最后一个元素外，每个元素有且仅有一个直接后继。n个节点离散分配彼此通过指针相连每个节点只有一个前驱节点，每个节点只有一个后续节点首节点没有前驱节点，尾节点没有后续节点从某种角度而言。............
数据结构|总结线性表的几种存储结果
weixin_40141473的博客
10-11 580
一、顺序存储结构——顺序表 顺序表是用一段地址连续的存储单元依次存储线性表的数据元素。所以通常用数组来存储线性表，用数组存放，这意味着我们要确定数组的长度，分配固定长度的数组空间。 ①特点：内存中地址连续，支持随机查找，按位查找算法的时间复杂度为O（1），按值查找的平均时间性能是O（n），插入删除操作的平均时间性能是O（n），适用于需要大量访问元素，而没有或少量增添或删除元素...
第二章——线性表2.1线性表及其逻辑结构
qq_42974449的博客
09-17 1533
1.3.1算法分析概述：算法分析就是分析算法占用计算机资源（CPU时间和内存空间）的多少。 1.3.2算法时间性能分析： 1.两种算法时间性能分析： （1）事后统计法：存在两个缺点，一是必须执行程序，二是存在很多因素掩盖了算法的本质。 （2）事前估计法：把算法的执行时间看做问题规模的函数，实际上通常采用事前估算法来分析算法的时间性能 2....
线性表的存储结构
Lnginx的博客
04-20 347
1、线性表存储结构定义顺序存储结构：顺序表就是把线性表中的所有元素按照其逻辑顺序，依次存储到从指定的存储位置开始的一块连续的存储空间中。（顺序表需要提前分配内存，一旦分配好了，对其操作的过程中始终不变）链式存储结构：每个节点不仅包含所存元素的信息，还包含元素之间逻辑关系的信息，如：单链表中前驱节点包含后继节点的地址信息。（链表可以动态分配内存，需要几个节点划分几个节点的内存）2、顺序存储和链式存储...
线性表(逻辑结构)
weixin_39280437的博客
07-12 1552
线性表定义（逻辑结构）值得注意的特性重要术语基本运算创销、增删改查判空、判长、打印输出其它值得注意的点 定义（逻辑结构） 线性表是具有相同数据类型的n个数据元素的有限序列，其中n为表长，当n=0时线性表是一个空表。若用L表示线性表，则一般表示为 几个概念： a_i表示线性表中第i个元素的位序；（程序中下标从零开始） a_0表示线性表的表头元素； a_n表示线性表的表尾元素； 除第一个元素外，每个元素有且仅有一个直接前驱；除最后一个元素外，每个元素有且仅有一个直接后继 值得注意的特性 数据元素同类型、
数据结构-线性表
hyxdashi的博客
03-13 1843
线性表，全名为线性存储结构。线性表的存储数据的方式可以理解为“把所有数据用一根线串起来，在存储到物理空间中”
数据结构总结笔记1：线性表总结
Joye-joy的博客
05-28 1544
最近进行数据结构的复习，并将重点的一些线性表的知识点用图的方式进行总结，以方便进行复习、查看。 在此做一个总结记录。后续会更新上算法程序部分。 1，线性表的知识结构图 1.1线性表定义 线性表是一个具有相同特性的数据元素的有限序列。 相同特性：所有元素属于同一数据类型。 有限：数据元素个数是有限的。 序列：数据元素由逻辑序号唯一确定。一个线性表中可以有相同值的元素。 1....
数据结构——线性表（顺序存储结构）
最新发布
qq_55869380的博客
04-09 1458
利用数组实现的顺序存储的线性表，包含各种操作的具体实现
线性表的逻辑结构与实现分析
理解线性表的逻辑结构特性至关重要，这有助于选择合适的存储结构以优化性能。例如，对于频繁插入和删除操作的场景，链式存储可能是更好的选择；而如果主要需求是快速随机访问，顺序存储则更具优势。 在实际应用中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值