C语言-数据结构之线性表：顺序表和单链表

于 2023-07-20 20:15:23 发布
阅读量272 收藏 1
点赞数 2
分类专栏： 数据结构篇 文章标签： 数据结构 链表 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73849311/article/details/131837148
版权

目录

 不废话，直接开始 ！

一、顺序表（seqList）

顺序表使用数组实现，它具有以下特点：

  • 内存连续：顺序表中的元素在内存中是连续存储的，这使得顺序表的访问操作非常高效。
  • 随机访问：由于元素在内存中的位置与其在逻辑上的顺序相对应，可以通过下标快速访问任意位置的元素。
  • 大小可变：顺序表的大小可以根据需求进行动态调整，可以方便地插入或删除元素。
  • 遍历方便：由于内存连续，遍历顺序表的元素只需要按顺序依次访问即可。

首先定义一个结构体类型SeqList，并给其指针起一个别名为List：

typedef int E;   // 元素类型

struct SeqList{
    E * array;      //底层数组
    int capacity;   // 容量
    int size;       //表长
};

typedef struct SeqList* List;  // 顺序表指针别名

顺序表初始化：


bool initList(List list){
    //动态分配一个包含 10 个元素的数组空间
    list->array= malloc(sizeof(E)*10); 
    //动态分配内存失败，退出程序
    if(list==NULL) return 0;
    list->capacity=10;
    list->size=0;
    return 1;
}

顺序表插入元素：

/*
 * 索引index合法范围 [1,size]
 * 元素在数组插入下标 index-1
 */
bool insertList(List list,E element ,int index){
    //检查索引范围
    if(index<1 || index>list->size+1) return 0;
    //若数组空间已满，则将容量变为原来的1.5倍
    if(list->size==list->capacity){
        int newCapacity=list->capacity+(list->capacity>>1);
        //使用realloc函数为array重新分配内存
        E * newArray= realloc(list->array,sizeof(E) * newCapacity);
        //分配内存失败，退出程序
        if(newArray==NULL) return 0;
        list->array=newArray;
        list->capacity=newCapacity;
    }
    //插入位置后面的元素依次向右移动
    for (int i = list->size; i >=index ; --i)
        list->array[i]=list->array[i-1];
    //将元素放到指定索引处
    list->array[index-1]=element;
    list->size++;
    return 1;
}

顺序表删除元素：

/*
 * 索引index合法范围 [1,size]
 * 元素在数组中删除的下标 index-1
 */
bool deleteList(List list, int index){
    //检查索引范围
    if(index<1 || index>list->size) return 0;
    //插入位置后面的元素依次向前移动，覆盖下标为index-1处元素
    for (int i = index; i < list->size ; ++i) {
        list->array[i-1]=list->array[i];
    }
    list->size--;
    return 1;
}
顺序表查找元素： 
/*
 * element为需要查找的元素
 * 返回值为元素对应的索引
 */
int findList(List list ,E element){
    for (int i = 0; i < list->size; ++i)
        //返回的是对应的索引位置，而不是对应的数组下标
        if(list->array[i]==element) return i+1;
    return -1;  //未找到元素，返回-1
}

 顺序表修改元素：


bool setList(List list,int index,E element){
    //检查索引范围
    if(index<1 || index>list->size) return false;
    list->array[index-1]=element;
    return true;
}

主程序main：

int main(){
    struct SeqList list;
    if(initList(&list)){
        for (int i = 1; i < 10; ++i)
            insertList(&list, i, i);
        printArrayList(&list);
        printf("%d\n",*getList(&list,2));  //返回第二个元素
        printf("%d\n",findList(&list,5));  //返回元素 5 对应的索引
        printf("%d",sizeList(&list));      //返回表长
        clearList(&list);
    }
}

seqList实现代码：


#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
typedef int E;   // 元素类型

struct SeqList{
    E * array;      //底层数组
    int capacity;   // 容量
    int size;       //表长
};

typedef struct SeqList* List;  // 指针别名

bool initList(List list){
    list->array= malloc(sizeof(E)*10);
    if(list==NULL) return 0;
    list->capacity=10;
    list->size=0;
    return 1;
}

void printArrayList(List list){
    for (int i = 0; i < list->size; ++i)
        printf("%d ",list->array[i]);
    printf("\n");
}

/*
 * 索引合法范围 [1,size]
 */
bool insertList(List list,E element ,int index){
    if(index<1 || index>list->size+1) return 0;
    if(list->size==list->capacity){
        int newCapacity=list->capacity+(list->capacity>>1);
        E * newArray= realloc(list->array,sizeof(E) * newCapacity);
        if(newArray==NULL) return 0;
        list->array=newArray;
        list->capacity=newCapacity;
    }
    for (int i = list->size; i >=index ; --i)
        list->array[i]=list->array[i-1];
    list->array[index-1]=element;
    list->size++;
    return 1;
}

/*
 * 索引合法范围 [1,size]
 */
bool deleteList(List list, int index){
    if(index<1 || index>list->size) return 0;
    for (int i = index; i < list->size ; ++i) {
        list->array[i-1]=list->array[i];
    }
    list->size--;
    return 1;
}

void destroyList(List list){
    if(list==NULL) return;
    free(list->array);
    free(list);
}

E * getList(List list,int index){
    return &list->array[index-1];
}

bool setList(List list,int index,E element){
    if(index<1 || index>list->size) return false;
    list->array[index-1]=element;
    return true;
}

int findList(List list ,E element){
    for (int i = 0; i < list->size; ++i)
        if(list->array[i]==element) return i+1;
    return -1;
}

bool isEmptyList(List list){
    return list->size == 0;
}

bool isFullList(List list){
    return list->size == list->capacity;
}

int getCapacityList(List list){
    return list->capacity;
}

int sizeList(List list){
    return list->size;
}

bool setCapacityList(List list,int newCapacity){
    if(list->size > newCapacity && newCapacity > list->capacity)
        return false;
    int* newArray= realloc(list->array,sizeof(E)*newCapacity);
    if(newArray == NULL) return false;
    list->array=newArray;
    list->capacity=newCapacity;
    return true;
}

void clearList(List list){
    list->size=0;
}

int main(){
    struct SeqList list;
    if(initList(&list)){
        for (int i = 1; i < 10; ++i)
            insertList(&list, i, i);
        printArrayList(&list);
        printf("%d\n",*getList(&list,2));  //返回第二个元素
        printf("%d\n",findList(&list,5)); //返回元素 5 对应的索引;
        printf("%d",sizeList(&list)); //返回表长
        clearList(&list);
    }
}

二、单链表（singlyList）

单链表使用指针实现，它具有以下特点：

  • 链式结构：单链表由一系列节点组成，每个节点包含数据域和指针域。通过指针将节点连接起来形成链式结构。

  • 动态分配内存：单链表的节点是通过动态分配内存来创建的，可以根据需要动态增加或删除节点，不需要预先分配固定大小的内存空间。

  • 插入和删除高效：相比于顺序表（数组）实现，单链表在插入和删除操作上更高效。插入或删除一个节点只需要修改相邻节点的指针，时间复杂度为 O(1)。

  • 无需移动元素：在单链表中插入和删除节点时，不需要移动其他节点，只需要修改对应节点的指针即可。

  • 随机访问较慢：由于单链表无法直接访问任意位置的节点，需要从头节点开始依次遍历到目标位置，因此索引定位节点的时间复杂度为 O(n)，效率较低。

首先定义一个结构体类型SinglyList，并给其指针起一个别名为List
              一个结构体类型ListNode， 并给其指针起一个别名为Node

typedef int E;

//带头结点的单链表，即头结点不存储数据

struct ListNode{
    E element;               //数据域
    struct ListNode * next;  //指针域
};

struct SinglyList{
    struct ListNode* head;  //头指针
    struct ListNode* tail;  //尾指针
    int size;
};

typedef struct SinglyList * List;  //别名

typedef struct ListNode * Node;    //别名

单链表初始化：

/*
* malloc函数为头、尾指针分配内存空间，他们的大小为结构体
* struct ListNode的字节大小
*/
void initList(List list){
    list->head= malloc(sizeof (struct ListNode));
    list->tail= malloc(sizeof (struct ListNode));
    list->head->next=list->tail->next=NULL;
    list->size=0;
}

单链表插入元素：


/*
 * 索引的合法插入范围 [1,size+1]，即包含了首插入、尾插入
 */
bool insertList(List list, E element, int index){
    Node head=list->head;
    //检查索引范围
    if(list==NULL || index<1 || index>list->size+1) return 0;
    //为插入节点动态分配内存
    Node newNode= malloc(sizeof (struct ListNode));
    newNode->element=element;
    //首先空表时插入，表长为0
    if(list->head->next==NULL){
        list->tail->element=element;
        head->next=list->tail;
        list->tail->next=NULL;
        list->size++;
        return 1;
    }
    //其次是首插入，但表长不为0
    if(index==1){
        newNode->next=head->next;
        head->next=newNode;
        list->size++;
        return 1;
    }
    //再其次是尾插入，但表长不为0
    if(index==list->size+1){
        list->tail->next=newNode;
        newNode->next=NULL;
        list->tail=newNode;
        list->size++;
        return 1;
    }
   //再再其次是中间插入 索引范围：[2,size]
    Node front=head;
    while (index>1){
        front=front->next;
        index--;
    }
    head=front->next;
    front->next=newNode;
    newNode->next=head;
    list->size++;
    return 1;
}

单链表删除元素：

/*
 * 索引的合法删除范围 [1,size]
 */
bool deleteList(List list, int index){
    Node head=list->head;
    //索引合法检查，表为空检查
    if(head==NULL || index<1 || index>list->size) return 0;
    Node front=head;
    while (index>1){
        front=front->next;
        index--;
    }
    head=front->next;
    if(head==NULL){
        front->next=NULL;
        return 1;
    }
    Node temp=head;
    front->next=front->next->next;
    free(temp);//释放被删除节点的内存
    list->size--;
    return 1;
}

单链表查找元素：


/*
 * 返回元素的索引 索引合法范围 [1,size]
 */
int findList(List list, E element){
    Node head=list->head;
    if(head==NULL) return 0;
    Node node=head->next;
    int i=1;
    while(node!=NULL){
        if(node->element==element)
            return i;
        node=node->next;
        i++;
    }
    return -1;
}

单链表修改元素：


/*
 *  索引合法范围 [1,size]
 */
void setList(List list,E element, int index) {
    Node head=list->head;
    if (head == NULL || index < 1)
        return;
    Node front = head;
    while (index > 1) {
        front = front->next;
        index--;
    }
    head = front->next;
    if (head != NULL)
        head->element=element;
}

主程序main：

int main() {
    struct SinglyList singlyList;
    initList(&singlyList);
    for (int i = 1; i <= 10; ++i) {
        insertList(&singlyList, i * 100, i);//尾插入
    }
    setList(&singlyList,0,1); //修改第一个元素
    insertList(&singlyList,0,5); //中间插入
    deleteList(&singlyList, 3);   //删除第三个元素
    printList(&singlyList);
    printf("\n");
    printf("%d\n", sizeList(&singlyList));  //表长
    printf("%d\n ", getList(&singlyList,2));  //返回第二个元素
    printf("%d ", findList(&singlyList,500));  // 返回500对应的索引
}

singlyList实现代码：


#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

typedef int E;

//带头结点的单链表，头结点不存储数据

struct ListNode{
    E element;
    struct ListNode * next;
};

struct SinglyList{
    struct ListNode* head;
    struct ListNode* tail;
    int size;
};

typedef struct SinglyList * List;

typedef struct ListNode * Node;

void initList(List list){
    list->head= malloc(sizeof (struct ListNode));
    list->tail= malloc(sizeof (struct ListNode));
    list->head->next=list->tail->next=NULL;
    list->size=0;
}

/*
 * 索引的合法插入范围 [1,size+1]，即包含了首插入、尾插入
 */
bool insertList(List list, E element, int index){
    Node head=list->head;
    if(list==NULL || index<1 || index>list->size+1) return 0;
    Node newNode= malloc(sizeof (struct ListNode));
    newNode->element=element;
    //首先空表时插入，表长为0
    if(list->head->next==NULL){
        list->tail->element=element;
        head->next=list->tail;
        list->tail->next=NULL;
        list->size++;
        return 1;
    }
    //其次是首插入，但表长不为0
    if(index==1){
        newNode->next=head->next;
        head->next=newNode;
        list->size++;
        return 1;
    }
    //再其次是尾插入，但表长不为0
    if(index==list->size+1){
        list->tail->next=newNode;
        newNode->next=NULL;
        list->tail=newNode;
        list->size++;
        return 1;
    }
   //再再其次是中间插入 索引范围：[2,size]
    Node front=head;
    while (index>1){
        front=front->next;
        index--;
    }
    head=front->next;
    front->next=newNode;
    newNode->next=head;
    list->size++;
    return 1;
}

/*
 * 索引的合法删除范围 [1,size]
 */
bool deleteList(List list, int index){
    Node head=list->head;
    if(head==NULL || index<1 || index>list->size) return 0;
    Node front=head;
    while (index>1){
        front=front->next;
        index--;
    }
    head=front->next;
    if(head==NULL){
        front->next=NULL;
        return 1;
    }
    Node temp=head;
    front->next=front->next->next;
    free(temp);//释放被删除节点的内存
    list->size--;
    return 1;
}

/*
 * 返回元素 索引的合法范围 [1,size]
 */
E getList(List list, int index) {
    Node head=list->head;
    if (head == NULL || index < 1)
        return 0;
    Node front = head;
    while (index > 1) {
        front = front->next;
        index--;
    }
    head = front->next;
    if (head != NULL) {
        int element = head->element;
        return element;
    }
    return 0;
}

/*
 *  索引合法范围 [1,size]
 *
 */
void setList(List list,E element, int index) {
    Node head=list->head;
    if (head == NULL || index < 1)
        return;
    Node front = head;
    while (index > 1) {
        front = front->next;
        index--;
    }
    head = front->next;
    if (head != NULL)
        head->element=element;
}
/*
 * 返回元素的索引 索引合法范围 [1,size]
 */
int findList(List list, E element){
    Node head=list->head;
    if(head==NULL) return 0;
    Node node=head->next;
    int i=1;
    while(node!=NULL){
        if(node->element==element)
            return i;
        node=node->next;
        i++;
    }
    return -1;
}

int sizeList(List list){
    Node head=list->head;
    //因为头结点没有存储数据
    int resSize=-1;
    Node node = head;
    while(node!=NULL){
        node=node->next;
        resSize++;
    }
    return resSize;
//    return list->size; 注意，此处也可直接返回维护的表长，无需遍历节点
}

void printList(List list){
    Node head=list->head;
    Node node = head->next;
    while(node!=NULL){
        //while循环条件中的node!=NULL等价于node
        printf("%d ",node->element);
        node=node->next;
    }
}

int main() {
    struct SinglyList singlyList;
    initList(&singlyList);
    for (int i = 1; i <= 10; ++i) {
        insertList(&singlyList, i * 100, i);//尾插入
    }
    setList(&singlyList,0,1); //修改第一个元素
    insertList(&singlyList,0,5); //中间插入
    deleteList(&singlyList, 3);   //删除一下第三个元素
    printList(&singlyList);
    printf("\n");
    printf("%d\n", sizeList(&singlyList));
    printf("%d\n ", getList(&singlyList,2));
    printf("%d ", findList(&singlyList,500));
}

总结

  顺序表适用于元素频繁访问和随机访问的场景，但当需要频繁插入或删除元素时，顺序表的效率较低，因为在插入或删除操作后需要移动其他元素。在这种情况下，可以考虑使用链表等其他数据结构来代替顺序表。

单链表通过使用指针实现了灵活的链式结构，允许动态添加和删除节点，但随机访问效率较低。它在插入和删除操作频繁的情况下表现出较高的效率。

以上就是今天要讲的内容，感谢各位看官老爷的捧场。

shenjian~
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
线性表的顺序存储结构及操作的实现
m0_56804824的博客
01-05 2119
要求：利用书本上的线性表的顺序存储结构定义： 1）编写完成下列功能的函数：（1）初始化一个线性表；（2）在已经初始化的基础上，创建一个包含15个不大于100的正整数值的线性表（15个值由计算机随机产生）；（3）将一个数x插在第i个元素前（x和i在程序运行时输入）；（4）删除第i个元素（i在程序运行时输入），并在删除结束后输出删除元素的值；（5）查找给定值x是否在线性表中（x在程序运行时输入），若在，输出x在线性表中第一次出现的位置，若不在就输出x不在表中的提示；（6）输出线性表中所有元素。 2）要求编一
数据结构：顺序表与单链表区别
qiuxiaonao的博客
05-15 1862
顺序表与单链表区别（以不定长顺序表和带头结点单链表为例） 不定长顺序表： 单链表（带头结点）： 线性表分为顺序表和链表 顺序表： 1.顺序存储，必须占用一片连续存储单元； 可将顺序表简单理解为数组，其空间是连续的储存单元。 elem是指向顺序表内存地址的指针，listsize是顺序表总大小，length为当前存放有效数据个数。若在末尾插入数据8，只能在下标4处插入，不能中间空几个存储单元插入数据。 2.不便插入删除数据（插入删除位置及后面数据需要均向后或前移动一位）,除了尾插尾删（不用移动）； 例如在上
[数据结构]链表之单链表（详解）
m0_63123468的博客
03-28 1万+
[数据结构]链表之单链表的详细解析
main2-01~2-08.cpp 线性表检验主程序
dfreng的专栏
10-19 601
 // main2-6.cpp 检验bo2-6.cpp的主程序  #include"c1.h"  typedef int ElemType;  #include"c2-5.h"  #include"bo2-6.cpp"  #include"func2-3.cpp" // 包括equal()、comp()、print()、print2()和print1()函数
algo2-01~2-13.cpp 线性表-主程序的实现
dfreng的专栏
10-19 1106
 // algo2-9.cpp 尽量采用bo2-31.cpp中的基本操作实现算法2.17的功能  #include"c1.h"  #define N 2  typedef char ElemType;  #include"c2-3.h"  #include"func2-2.c
顺序表(数组)和单链表的区别
qq_52276036的博客
08-24 5310
1.存储形式上的区别: 顺序表在物理上和逻辑上都是连续的 单链表在物理上时不连续的，逻辑上是连续的 2.空间上的区别： （1）顺序表一般有固定的空间大小，当空间不够时需要进行扩容，扩容时往往不能准确知道需要扩容的空间大小，很容易造成会造成空间浪费 （2）单链表用一个空间申请一个空间，相比顺序表不那么浪费空间(并不是完全不浪费） 总结：在存储数据时，如果知道具体空间大小，就用顺序表进行存储 不知道具体空间大小，就用单链表 3.时间上的区别： （1）随机插入元素，删除元素的时间复杂度： 顺序表：时间复杂度为O(
(数据结构C语言版)顺序表和单链表的逆置.docx
07-07
顺序表和单链表是两种常用的数据结构，它们的逆置操作是数据结构课程中的一项重要内容。 顺序表是一种具有固定大小的线性表，也称作数组。它的每个元素都占有固定的存储空间，元素之间的存储顺序和逻辑顺序是一致的...
c语言数据结构线性表实验（包括顺序表和链表）
11-28
c语言数据结构线性表实验（包括顺序表和链表）
python数据结构之线性表的顺序存储结构
09-20
线性表是计算机科学中一种基础且重要的数据结构，它是由n（n≥0）个相同类型元素构成的有限序列。在Python中实现线性表的顺序存储结构，即使用数组来存储线性表的元素，这是因为Python的列表本质上就是动态数组，...
数据结构与算法-链表（线性表的链表表示和实现） 定义线性表节点的结构.pdf
04-18
链表数据结构和算法实现 链表是一种线性表的链式表示和实现，定义线性表节点的结构。链表的内存结构是不连续的内存空间，是将一组零散的内存块串联起来，从而进行数据存储的数据结构。一个链表有很多个节点，各个...
c语言数组指定位置插入和删除-玩转C语言链表，单链表双向链表的建立遍历插入删除... 数组和链表.pdf
04-18
C语言数组指定位置插入和删除-玩转C语言链表，单链表双向链表的建立遍历插入删除... 本文主要讲解了C语言中数组和链表的概念及操作，包括数组指定位置插入和删除、链表的结构、静态链表和动态链表、单链表的建立和...
单链表和顺序表
choudan8888的博客
05-13 2230
顺序表：顺序表是在计算机内存中以数组的形式保存的线性表，是以段内存连续的存储数据元素的现性结构，只要确定了起始位置的地址，后面的元素就会连续的存储在起始地址之后。 链表：链表是一种链式存取的数据结构，链式存储的的数据元素的地址在内存中是任意的。它的数据是以结点来存储的，还需要一个指针来将所有的结点连接起来。 单链表的代码如下： typedef class Node { public: i...
第二章 线性表之顺序表（一）
nianqingren_的博客
11-13 260
第二章 线性表(一） 1、 线性表的基本概念 ​  线性表定义：线性表是具有相同数据类型的n个数据元素的有序序列，其中n为表常，当n=0时即为空表，一般表示为： L=(a1,a2,a3,a4,....,ai,ai+1..,an) L = (a_1,a_2,a_3,a_4,....,a_i,a_{i+1}..,a_n) L=(a1​,a2​,a3​,a4​,....,ai​,ai+1​..,an​) ​  其中aia_iai​表示的就是数据结构中的数据元素，它是由多个数据项所构成，表示的是第i个元素，这个
链表和顺序表的一些区别
斜阳雨陌
07-03 1万+
顺序表与链表是非常基本的数据结构，它们可以被统称为线性表。 线性表（Linear List）是由 n（n≥0）个数据元素（结点）a[0]，a[1]，a[2]…，a[n-1] 组成的有限序列。 顺序表和链表，是线性表的不同存储结构。它们各自有不同的特点和适用范围。针对它们各自的缺点，也有很多改进的措施。 一、顺序表 顺序表一般表现为数组，使用一组地址连续的存储单元依次存储数据元素
顺序链表与单链表
hy_honor的博客
03-29 311
顺序链表与单链表优缺点（C语言） 顺序链表存储结构：用地址来表示两个相邻元素之间的逻辑关系，可随机存取，但是插入与删除，移动元素太多浪费时间，但是修改、查找速度要比单链表快得多。且顺序链表要事先给定一块空间，容易造成空间的浪费。 //顺序表的定义 typedef struct SequList { datetype listsize;//最大长度 datetype length;//实际长度 ...
链表：顺序链表和单链表
Runner2012的专栏
10-27 4217
在学习线性表之前，必须要清楚“顺序存储的线性表”和“链式存储的线性表”。 （1）顺序存储线性表         1、采用数组来存储顺序线性表的各元素。         2、基本结构： #define MAXSIZE 20 typedef int Elemtype; typedef struct { Elemtype data[MAXSIZE]; //采用数组存储线性表
线性表之顺序表与单链表的区别及优缺点
热门推荐
ljx_5489464的博客
03-23 3万+
这里比较的是基于C语言实现的顺序表与单链表，与其他语言的实现可能会有差异，但我相信语言是相通的，它们的实现机制应该也差不多。 1、What 什么是顺序表和单链表 ①顺序表： 顺序表是在计算机内存中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。只要确定了起始位置，表中任一元素的地址都通过下列公式得到：LOC（ai）=LOC（a1）+（i-1）*L 　1≤i≤
【数据结构】顺序表和单链表的区别
卑微楽的开发之路
10-02 315
我们前两篇已经自助实现了顺序表和链表,那么我们现在来看一下它们的区别 顺序表 单链表 随机访问 支持 ...
C语言 顺序表和链表的区别与总结
e我所欲也的博客
12-13 1670
顺序表和链表的区别和联系 顺序表 特点：空间连续、支持随机访问 缺点 1. 中间/头部的插入删除，时间复杂度为O(N) 2. 增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。 3. 增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。 而链表的结构就正好解决了这些问题 链表...
数据结构线性表试验报告.pdf
最新发布
11-12
总的来说，本次实验旨在帮助学生更好地理解数据结构线性表的基本逻辑结构和存储结构，并通过实际操作熟练掌握顺序表和单链表的基本运算，使学生能够灵活运用所学知识解决实际问题。通过本次实验，学生不仅能够掌握...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

shenjian~

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

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

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

打赏作者

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

抵扣说明：

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

余额充值