数据结构基础：数组与链表详解

于 2025-02-09 21:18:38 发布
阅读量908 收藏 7
点赞数 23
分类专栏： 数据结构 文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_63520660/article/details/145537266
版权

引言

数据结构是计算机科学的核心基础之一，而数组和链表是最基本的数据结构。本文将详细介绍数组和链表的基本概念、操作及其应用场景，并通过C语言代码示例帮助初学者理解。此外，我们还将深入探讨复杂链表，如循环链表和双向链表。

1. 数组

数组是一种线性数据结构，用于存储相同类型的元素。数组的元素在内存中是连续存储的，因此可以通过索引快速访问。

1.1 数组的基本概念

  • 定义：数组是一个固定大小的、相同类型元素的集合。

  • 索引：数组中的每个元素都有一个唯一的索引，通常从0开始。

  • 内存分配：数组在内存中是连续存储的。

1.2 数组的操作

  • 访问元素：通过索引访问数组中的元素，时间复杂度为O(1)。

  • 插入元素：在数组中插入元素需要移动后续元素，时间复杂度为O(n)。

  • 删除元素：删除数组中的元素同样需要移动后续元素，时间复杂度为O(n)。

1.3 数组的应用场景

  • 存储固定大小的数据：如存储一周的温度数据。

  • 快速访问元素：由于数组的连续内存分配，访问元素非常高效。

1.4 代码示例

以下代码演示了如何在C语言中定义和操作数组：

#include <stdio.h>

int main() {
    int arr[5] = {1, 2, 3, 4, 5};

    // 访问元素
    printf("Element at index 2: %d\n", arr[2]);

    // 修改元素
    arr[2] = 10;
    printf("Modified element at index 2: %d\n", arr[2]);

    // 遍历数组
    for (int i = 0; i < 5; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    return 0;
}

2. 链表

链表是一种动态数据结构，由一系列节点组成，每个节点包含数据和指向下一个节点的指针。链表的内存分配是非连续的。

2.1 链表的基本概念

  • 节点：链表中的每个元素称为节点，包含数据和指向下一个节点的指针。

  • 头节点：链表的第一个节点。

  • 尾节点：链表的最后一个节点，通常指向NULL。

2.2 链表的操作

  • 插入元素：在链表中插入元素只需修改指针，时间复杂度为O(1)。

  • 删除元素：删除链表中的元素同样只需修改指针，时间复杂度为O(1)。

  • 访问元素：访问链表中的元素需要从头节点开始遍历，时间复杂度为O(n)。

2.3 链表的应用场景

  • 动态数据存储：链表可以动态分配内存，适合存储大小不确定的数据。

  • 实现其他数据结构：如栈、队列、哈希表等。

2.4 代码示例

以下代码演示了如何在C语言中定义和操作链表：

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

// 定义链表节点
struct Node {
    int data;
    struct Node* next;
};

// 创建新节点
struct Node* createNode(int data) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}

// 在链表末尾插入节点
void append(struct Node** head, int data) {
    struct Node* newNode = createNode(data);
    if (*head == NULL) {
        *head = newNode;
        return;
    }
    struct Node* lastNode = *head;
    while (lastNode->next != NULL) {
        lastNode = lastNode->next;
    }
    lastNode->next = newNode;
}

// 打印链表
void printList(struct Node* head) {
    struct Node* currentNode = head;
    while (currentNode != NULL) {
        printf("%d ", currentNode->data);
        currentNode = currentNode->next;
    }
    printf("\n");
}

int main() {
    struct Node* head = NULL;

    // 插入元素
    append(&head, 1);
    append(&head, 2);
    append(&head, 3);

    // 打印链表
    printList(head);

    return 0;
}

3. 复杂链表

除了基本的单向链表，还有一些复杂的链表结构，如循环链表和双向链表。

3.1 循环链表

循环链表是一种特殊的链表，其中尾节点指向头节点，形成一个环。

3.1.1 循环链表的基本概念

  • 尾节点指向头节点：循环链表的尾节点不再指向NULL，而是指向头节点。

  • 遍历：遍历循环链表时需要特别注意终止条件，否则会进入无限循环。

3.1.2 代码示例

以下代码演示了如何在C语言中定义和操作循环链表：

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

// 定义循环链表节点
struct Node {
    int data;
    struct Node* next;
};

// 创建新节点
struct Node* createNode(int data) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}

// 在循环链表末尾插入节点
void append(struct Node** head, int data) {
    struct Node* newNode = createNode(data);
    if (*head == NULL) {
        *head = newNode;
        newNode->next = *head;
        return;
    }
    struct Node* lastNode = *head;
    while (lastNode->next != *head) {
        lastNode = lastNode->next;
    }
    lastNode->next = newNode;
    newNode->next = *head;
}

// 打印循环链表
void printList(struct Node* head) {
    if (head == NULL) {
        printf("List is empty.\n");
        return;
    }
    struct Node* currentNode = head;
    do {
        printf("%d ", currentNode->data);
        currentNode = currentNode->next;
    } while (currentNode != head);
    printf("\n");
}

int main() {
    struct Node* head = NULL;

    // 插入元素
    append(&head, 1);
    append(&head, 2);
    append(&head, 3);

    // 打印循环链表
    printList(head);

    return 0;
}

3.2 双向链表

双向链表是一种特殊的链表，每个节点包含两个指针，分别指向前一个节点和后一个节点。

3.2.1 双向链表的基本概念

  • 前驱指针和后继指针：每个节点包含两个指针，分别指向前一个节点和后一个节点。

  • 双向遍历：可以从头节点或尾节点开始遍历链表。

3.2.2 代码示例

以下代码演示了如何在C语言中定义和操作双向链表：

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

// 定义双向链表节点
struct Node {
    int data;
    struct Node* prev;
    struct Node* next;
};

// 创建新节点
struct Node* createNode(int data) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->data = data;
    newNode->prev = NULL;
    newNode->next = NULL;
    return newNode;
}

// 在双向链表末尾插入节点
void append(struct Node** head, int data) {
    struct Node* newNode = createNode(data);
    if (*head == NULL) {
        *head = newNode;
        return;
    }
    struct Node* lastNode = *head;
    while (lastNode->next != NULL) {
        lastNode = lastNode->next;
    }
    lastNode->next = newNode;
    newNode->prev = lastNode;
}

// 打印双向链表
void printList(struct Node* head) {
    struct Node* currentNode = head;
    while (currentNode != NULL) {
        printf("%d ", currentNode->data);
        currentNode = currentNode->next;
    }
    printf("\n");
}

int main() {
    struct Node* head = NULL;

    // 插入元素
    append(&head, 1);
    append(&head, 2);
    append(&head, 3);

    // 打印双向链表
    printList(head);

    return 0;
}

4. 总结

本文详细介绍了数组和链表的基本概念、操作及其应用场景，并通过C语言代码示例帮助初学者理解。我们还深入探讨了复杂链表，如循环链表和双向链表。掌握这些基础知识后，你可以进一步学习更高级的数据结构，如栈、队列、树和图等。

希望这篇文章能帮助你入门数据结构，并为你的学习之旅打下坚实的基础。

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值