《数据结构》| 顺序表的具体实现（超详细）

最新推荐文章于 2023-01-21 17:25:16 发布
最新推荐文章于 2023-01-21 17:25:16 发布
阅读量443 收藏 4
点赞数 1
分类专栏： 算法与数据结构 文章标签： c++ c语言 数据结构 算法 编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29582443/article/details/116893036
版权

与你相识


博主介绍：

– 本人是普通大学生一枚，每天钻研计算机技能，CSDN主要分享一些技术内容，因我常常去寻找资料，不经常能找到合适的，精品的，全面的内容，导致我花费了大量的时间，所以会将摸索的内容全面细致记录下来。另外，我更多关于管理，生活的思考会在简书中发布，如果你想了解我对生活有哪些反思，探索，以及对管理或为人处世经验的总结，我也欢迎你来找我。

– 目前的学习专注于Go语言，辅学算法，前端领域。也会分享一些校内课程的学习，例如数据结构，计算机组成原理等等，如果你喜欢我的风格，请关注我，我们一起成长。

Introduction

本节主要解决线性表在顺序储存这种物理结构下的具体实现，涉及到静态长度顺序表，可变长度顺序表，时间复杂度分析。

Table of Contents

具体实现就是把数据结构这种结构填充上具体的数据，落在实处了，需要去做一些具体的操作，比如光有加减乘除，没有任何意义，但是加减乘除遇上数字就有了意义，我们我们学习的顺序表这种数据结构就仅仅是一种结构，我们需要让它实际的能够处理问题。

不变长顺序表

#include <iostream>

// 把这种常量都定义一下，这个属于编程规范方面的事情
#define LIST_INIT_SIZE 10

// 定义一个结构体，data表示数据，length表示有多少个元素
typedef struct {
    int data[LIST_INIT_SIZE];
    int length;
} List;

/*
 * 清空一个List
 */
void ClearList(List &L) {
    // 1. length置为0，现在还没有元素
    L.length = 0;
    // 2. 虽然L.data本身就已经开辟了一个LIST_INIT_SIZE大小的空间，但是C语言默认并不会把数组的数据设置为空，里面的数据是乱七八糟的
    // 所以需要我们就遍历一下，把它的所有元素置0
    for (int i = 0; i < LIST_INIT_SIZE; i++) {
        L.data[i] = 0;
    }
}

/*
 * 构造一个空的顺序表
 * char*的返回类型会有不安全的因素，所以我们加上const防止别人进行修改
 */
void InitList(List &L) {
    ClearList(L);
}

/*
 * 销毁一个顺序表，因为我们使用的是静态数组，在程序结束后会被程序自动回收，所以不用销毁
 */
const char *DestroList(List &L) {
    return NULL;
}

/*
 * 判断表是否为空
 */
bool ListEmpty(List L) {
    // 如果为空返回true，如果有值返回false
    return L.length == 0;
}

/*
 * 返回列表的数据元素个数
 */
int ListLength(List L) {
    // 返回列表的length
    return L.length;
}

/*
 * 用e返回L中第i个数据元素的值
 */
void GetElem(List L, int i, int &e) {
    // itoa 将整型值转为字符串
    if (i < 0 || i >= L.length) {
        std::cout << "Get failed. Index is illegal." << std::endl;
        return;
    }
    // 为e赋值
    e = L.data[i];
}

/*
 * 返回L中第1个与e相同的元素在L中的位置，若这样的数据元素不存在，返回值为-1
 */
int LocateElem(List L, int e) {
    for (int i = 0; i < L.length; i++) {
        // 如果找到这个元素了，返回在L中的位置
        if (L.data[i] == e) {
            return i;
        }
    }
    // 如果没有找到，返回-1
    return -1;
}

/*
 * 若cur_e是L的数据元素，且不是第一个，则用pre_e返回其前驱，否则操作失败，pre_e无定义
 */
void PriorElem(List L, int cur_e, int &pre_e) {
    // 查询一下cur_e这个元素的index
    int location = LocateElem(L, cur_e);
    // 如果返回值为-1，说明没找到这个元素，返回错误信息
    if (location == -1) {
        std::cout << "Get failed. The current element not found." << std::endl;
        return;
    }
    // 如果返回值为0，说明这个元素是List第一个元素，没有前驱，返回错误信息。
    if (location == 0) {
        std::cout << "Get failed. The current element is first of the List." << std::endl;
        return;
    }
    // 否则的情况下，就可以赋值前驱的值了
    pre_e = L.data[location - 1];
}

/*
 * 若cur_e是L的数据元素，且不是最后一个，则用next_e返回其后继，否则操作失败，next_e无定义
 */
void NextElem(List L, int cur_e, int &next_e) {
    // 查询一下cur_e这个元素的index
    int location = LocateElem(L, cur_e);
    // 如果返回值为-1，说明没找到这个元素，返回错误信息
    if (location == -1) {
        std::cout << "Get failed. The current element not found." << std::endl;
        return;
    }
    // 如果返回值为length - 1，说明这个元素是List最后一个元素，没有后继，返回错误信息。
    if (location == L.length - 1) {
        std::cout << "Get failed. The current element is last of the List." << std::endl;
        return;
    }
    // 否则的情况下，就可以赋值后继的值了
    next_e = L.data[location + 1];
}

/*
 * 在L中第i个位置之前插入新的数据元素e，L的长度加1
 */
void ListInsert(List &L, int index, int e) {
    // 1. 判断List是否已经满了,如果length == 最大长度的话，说明List已经满了
    if (L.length == LIST_INIT_SIZE) {
        std::cout << "Insert failed. The list is full." << std::endl;
        return;
    }
    // 2. 判断索引是否合法, 首先List未满，此时索引小于0没有意义，或等于length的时候就是在末尾添加元素，超出这个索引没有意义
    if (index < 0 || index > L.length) {
        std::cout << "Insert failed. The index is illegal." << std::endl;
        return;
    }
    // 3. 添加元素
    // 将index ~ length的元素往后移动一位,倒着移动
    for (int i = L.length; i > index; i--) {
        L.data[i] = L.data[i - 1];
    }
    // 4. 将e赋值到index下标
    L.data[index] = e;
    // 5. length + 1
    L.length++;
}

/*
 * 删除L的第i个数据元素，L的长度减1
 */
void ListDelete(List &L, int index) {
    // 1. 判断index是否合法
    if (index < 0 || index >= L.length) {
        std::cout << "Delete failed. The index is illegal." << std::endl;
        return;
    }
    // 2. 删除元素
    for (int i = index; i < L.length; i++) {
        L.data[i] = L.data[i + 1];
    }
    // 3. length --
    L.length--;
}

/*
 * 对线性表L进行遍历，在遍历过程中对L的每个结点访问一次
 */
void TraverseList(List L) {
    if (ListEmpty(L)) {
        // 如果是空表，直接返回
        return;
    }
    // 遍历List
    for (int i = 0; i < L.length; i++) {
        std::cout << L.data[i] << std::endl;
    }
}

变长顺序表

变长顺序表实际上就是控制一下删除和添加元素的时候的策略就可以了。

在我们不变长的顺序表中，如果添加的数据以及满了，会提示错误（不能继续添加），但是在变长顺序表中，如果它满了的话，我们可以给它扩充一些长度，扩充原理：

再创建一个更长的数组，把慢的那个数组的数据移动过来，返回这个更长的数组。

倒没有什么神秘的，其实就是大瓶换小瓶。 但是光扩容可不够，在删除的时候也需要能够锁容，因为如果扩容太多，但是用不上会出现内存的冗余，那这个时候就是小瓶换大瓶。

由于我之前学习的是Java语言版的数据结构，虽然说大家根本上是相似的，但是还是会有一些差异化。

比如实现这个动态数组的方式，C语言就用了一种让我比较迷惑的方式：

C语言的数组长度必须在创建数组的时候就指定，并且是一个常数，系统会分配一个固定大小的空间，这是静态数组。
而动态数组在C语言中有malloc/free的库函数可以分配内存空间，但是分配内存空间之后需要在程序运行结束前完成释放内存的操作，如果程序运行期间分配的内存未释放，就会造成内存空间的浪费，形成所谓的内存泄漏。
而在c++中，使用new/delete关键字（基于malloc/free）也可以实现内存的扩张和释放，不过他们还是有一些细微不同，需要大家去私下了解。

既然我们是使用C语言来写的数据结构，就入乡随俗，如果需要讨论的话，也欢迎私信我，我们一起沟通。

我们本次也使用malloc/free的方式来动态分配空间。

在静态数组的基础上加了扩容和缩容的机制

#include <iostream>
#include <cstdlib>

// 把这种常量都定义一下，这个属于编程规范方面的事情
#define LIST_INIT_SIZE 2

// 定义一个结构体，data表示数据，length表示有多少个元素
typedef struct {
    // 因为扩容机制的原因，我们需要使用*data基址来存储元素
    int *data;
    // 顺序表的元素个数
    int length;
    // 顺序表的最大容量
    int MaxSize;
} List;

/*
 * 清空一个List
 */
void ClearList(List &L) {
    // 1. C语言默认并不会把开辟的内存空间的数据设置为空，里面的数据是乱七八糟的
    // 所以需要我们就遍历一下，把它的所有元素置0
    for (int i = 0; i < L.MaxSize; i++) {
        L.data[i] = 0;
    }
}

/*
 * 当List满的时候，每次扩容1倍
 */
void IncreaseSize(List &L) {
    // 将旧空间存储一份
    int *p = L.data;
    // 开辟新的存储空间，扩容一倍的长度，因为malloc返回的类型是泛型，我们需要把它转换为我们想要的类型
    // 括号里的内容是字节大小，左边是我们想要多少块，右边sizeof(int)是指一块为多少字节，sizeof会算出int的字节数
    L.data = (int *) malloc((L.MaxSize * 2) * sizeof(int));
    // 维护最大容量
    L.MaxSize = L.MaxSize * 2;
    // 将新内存空间置0
    ClearList(L);
    // 把旧有区域的数据转移到新内存空间
    for(int i = 0; i < L.length; i ++){
        L.data[i] = p[i];
    }
    // 释放旧空间的内存
    free(p);
}

/*
 * 每当数据小于等于总大小的1/4的时候，缩容到1/2.
 */
void DecreaseSize(List &L) {
    // 将旧空间存储一份
    int *p = L.data;
    // 开辟新的存储空间，砍掉一半的长度
    L.data = (int *) malloc((L.MaxSize / 2) * sizeof(int));
    // 维护最大容量
    L.MaxSize = L.MaxSize / 2;
    // 将新内存空间置0
    ClearList(L);
    // 把旧有区域的数据转移到新内存空间
    for(int i = 0; i < L.length; i ++){
        L.data[i] = p[i];
    }
    // 释放旧空间的内存
    free(p);
}

/*
 * 构造一个空的顺序表
 */
void InitList(List &L) {
    // 1. 用malloc函数申请一篇连续的存储空间
    L.data = (int *)malloc(LIST_INIT_SIZE * sizeof(int));
    L.length = 0;
    L.MaxSize = LIST_INIT_SIZE;
    // 2. 对申请的内存空间区域置0
    ClearList(L);
}

/*
 * 销毁一个顺序表，因为我们使用的是malloc动态分配，必须需要通过free(指针)手动回收
 */
void DestroList(List &L) {
    free(L.data);
    L.length = 0;
    L.MaxSize = 0;
}

/*
 * 判断表是否为空
 */
bool ListEmpty(List L) {
    // 如果为空返回true，如果有值返回false
    return L.length == 0;
}

/*
 * 返回列表的数据元素个数
 */
int ListLength(List L) {
    // 返回列表的length
    return L.length;
}

/*
 * 用e返回L中第i个数据元素的值
 */
void GetElem(List L, int i, int &e) {
    // itoa 将整型值转为字符串
    if (i < 0 || i >= L.length) {
        std::cout << "Get failed. Index is illegal." << std::endl;
        return;
    }
    // 为e赋值
    e = L.data[i];
}

/*
 * 返回L中第1个与e相同的元素在L中的位置，若这样的数据元素不存在，返回值为-1
 */
int LocateElem(List L, int e) {
    for (int i = 0; i < L.length; i++) {
        // 如果找到这个元素了，返回在L中的位置
        if (L.data[i] == e) {
            return i;
        }
    }
    // 如果没有找到，返回-1
    return -1;
}

/*
 * 若cur_e是L的数据元素，且不是第一个，则用pre_e返回其前驱，否则操作失败，pre_e无定义
 */
void PriorElem(List L, int cur_e, int &pre_e) {
    // 查询一下cur_e这个元素的index
    int location = LocateElem(L, cur_e);
    // 如果返回值为-1，说明没找到这个元素，返回错误信息
    if (location == -1) {
        std::cout << "Get failed. The current element not found." << std::endl;
        return;
    }
    // 如果返回值为0，说明这个元素是List第一个元素，没有前驱，返回错误信息。
    if (location == 0) {
        std::cout << "Get failed. The current element is first of the List." << std::endl;
        return;
    }
    // 否则的情况下，就可以赋值前驱的值了
    pre_e = L.data[location - 1];
}

/*
 * 若cur_e是L的数据元素，且不是最后一个，则用next_e返回其后继，否则操作失败，next_e无定义
 */
void NextElem(List L, int cur_e, int &next_e) {
    // 查询一下cur_e这个元素的index
    int location = LocateElem(L, cur_e);
    // 如果返回值为-1，说明没找到这个元素，返回错误信息
    if (location == -1) {
        std::cout << "Get failed. The current element not found." << std::endl;
        return;
    }
    // 如果返回值为length - 1，说明这个元素是List最后一个元素，没有后继，返回错误信息。
    if (location == L.length - 1) {
        std::cout << "Get failed. The current element is last of the List." << std::endl;
        return;
    }
    // 否则的情况下，就可以赋值后继的值了
    next_e = L.data[location + 1];
}

/*
 * 在L中第i个位置之前插入新的数据元素e，L的长度加1
 */
void ListInsert(List &L, int index, int e) {
    // 1. 判断索引是否合法, 首先List未满，此时索引小于0没有意义，或等于length的时候就是在末尾添加元素，超出这个索引没有意义
    if (index < 0 || index > L.length) {
        std::cout << "Insert failed. The index is illegal." << std::endl;
        return;
    }
    // 2. 判断List是否已经满了,如果length == 最大长度的话，说明List已经满了，要进行扩容
    if (L.length == LIST_INIT_SIZE) {
        IncreaseSize(L);
        std::cout << "The list is increase size, The list Maxsize is ";
        std::cout << L.MaxSize << std::endl;
    }
    // 3. 添加元素
    // 将index ~ length的元素往后移动一位,倒着移动
    for (int i = L.length; i > index; i--) {
        L.data[i] = L.data[i - 1];
    }
    // 4. 将e赋值到index下标
    L.data[index] = e;
    // 5. length + 1
    L.length++;
}

/*
 * 删除L的第i个数据元素，L的长度减1
 */
void ListDelete(List &L, int index) {
    // 1. 判断index是否合法
    if (index < 0 || index >= L.length) {
        std::cout << "Delete failed. The index is illegal." << std::endl;
        return;
    }
    // 2. 删除元素
    for (int i = index; i < L.length; i++) {
        L.data[i] = L.data[i + 1];
    }
    // 3. length --
    L.length--;
    // 4. 判断是否需要缩容,如果需要的话，缩容1/2
    if (L.length <= L.MaxSize / 4) {
        DecreaseSize(L);
        std::cout << "The list is decrease size, The list Maxsize is ";
        std::cout << L.MaxSize << std::endl;
    }
}

/*
 * 对线性表L进行遍历，在遍历过程中对L的每个结点访问一次
 */
void TraverseList(List L) {
    if (ListEmpty(L)) {
        // 如果是空表，直接返回
        return;
    }
    // 遍历List
    for (int i = 0; i < L.length; i++) {
        std::cout << L.data[i] << std::endl;
    }
}

时间复杂度分析

分析顺序存储中静态数组和动态分配的时间复杂度意义不大，但是分析一下顺序表的增删查改时间复杂度，还是很有必要的。

增：O(n)
因为增加一个元素需要把这个元素的后面的所有元素后移一位。

删：O(n)
同样的，删除一个元素，也需要把这个元素后面的元素全部前移

查：O(1)
由于静态数组的内存连续的特性，我们查询一个元素的时候可以直接获取到，所以为O(1)

改：O(1)
同样的，由于内存连续，我们可以直接把某个地址的值改成我们想要的

综上，如果一个地方的查和改的需求很大，增加和删除的需求量很小，就可以使用顺序表这种数据结构了。

欢迎评论区讨论，或指出问题。 如果觉得写的不错，欢迎点赞，转发，收藏。

Jacob_云飞
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
大学笔试专用，计算机数据结构超快星人复习笔记
02-23
这份“大学笔试专用，计算机数据结构超快星人复习笔记”旨在帮助学生在短时间内掌握数据结构的基本概念和重要算法，特别适合应对笔试考试。 首先，笔记强调了对编程思想的理解，这是学习数据结构的基础。编程思想...
易语言超级列表框单击表头实现图片转换
07-22
通过分析和学习这段代码，开发者可以理解具体的实现细节，包括如何处理事件，如何进行数据排序，以及如何更新界面元素。对于初学者来说，这是一个很好的实践案例，能够帮助他们更好地掌握易语言的编程技巧和面向对象...
【数据结构——顺序表的实现】
m0_56069910的博客
01-21 1195
顺序表的具体实现
【数据结构】顺序表的实现——超级无敌详细
qq_59702185的博客
08-07 2012
在当我们每想插入一个数据的时候，我们都要对顺序表进行判断，容量 capacity 是否和 size 相等，如果相等的话，那么，顺序表的空间就不够我们进行插入数据了。当然我们不能需要插入一个数据就开辟一个数据的大小，这样的话，付出的代价很大，我们可以每次增容 2 倍的capacity大小的容量，或者4倍，2倍是比较好的了。在我们想把顺表表最后一个数据删除时，不能直接赋为0，第一，我们不知道SLDataType到底是什么数据类型，第二，顺序表的最后一个数据有可能就是0，没有意义。遍历一遍顺序表，打印顺序表。..
【数据结构】顺序表的实现
学了就忘是正常现象
08-01 1078
【数据结构】顺序表的实现及数组相关oj题
数据结构与算法-顺序表
olunano的博客
01-27 321
文章目录2.顺序表2.1顺序表的基本形式 2.顺序表   在程序中，经常需要将一组（通常是同为某个类型的）数据元素作为整体管理和使用，需要创建这种元素组，用变量记录它们，传进传出函数等。一组数据中包含的元素个数可能发生变化（可以增加或删除元素）。   对于这种需求，最简单的解决方案便是将这样一组元素看成一个序列，用元素在序列里的位置和顺序，表示实际应用中的某种有意义的信息，或者表示数据之间的某种关系。   这样的一组序列元素的组织形式，我们可以将其抽象为线性表。一个线性表是某类元素的一个集合，还记录着元素之
数据结构系列学习（二） - 顺序表（Contiguous_List）
曾铎的博客
10-23 1982
在计算机内部存储一张线性表（线性结构的数表），最为方便简单的就是用一组连续的地址的内存单元来存储整张线性表。这种存储结构称为顺序存储结构。这种存储结构下的线性表就称为顺序表。一张顺序表包括这几个特征：有一个唯一的表名来标识该顺序表；内存单元连续存储，也就是说一张顺序表必须要占据一块连续的内存空间；数据顺序存放，元素之间有先后关系；定义一张顺序表也就是在内存中开辟一段连续的存储空间，同时我们定义的顺序表也应该实现增删查改这四个功能。
数据结构自用超级简单版
09-04
这些基本数据结构的选择和应用取决于具体问题的需求。例如，如果需要快速查找，可能选择哈希表；如果要保持元素的顺序，可能会选择队列或栈；如果要处理层次关系，可能需要用到树或图。 学习数据结构时，除了理解...
java笔记整理(超详细)
07-14
Java不支持类的多重继承，以避免调用歧义，但接口可以实现多重继承，因为接口只规定了方法签名，不包含具体实现。抽象类可以包含非抽象方法，而接口的所有方法默认是public且无实现。一个类可以实现多个接口，但只能...
数据结构（C语言）代码实例21
04-18
“[数据结构(C语言版)].124.pdf”可能是一个详细的教程或参考手册，涵盖了C语言实现的各种数据结构，包括但不限于数组、链表、树、图等。这将提供丰富的背景知识和实践指导。 “函数调用详解 ppt”可能是一个演示...
数据结构顺序表程序清单
10-23
数据结构顺序表是在校大学生的一个课程的必要程序
数据结构顺序表的算法实现
07-06
数据结构中顺序表的C语言程序简单源代码，数据结构顺序表的算法实现
【数据结构】C语言实现顺序表（超级详细）
m0_74459723的博客
01-01 1万+
顺序表作为线性表的一种，它是用一段数据元素的线性结构，一般情况下采用。在数组上完成数据的增删查改。顺序表一般分为：1、静态顺序表——使用定长数组进行存储元素。这种存储方式在存储数据时比较有局限性，当数据存储量非常小的时候，数组长度太长，会造成空间的浪费；当数据存储量非常大的时候，数组空间可能会不够，但是这种存储方式不能进行扩容。所以在实现顺序表时，我们通常使用的是动态顺序表。这样能够提高我们的空间利用率。2、动态顺序表——使用动态开辟的数组进行存储元素。
2.【顺序表】线性表的顺序存储：动态分配代码以及常用函数定义（可直接运行）
Benny_Shlhyr的博客
07-10 241
【顺序表】线性表的顺序存储：动态分配代码以及常用函数定义（可直接运行）运行软件代码展示运行结果 运行软件 C-free5.0 或者 VS C++ 2010 代码展示 #include <stdio.h> #include <stdlib.h> #define Initsize 10 //建立顺序表的动态分配数据类型 typedef struct{ int *data; int maxsize; int length; }SeqList; //初始化函数 void InitL
数据结构——顺序表（C++）
qq_43230771的博客
09-20 176
#include<malloc.h> #include<iostream> #define LIST_INIT_SIZE 100 //线性表存储空间的初始分配量 #define LISTINCREMENT 10 //线性表存储空间的分配增量 using namespace std; //————————————————————顺序表————————————————...
顺序表的类型定义以及基本操作函数
热门推荐
qq_38846633的博客
07-22 1万+
引言 本篇文章是我的处女作，主要是我学习清华大学出版社《数据结构》课程顺序表一节的心得体会，主要内容为对于书本上伪代码的详细实现的补充以及学习，如果有任何错误或可以改进之处欢迎各位巨巨指出 正文 顺序表作为线性结构的一种，而线性结构的特点是：1.存在唯一的一个被称为“第一个”的元素，同时也存在唯一的一个被称为“最后一个”的元素 2、集合之中的每一个元素均有且仅有一个它的前驱或后...
数据结构—顺序表的基本功能实现
qq_42932834的博客
06-05 1463
顺序表的基本功能实现 线性表是数据结构的基础结构。数据结构+算法=程序，今天结束了C++的书本自学，扎进数据结构和算法的世界里。 线性表分为顺序存储，链式存储，索引存储，散列存储等。 顺序存储即顺序表，链式存储即链表。 关于数据结构，最重要的是会画图，明白逻辑结构和物理结构。不急不燥，代码不是一气呵成的，需要长久的练习和耐心。 下面是顺序表的实现代码： #include <iostrea...
数据结构（c语言版）顺序表的实现
ChunkWen的博客
09-12 1639
数据结构原本的书籍上面只写了算法部分，不能直接运行，在此贴上c语言实现的完整代码，需要注意的地方已在代码中注释 #include <stdio.h> #include <malloc.h> #define LIST_SIZE 100//初始分配空间的节点个数 #define LIST_INCREMENT 10//新分配空间的节点个数 typedef int ElemType; typedef struct book{ ElemType* elem;//存储空间基地址 int
蓝桥杯算法:打印图形——六芒星
KeepCodeing
10-13 3334
【输入格式】 输入一行包含一个整数 n。 【输出格式】 输出一个六芒星，表示满足题意的图形。 【样例输入】 3 4 【样例输出】 【评测用例规模与约定】 对于所有评测用例，1 ≤ n ≤ 20。 总结: 第一次做图形题,做了蛮久,图形题有很多的方式去完成,它考验的是你能不能找到更简单的那一种方式. 我初看到这个图形,第一种想法是把这个六芒星当做六个小三角形来做，然后以某种规则排列一下，就能做出来，但是尝试了一下感觉太麻烦了。 然后我的第二种想法是，这个图形是对称图形，怎么能写出一半吗？ 这样另一半想办
王道数据结构栈的链式存储
最新发布
08-26
在王道数据结构书中，可能会对链式存储结构的实现进行详细的介绍，包括节点的定义、插入和删除操作的具体步骤等。如果你需要更详细的信息，建议参考相关章节的内容。<span class="em">1 #### 引用[.reference_title]...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Jacob_云飞

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值