动态数组和链表优缺点以及代码实现（C语言）

原创 已于 2025-07-14 19:11:47 修改 · 900 阅读 · 8 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
收录于
数据结构和算法

当前文章被收录于：

数据结构和算法
2 篇文章 0 人学习
订阅专栏 查看详情
于 2025-07-11 20:07:11 首次发布

1. 动态数组

1.1 优点

  • 查找容易（通过下标），时间复杂度为O(1)。不需要额外申请或删除空间。
  • 使用下标位置索引(index)十分高效的访问任意元素，修改快

1.2 缺点 

  • 插入、删除元素难，效率低。（需要移动大量元素以使元素空间连续）。
  • 插入操作平均需要移动n/2个元素。
  • 删除操作平均需要移动(n-1)/2个元素。
  • 扩展相对繁琐。一方面需要确保能提供更大区域的连续内存空间，另一方面需要将原有数据复制到新的顺序表中。

1.3 代码实现动态数组 

通过指针和动态内存分配来实现动态数组，常见的内存分配函数包括：malloc()，calloc()，realloc()以及free().

为了提高代码的可读性和灵活性（比如：将int类型变为double，char，struct类型），使用typedef 来为类型取一个别名，这样方便将来类型的更改！！！

typedef int element_t;
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

typedef int element_t;

typedef struct{
    element_t *data;
    size_t capacity;
    size_t size;
} DynamicArray;

// 判断结构体数组是否为NULL
bool checkIsNULL(DynamicArray *array)
{
    if (array == NULL){
        printf("结构体数组为NULL！\n");
        return false;
    }
    return true;
}

// 初始化
void initDynamicArray(DynamicArray *array, size_t initCapacity)
{
    if (!checkIsNULL(array)) return false;

    array->data = (element_t *)malloc(sizeof(element_t) * initCapacity);
    if (array->data == NULL){
        printf("动态数组分配失败！\n");
        exit(EXIT_FAILURE);
    }
    array->capacity = initCapacity;
    array->size = 0;
}

// 销毁动态分配的内存
void desDynamicArray(DynamicArray *array)
{
    if (!checkIsNULL(array)) return false;

    if (array->data == NULL){
        return;
    }

    free(array->data);
    array->data = NULL;
    array->capacity = 0;
    array->size = 0;
}

// 获取动态数组元素的个数
size_t getDynamicArrayLength(DynamicArray *array)
{
    if (!checkIsNULL(array)) return false;

    return array->size;
}

// 扩容
bool changeCapacity(DynamicArray *array, size_t newCapacity)
{
    if (!checkIsNULL(array)) return false;

    element_t *newData = (element_t *)realloc(array->data, newCapacity * sizeof(element_t));
    if (newData == NULL){
        printf("扩容失败！\n");
        return false;
    }

    array->data = newData;
    array->capacity = newCapacity;

    return true;
}

// 插入元素
void insertAt(DynamicArray *array, size_t index, element_t *element)
{
    if (!checkIsNULL(array)) return false;

    if (index < 0 || index > array->size){
        printf("不允许在 %zu 的位置插入元素！\n", index);
        return;
    }

    if (array->size == array->capacity){
        if (changeCapacity(array, array->capacity * 2) == false)
            return;
    }

    for (size_t i = array->size; i > index; i++){
        array->data[i] = array->data[i - 1];
    }

    array->data[index] = *element;
    array->size++;
}

// 在末尾插入元素
void insertEnd(DynamicArray *array, element_t *element)
{
    if (!checkIsNULL(array)) return false;

    insertAt(array, array->size, element);
}

// 打印动态数组中的所有元素
void PrintArray(DynamicArray *array)
{
    if (!checkIsNULL(array)) return false;

    for (size_t i = 0; i < array->size; i++){
        printf("%d ", array->data[i]);
    }

    printf("\n");
}

// 删除指定位置的元素
bool deletedAt(DynamicArray *array, size_t index, element_t *deletedElement)
{
    if (!checkIsNULL(array)) return false;

    if (index < 0 || index >= array->size){
        printf("不允许删除 %zu 位置的元素！\n", index);
        return false;
    }

    *deletedElement = array->data[index];

    for (size_t i = index; i < array->size - 1; i++){
        array->data[i] = array->data[i + 1];
    }

    array->size--;

    return true;
}

// 删除末尾的元素
bool deletedEnd(DynamicArray *array, element_t *deletedElement)
{
    if (!checkIsNULL(array)) return false;

    return deletedAt(array, array->size - 1, deletedElement);
}

// 修改指定位置的元素
void updateDynamicArrayElement(DynamicArray *array, size_t index, element_t *element)
{
    if (!checkIsNULL(array)) return false;

    if (index < 0 || index >= array->size){
        printf("不允许修改 %zu 位置的元素！\n", index);
        return;
    }

    array->data[index] = *element;
}

// 得到指定位置的元素
element_t getValue(DynamicArray *array, size_t index)
{
    if (!checkIsNULL(array)) return false;

    if (index < 0 || index >= array->size){
        printf("不允许获取 %zu 位置的元素！\n", index);
        return -1;
    }

    return array->data[index];
}

int main()
{
    DynamicArray array;
    initDynamicArray(&array, 4);

    element_t a = 20, b = 30;
    insertEnd(&array, &a);

    insertAt(&array, 1, &b);

    printf("当前动态数组中的元素的个数为：%d \n", getDynamicArrayLength(&array));
    PrintArray(&array);

    element_t deletedEndElement;
    bool resEnd = deletedEnd(&array, &deletedEndElement);
    if (resEnd == true)
        printf("被删除的元素为：%d\n", deletedEndElement);

    element_t deletedAtElement;
    bool resAt = deletedAt(&array, 0, &deletedAtElement);
    if (resAt == true)
        printf("被删除的元素为：%d\n", deletedAtElement);
    printf("当前动态数组中的元素的个数为：%d \n", getDynamicArrayLength(&array));
    PrintArray(&array);
    
    desDynamicArray(&array);
    return 0;
}

2. 链表

2.1 优点

  • 插入和删除操作效率高。
  • 动态扩展性能更好，链表不需要像数组那样预先指定固定的大小，而是可以随时动态的增长或缩小。链表是真正的动态数据结构，不需要处理固定容量的问题。

2.2 缺点

  • 查找慢。由于链表中的结点不是连续存储的，无法像数组一样根据索引直接计算出每个结点的地址。必须从头结点开始遍历链表，直到找到目标结点，这导致了链表的随机访问效率较低。

  • 额外的存储空间。链表的每个结点都需要存储指向下一个结点的指针，这会占用额外的存储空间。所以，相比于数组，链表需要更多的内存空间来存储相同数量的数据元素。

2.3 链表的特点与实现要点总结

2.3.1 链表的基本特性

  • 内存不连续：链表的节点在内存中是离散分布的，不需要像动态数组那样占用一块连续的空间。
  • 无需扩容：由于每个节点都是独立分配的，因此链表不需要扩容操作。
  • 依赖动态内存管理：链表中的每个节点都需要通过 malloc 或类似方式动态申请内

2.3.2 链表节点结构体的设计

链表的每个节点必须包含两个部分：

  • 数据域（data）：用于存储当前节点的数据。
  • 指针域（next）：指向下一个节点的地址。
typedef struct Node {
    int data;           // 当前节点的数据
    struct Node *next;  // 指向下一个节点的指针
} Node;

注意：

  • 结构体内部不能省略自身的类型名（如 struct Node），否则无法正确声明指向下一个节点的指针。
  • 不建议使用 void* 存储任意类型数据，除非你正在实现一个通用链表库。

2.3.3 链表结构体的设计

为了方便管理和操作链表，通常会封装一个链表结构体，包含以下两个核心字段：

  • 头节点指针（head）：指向链表的第一个节点。
  • 当前节点个数（size）：记录链表中有效节点的数量。
typedef struct {
    Node *head;     // 头节点指针
    size_t size;    // 当前链表中的节点数量
} LinkedList;

2.3.4 实现链表的关键操作（实现链表时，需要特别注意）

2.4 代码实现链表（单向链表） 

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

typedef int element_t;

// 定义节点
typedef struct Node
{
    element_t data;
    struct Node *next;
} Node;

// 定义链表结构体
typedef struct
{
    Node *head;
    size_t size;
} LinkedList;

void isLinkedListNull(LinkedList *list)
{
    if (list == NULL){
        printf("链表为空！\n");
        return;
    }
}

// 初始化链表
void initLinkedList(LinkedList *list)
{
    isLinkedListNull(list);

    list->head = NULL;
    list->size = 0;
}

// 销毁动态分配的内存
void destoryLinkedList(LinkedList *list)
{
    isLinkedListNull(list);

    Node *currentNode = list->head;
    while (currentNode != NULL)
    {
        Node *destoryNode = currentNode;
        currentNode = currentNode->next;

        free(destoryNode);
    }

    list->head = NULL;
    list->size = 0;
}

// 获取上一个节点
Node *getPrevNode(LinkedList *list, size_t index)
{
    if (index <= 0 || index > list->size){
        printf("索引 %zu 不被允许进行接下的操作！\n", index);
        return NULL;
    }

    Node *prevNode = list->head;
    for (int i = 1; i < index; i++){
        prevNode  = prevNode->next;
    }
    return prevNode;
}

// 插入数据
void insertAt(LinkedList *list, size_t index, element_t element)
{
    isLinkedListNull(list);

    if (index < 0 || index > list->size){
        printf("不允许在 %zu 位置插入结点！\n", index);
        return;
    }

    Node *newNode = (Node *)malloc(sizeof(Node));
    if (newNode == NULL){
        printf("动态内存分配失败！\n");
        exit(EXIT_FAILURE);
    }
    newNode->data = element;
    newNode->next = NULL;

    if (index == 0){
        // 将新节点指向头节点的地址
        newNode->next = list->head;

        list->head = newNode;
    }
    else{
        // 获取上一个节点
        Node *prevNode = getPrevNode(list, index);
        newNode->next = prevNode->next;
        prevNode->next = newNode;
    }
    
    list->size++;
}

// 尾端插入节点
void insertEnd(LinkedList *list, element_t element)
{
    isLinkedListNull(list);

    insertAt(list, list->size, element);
}

// 获取当前的节点
Node *getCurrentNode(LinkedList *list, size_t index)
{   
    if (index >= list->size){
        printf("索引 %zu 不被允许进行接下的操作！\n", index);
        return NULL;
    }

    Node *currentNode = list->head;
    for (int i = 1; i <= index; i++){
        currentNode  = currentNode->next;
    }
    return currentNode;
}

// 指定位置删除数据，并且将删除的数据保存
void deletedAt(LinkedList *list, size_t index, element_t *deletedElement)
{
    isLinkedListNull(list);

    if (index < 0 || index >= list->size){
        printf("不允许在 %zu 位置删除节点！\n", index);
        return;
    }

    Node *deletedNode;
    Node *prevNode;

    if (index == 0){
        deletedNode = list->head;
        list->head = list->head->next;
    }
    else{
        prevNode = getPrevNode(list, index);
        deletedNode = prevNode->next;
        prevNode->next = prevNode->next->next;
    }

    *deletedElement = deletedNode->data;
    list->size--;
}

// 在尾端删除节点
void deletedEnd(LinkedList *list, element_t *element)
{
    deletedAt(list, list->size -  1, element);
}

// 修改指定位置节点的数据
void modifyNode(LinkedList *list, size_t index, element_t element)
{
    isLinkedListNull(list);

    if (index < 0 || index >= list->size){
        printf("不允许在 %zu 位置修改节点！\n", index);
        return;
    }

    Node *currentNode = getCurrentNode(list, index);
    currentNode->data = element;
}

// 获取指定位置的节点的数据值
element_t getNodeData(LinkedList *list, size_t index)
{
    Node *currentNode = getCurrentNode(list, index);

    return currentNode->data;
}

// 获取当前链表的节点个数
size_t getSize(LinkedList *list)
{
    isLinkedListNull(list);

    return list->size;
}

// 打印所有节点数据
void Print(LinkedList *list)
{
    Node *currentNode = list->head;

    for (int i = 0; i < list->size; i++){
        printf("当前节点的地址：%p, " 
               "当前节点的数据为：%d, " 
               "当前节点指向的地址为：%p \n",
                currentNode, currentNode->data, currentNode->next);
        
        currentNode = currentNode->next;
    }   
    printf("\n");
}

int main()
{
    LinkedList list;
    // 初始化
    initLinkedList(&list);

    // 插入数据
    insertAt(&list, 0, 100);
    insertAt(&list, 1, 200);
    insertAt(&list, 2, 300);
    insertAt(&list, 3, 400);
    insertAt(&list, 4, 500);

    // 尾端插入数据
    insertEnd(&list, 600);
    size_t size = getSize(&list);
    printf("当前链表的节点的个数为：%zu \n", size);

    Print(&list);

    // 删除节点
    element_t element;
    deletedAt(&list, 0, &element);
    printf("被删除的节点为：%d \n", element);

    // 删除尾端节点
    deletedEnd(&list, &element);
    printf("被删除的节点为：%d \n", element);

    size = getSize(&list);
    printf("当前链表的节点的个数为：%zu \n", size);
    Print(&list);

    // 获取指定位置节点的数据
    element_t getElement = getNodeData(&list, 2);
    printf("当前节点的数据为：%d \n", getElement);
    Print(&list);

    // 修改指定位置节点的数据
    modifyNode(&list, 2, 200000);
    Print(&list);

    // 销毁动态分配的内存
    destoryLinkedList(&list);
    return 0;
}

标签
#链表 #数据结构 #动态数组 #内容总结
c语言单链表尾添加的深入讲解
s13596191285的博客
01-24 85
犹豫了几天，看了很多大牛写的关于c语言链表，感触很多，终于下定决心，把自己对于链表的理解随之附上，可用与否，自行裁夺。由于作者水平有限也是第一次写，不足之处，竭诚希望得到各位大神的批评指正。！！在正文开始之前，我先对数组和链表进行简单的对比分析。链表也是一种很常见的数据结构，不同于数组的是它是动态进行存储分配的一种结构。数组存放数据时，必须要事先知道元素的个数。举个例子，比如一个班有40个人，另一个班有100个人，如果要用同一个数组先后来存放这两个班的学生数据，那么必须得定义长度为100的数组。
什么是动态数组？动态数据的优缺点？
m0_53396342的博客
04-15 2610
软件测试常见面试题：什么是动态数组？动态数据的优缺点？
静态数组和动态数组的区别
jianghuan0122的博客
08-10 1万+
1. 静态数组在内存中位于栈区，是在定义时就已经在栈上分配了固定大小，在运行时这个大小不能改变，如：int a[10]; 动态数组是malloc或者new出来的，位于内存的堆区，它的大小是在运行时给定，并且可以改变其，如： int *a; a = new int[10]; 2. 静态数组的大小是在编译期间就确定，并且分配的，其内存在使用结束后由计算机自动释放，效率高;动态数组是在程序运行时，由程序员根据实际需要从堆内存中动态申请的，使用结束后由程序员进行释放，效率低。 3. ...
数组的优缺点
qq_29224201的博客
11-18 1万+
一、数组的优缺点： （一）优点： 1、按照索引查询元素速度快； 2、能存储大量数据； 3、按照索引遍历数组方便； 4、数组定义简单，而且访问很方便； 5、可以随机访问其中的元素。 （二）缺点： 1、根据内容查找元素速度慢； 2、数组的大小一经确定不能改变，不适合动态存储； 3、数组智能存储一种类型的数据； 4、增加、删除元素效率慢； 5、未封装任何方法，所有操作都需要用户自己定义； 6、数组的空间...
编程语言专题《开发篇，数组的优缺点》
物联网研究室BBC的博客
10-27 6304
优点： 数组定义简单，而且访问很方便 缺点： 数组中所有元素类型都必须相同 数组大小必须定义时给出，而且大多数情况下，数组空间的大小一旦确定后就不能更改 数组的空间必须是连续的，这就造成数组在内存中分配空间时必须找到一块连续的内存空间。所以数组不可能定义得太大，因为内存中不可能有那么多大的连续的内存空间，而解决这个问题的方法就是使用链表。 ...
C语言数据结构之精简讲
2301_76633821的博客
08-09 2380
数据结构是计算机科学的核心基础，研究数据的组织、存储和操作方式。算法+数据结构=程序。数据结构分为逻辑结构（集合、线性、树形、图形）和物理结构（顺序、链式、索引、散列存储）。线性结构中最基础的数组具有随机访问高效（O(1)）但插入删除低效的特点，可通过动态数组实现扩容功能。理解数据结构需要掌握内存存储原理，其本质与编程语言无关，如同数学定理与表达语言的关系。高效的数据结构设计能显著提升程序性能，是解决复杂问题的关键。
c语言用指针fp查找,c语言链表和指针的运用
weixin_32562973的博客
05-19 982
在学习指针之前，首先要认识指针。指针是一个存储计算机内存地址的变量。从指针指向的内存读取数据称作指针的取值。指针可以指向某些具体类型的变量地址，例如int、long和double。指针也可以是void类型、NULL指针和未初始化指针。根据出现的位置不同，操作符*既可以用来声明一个指针变量，也可以用作指针的取值。当用在声明一个变量时，*表示这里声明了一个指针。其它情况用到*表示指针的取值。&...
数据结构——静态链表
Mr_Dongzheng的博客
05-03 562
1.定义 逻辑结构上相邻的数据元素，存储在指定的一块内存空间中，数据元素只允许在这块内存空间中随机存放，这样的存储结构生成的链表称为静态链表。也就是说静态链表是用数组来实现链式存储结构，目的是方便在不设指针类型的高级程序设计语言中使用链式结构。它的优点是和动态链表一样，删除和插入元素时间复杂度低；不足是和数组一样，需要提前分配一块较大的空间。 2.老师的代码 #include <stdio.h> #include <malloc.h> #define DEFAULT_SIZ
多项式加法和乘法的实现
weixin_30265171的博客
08-06 766
多项式的表示可以使用数组也可以使用链表 数组表示起来简单，调试方便。但需要事先确定数组的大小。 链表表示起来动态性强，但编程复杂，调试起来困难。 为了提高对链表的操作，后面介绍的程序，均使用链表来完成。 注意：下列链表没有头节点 //多项式的加法和乘法 #define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include...
（数据结构）C语言中字符串存储的三种形式 —— 2022/3/19
weixin_51927215的博客
03-19 2871
字符串串串的定长顺序存储串的堆分配存储串的块链存储 串 根据串中存储字符的数量及特点，对一些特殊的串进行了命名 空串：存储0个字符的串，如 str = ""（双引号紧挨着） 空格串：只包括空格的串，如 str = " "（双引号包括三个空格） 主串和子串：子串能在主串中找到，如 str_zi = "abc";str_zhu = "aabc"（子串能在主串中找到若干连续字符与之对应） 串的定长顺序存储 实际上是用普通数组（又称静态数组，如 char str[3] = "lo"）存储 #includ
第一百一十二天学习记录：数据结构与算法基础：循环链表和双向链表以及线性表应用（王卓教学视频）
为了上岸
07-20 192
1、结点空间可以动态申请和释放；2、数据元素的逻辑次序靠结点的指针来指示，插入和删除时不需要移动数据元素。
浅谈java基本容器
Codemenon的博客
07-29 239
还记得我半年前第一次学习c中的数组，大概曾经我觉得非常难以理解的计算机数据存储在学习数组之后感觉也就这样，比我想象的容易，而且指针的概念在通过学习数组后也逐渐清晰明了。直到我学到了数据结构，害！不提了，那都是后话了。 在这里 我通过java知识来梳理和下我曾经学过的数组以及为了应付考试学的一点点数据结构。以此纪念曾经奋斗学习的岁月。 java 在其库中提供了多种的容器结构。想想我花了一天敲出来的单链表。这些库函数也大大提高了我们开发的效率。当然java中没有指针这个概念，因此容器的数据增删改查远远没有c
第1章 数据结构
最新发布
Mephisto_123的博客
02-04 1188
摘要 本文介绍了数据结构的基础概念及其实现方式。数据结构是为高效访问数据而设计的组织和存储方式，可分为逻辑结构（集合、线性、树形、图形）和存储结构（顺序、链式、索引、散列）。重点讲解了数组这一基本数据结构，包括其优缺点（查找快但插入删除难）和动态数组的实现方法。通过C语言示例展示了动态数组的初始化、扩容、插入删除等操作，体现了数据结构与算法在程序设计中的核心作用。
数据结构（一）——线性表的顺序存储原理及实现
hml111666的博客
02-09 2892
一、线性表介绍 1、定义：由n（n>0）个相同类型的元素组成的有序集合，如图 这里所说的线性表是逻辑结构，表示元素一对一的相邻关系，是独立于存储结构（顺序表和链表）的，他们属于不同层面的概念 2、特点： ➢表中元素的个数是有限的。 ➢表中元素的数据类型都相同。意味着每一个元素占用相同大小的空间 ➢表中元素具有逻辑上的顺序性，在序列中各元素排序有其先后顺序 3、实现方式——顺序表及链表 3.1顺序表：线性表的顺序表示 逻辑上相邻的两个元素在物理位置上也相邻 以上代码描述：.
C语言链表详解（通俗易懂，超详细）
weixin_46145739的博客
03-01 3万+
前言：想要很好的学好链表，我们首先要了解链表的优缺点（面试） 优点：1.插入 删除 不需移动其他元素, 只需改变指针；2:链表各个节点在内存中空间不要求连续!空间利用率高 缺点:1.访问数组元素效率低；2:数组的存储空间连续,内存空间利用率低 1.单链表 通俗讲就是结构体变量与结构体变量链接在一起. 链表结构体变量：一般由 数据域(任何数据)和指针域 组成。也就是所说的结点。 结点组成： stru...
C语言——动态数组的创建和使用
专注于C语言编程干货分享
11-26 3万+
动态数组是相对于静态数组而言的，从“动”字可以看出它的灵活性。静态数组的长度是预先定义好的，在整个程序中，一旦给定数组大小后就无法改变。而动态数组则不然，它可以根据程序需要重新指定数组大小。动态数组的内存空间是由堆动态分配的，通过执行代码为其分配存储空间，只有程序执行到分配语句时，才为其分配存储空间。
静态链表和动态链表的区别
热门推荐
我的博客
10-10 5万+
静态链表和动态链表的区别： 静态链表和动态链表是线性表链式存储结构的两种不同的表示方式。 1、静态链表是用类似于数组方法实现的，是顺序的存储结构，在物理地址上是连续的，而且需要预先分配地址空间大小。所以静态链表的初始长度一般是固定的，在做插入和删除操作时不需要移动元素，仅需修改指针。 2、动态链表是用内存申请函数（malloc/new）动态申请内存的，所以在链表的长度上没有限制。动态链表
C语言链表——增删改查
weixin_54859557的博客
03-20 3428
链表是一种数据结构，是一种数据存放的思想
【数据结构与算法】栈（Stack）之 浅谈数组和链表实现栈各自的优缺点
m0_52602233的博客
01-25 3001
C语言实现栈结构。栈是一种特殊的线性表，只允许在栈顶（Top）进行插入和删除元素操作，另一端称为栈底，栈中的数据元素遵守后进先出LIFO（Last In First Out）或先进后出的原则。栈的插入操作（Push）：称为压栈 或 入栈 或 进栈，。栈的删除操作（Pop）：也叫出栈 或 弹栈。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值