C语言的单链表

已于 2024-04-30 17:30:12 修改
阅读量1.5k 收藏 31
点赞数 76
分类专栏： c语言学习 文章标签： c语言 开发语言
于 2024-04-15 20:17:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/z6665454/article/details/137793392
版权

一.单链表的概念及结构


单链表是一种常见的数据结构，用于存储一系列的元素。它由一个节点的序列构成，每个节点包含一个数据元素和一个指向下一个节点的指针（或链接）。单链表中的节点按照顺序链接在一起，形成一个链式结构。

单链表的结构：

   +------+    +------+    +------+    +------+
   | Data |    | Data |    | Data |    | Data |
   +------+    +------+    +------+    +------+
   | Next |--> | Next |--> | Next |--> | NULL |
   +------+    +------+    +------+    +------+

1.单链表的基本概念

  • 节点（Node）：每个节点包含两个部分，一个是存储数据元素的值，另一个是指向下一个节点的指针。
  • 头节点（Head Node）：链表的第一个节点，用于表示链表的起始位置。
  • 尾节点（Tail Node）：链表的最后一个节点，其指针指向空值（NULL）。
  • 遍历（Traversal）：通过遍历链表中的每个节点，按顺序访问所有元素。
  • 插入（Insertion）：在链表的特定位置插入一个新节点。
  • 删除（Deletion）：从链表中删除指定位置的节点。

2.单链表的功能包括但不限于以下操作

  • 创建链表（Create）：创建一个空的链表。
  • 判断链表是否为空（IsEmpty）：检查链表是否没有任何节点。
  • 在链表末尾添加节点（Append）：向链表的尾部添加一个新节点。
  • 在链表的特定位置插入节点（Insert）：在指定位置插入一个新节点。
  • 删除链表中的节点（Delete）：从链表中删除指定位置的节点。
  • 遍历链表（Traverse）：按顺序访问链表中的每个节点，并处理节点的数据元素。
  • 查找链表中的节点（Search）：根据指定的值在链表中查找节点。
  • 反转链表（Reverse）：将链表中的节点顺序反转。

通过这些功能，可以对单链表进行各种操作，实现数据的存储、查找、插入、删除等操作。单链表的动态特性使得它在处理不确定长度的数据集合时非常灵活和高效。

单链表的结构如下所示：

struct Node {
    int data;              // 存储数据元素的值
    struct Node* next;     // 指向下一个节点的指针
};

struct LinkedList {
    struct Node* head;     // 指向链表的第一个节点的指针
};

链表的第一个节点被称为头节点（head），最后一个节点的指针指向空值（NULL），表示链表的结束。

单链表的优点是插入和删除元素的时间复杂度为O(1)，即常数时间，而不受链表长度的影响。但是，访问链表中的特定元素的时间复杂度为O(n)，其中n是链表的长度。

二.实现单链表

1.尾插

append函数用于在链表末尾添加新节点。它会创建一个新节点，并将新节点插入到链表的最后一个节点之后。

void append(struct LinkedList* list, int data) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->data = data;
    newNode->next = NULL;

    if (list->head == NULL) {
        list->head = newNode;
    } else {
        struct Node* current = list->head;
        while (current->next != NULL) {
            current = current->next;
        }
        current->next = newNode;
    }
}

2.指定插入

insert函数用于在链表的指定位置插入新节点。如果要在链表头部插入节点，它会将新节点设置为头节点，并指向原来的头节点。否则，它会找到指定位置的前一个节点，将新节点插入到其后面。

void insert(struct LinkedList* list, int data, int position) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->data = data;
    
    if (position == 0) {
        newNode->next = list->head;
        list->head = newNode;
    } else {
        struct Node* current = list->head;
        for (int i = 0; i < position - 1; i++) {
            if (current == NULL) {
                printf("Invalid position\n");
                return;
            }
            current = current->next;
        }
        newNode->next = current->next;
        current->next = newNode;
    }
}

3.删除

delete函数用于删除链表的指定位置的节点。如果要删除头节点，它会将头节点指向下一个节点，并释放原头节点的内存。否则，它会找到指定位置的前一个节点，将其指针跳过待删除节点，并释放待删除节点的内存。

void delete(struct LinkedList* list, int position) {
    if (list->head == NULL) {
        printf("List is empty\n");
        return;
    }

    struct Node* current = list->head;
    if (position == 0) {
        list->head = current->next;
        free(current);
    } else {
        struct Node* previous = NULL;
        for (int i = 0; i < position; i++) {
            if (current == NULL) {
                printf("Invalid position\n");
                return;
            }
            previous = current;
            current = current->next;
        }
        previous->next = current->next;
        free(current);
    }
}

4.遍历

display函数用于遍历链表，并打印各个节点的值。

void display(struct LinkedList* list) {
    struct Node* current = list->head;
    while (current != NULL) {
        printf("%d ", current->data);
        current = current->next;
    }
    printf("\n");
}

5.清空

cleanup函数用于释放链表的所有节点内存。它会遍历链表，并释放每个节点的内存，最后将链表的头节点指针设为NULL。

void cleanup(struct LinkedList* list) {
    struct Node* current = list->head;
    while (current != NULL) {
        struct Node* temp = current;
        current = current->next;
        free(temp);
    }
    list->head = NULL;
}

6.主函数

在main函数中，首先定义了一个名为my_list的链表，并将其头节点指针初始化为NULL。然后使用append函数向链表末尾添加了三个元素：10、20和30。接着使用insert函数在位置1插入了元素15。然后使用delete函数删除了位置2的元素。最后使用display函数打印链表中所有的元素，结果是打印出链表中剩余的两个元素的值。

int main() {
    struct LinkedList list;
    list.head = NULL;

    append(&list, 1);
    append(&list, 2);
    append(&list, 3);

    display(&list); // 输出：1 2 3

    insert(&list, 4, 1);

    display(&list); // 输出：1 4 2 3

    delete(&list, 2);

    display(&list); // 输出：1 4 3

三.链表的分类

链表是一种常见的线性数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。根据节点之间的连接方式和链表的特性，链表可以分为以下几种常见的分类：

1.单链表（Singly Linked List）

每个节点只包含指向下一个节点的指针。是最简单的链表形式。

2.双向链表（Doubly Linked List）

每个节点同时包含指向下一个节点和上一个节点的指针。相比于单链表，双向链表可以实现双向遍历。

3.循环链表（Circular Linked List）

尾节点的指针指向头节点，形成一个闭环。可以通过任意节点开始遍历整个链表。

4.带头节点的链表（Head-Linked List）

在链表的头部额外添加一个特殊的空节点（头节点），它不存储数据，仅用于方便链表的操作和处理边界情况。

5.带尾节点的链表（Tail-Linked List）

在链表的尾部额外添加一个特殊的节点（尾节点），它可以加快在链表末尾添加新节点的操作。

四.单链表的源码呈现

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

// 定义链表的节点结构
struct Node {
    int data;           // 数据部分
    struct Node* next;  // 指针部分
};

// 在链表末尾插入节点
void append(struct Node** head_ref, int new_data) {
    // 创建新节点
    struct Node* new_node = (struct Node*)malloc(sizeof(struct Node));
    new_node->data = new_data;
    new_node->next = NULL;

    // 如果链表为空，则将新节点设置为头节点
    if (*head_ref == NULL) {
        *head_ref = new_node;
        return;
    }

    // 找到链表的最后一个节点
    struct Node* last = *head_ref;
    while (last->next != NULL) {
        last = last->next;
    }

    // 将新节点链接到最后一个节点
    last->next = new_node;
}

// 在链表头部插入节点
void prepend(struct Node** head_ref, int new_data) {
    // 创建新节点
    struct Node* new_node = (struct Node*)malloc(sizeof(struct Node));
    new_node->data = new_data;
    new_node->next = *head_ref;

    // 将新节点设置为头节点
    *head_ref = new_node;
}

// 在链表中的指定位置插入节点
void insert(struct Node* prev_node, int new_data) {
    if (prev_node == NULL) {
        printf("Previous node cannot be NULL.\n");
        return;
    }

    // 创建新节点
    struct Node* new_node = (struct Node*)malloc(sizeof(struct Node));
    new_node->data = new_data;
    new_node->next = prev_node->next;

    // 将新节点链接到前一个节点
    prev_node->next = new_node;
}

// 从链表中删除指定位置的节点
void deleteNode(struct Node** head_ref, int position) {
    if (*head_ref == NULL) {
        printf("List is empty.\n");
        return;
    }

    // 找到要删除节点的前一个节点
    struct Node* prev_node = *head_ref;
    if (position == 0) {
        *head_ref = prev_node->next;
        free(prev_node);
        return;
    }

    for (int i = 0; prev_node != NULL && i < position - 1; i++) {
        prev_node = prev_node->next;
    }

    if (prev_node == NULL || prev_node->next == NULL) {
        printf("Invalid position.\n");
        return;
    }

    // 将前一个节点与要删除节点的下一个节点链接
    struct Node* next_node = prev_node->next->next;
    free(prev_node->next);
    prev_node->next = next_node;
}

// 遍历并打印链表的元素
void printList(struct Node* node) {
    while (node != NULL) {
        printf("%d ", node->data);
        node = node->next;
    }
    printf("\n");
}

// 释放链表的内存
void freeList(struct Node** head_ref) {
    struct Node* current = *head_ref;
    struct Node* next;

    while (current != NULL) {
        next = current->next;
        free(current);
        current = next;
    }

    *head_ref = NULL;
}

int main() {
    struct Node* head = NULL;  // 初始化链表为空

    // 在链表末尾插入节点
    append(&head, 1);
    append(&head, 2);
    append(&head, 3);

    // 在链表头部插入节点
    prepend(&head, 0);

    // 在指定位置插入节点
    insert(head->next, 4);

    // 删除指定位置的节点
    deleteNode(&head, 2);

    // 遍历并打印链表的元素
    printList(head);

    // 释放链表的内存
    freeList(&head);

    return 0;
}

晚安，cheems
关注
专栏目录
C语言单链表实现
01-16
通过这些基本操作，你可以构建和操作简单的C语言单链表。在学习过程中，理解指针和动态内存分配的重要性是至关重要的，因为它们是实现链表的关键。此外，实践编写和调试这些操作的代码将有助于加深对链表工作原理的...
C语言 单链表的实现
06-28
(1)熟悉将算法转换为程序代码的过程。 (2)了解顺序表的逻辑结构特性，熟练学握顺序表存储结构的 C 语言描述... (5)熟练掌握线性链表(单链表)的基本运算:查找、插入、删除等，能在实际应用中灵活选择适当的链表结构。
C语言单链表
myCs05的博客
01-18 702
【代码】C语言单链表。
c语言单链表
sunzixian998的博客
10-23 881
2.2创建单链表头结点。5.1按位置删除元素。2.1先创建指针结构。3.1按位置插入元素。4.1按位置查找元素。4.2按数值查找位置。
c语言单链表基本操作
qq_59328991的博客
08-16 1010
单链表基本操作
c语言单链表的逆置
weixin_50626842的博客
10-08 2674
单链表的逆置 方法一：头插 void Reverse(Node* plist) { assert(plist != NULL&&plist->next!=NULL); Node* p = plist->next; Node* q; plist->next = NULL; while (p != NULL) { q = p->next; p->next = plist->next; plist->next = p; p
C语言 单链表的反转
Genven_Liang的博客
05-18 2万+
C语言 单链表的反转 一、简述 记--简单的将单链表的数据顺序进行反转。如将原来的顺序1 2 3 4 5 6 7 反转为：7 6 5 4 3 2 1 二、方式1：头插法 2.1 头插法1--类似新建链表 2.1.1 思路：断开链表头，然后以头插法的方式将原链表的数据添加链表。 2.1.2 测.........
C语言单链表的基本操作总结（增删改查）
热门推荐
.
01-27 15万+
1.链表概述   链表是一种常见的数据结构。它与常见的数组是不同的，使用数组时先要指定数组包含元素的个数，即为数组的长度，但是如果向这个数组中加入的元素超过了数组的大小时，便不能将内容全部保存。   链表这种存储方式，其元素个数是不受限定的，当进行添加元素的时候存储的个数就会随之改变。   链表一般有两种形式，有空头链表和无空头链表。   在链表中有一个头指针变量，这个指针变量保存一个地址，...
C语言单链表的创建
qq_51830913的博客
07-20 2202
单链表是一种线性结构，但是它不是像一维数组一样所有的存储空间都是连续的。单链表是碎片的，也就是不连续。那么它是靠什么来连接，从而使它成为一种线性结构？如图：L就是一个单链表的结构，a就是一个数组。L中用红线连接起来的是一个个节点。每一个节点分为俩部分，一个是data域,还有一个是指针next域。data域里面存放的就是数据，next存放的是下一个节点的地址，也就是这样，next一个连一个，把链表串了起来。需要注意的是：头节点，也就是第一个节点的data通常是不存储数据的。
C语言单链表的算法之遍历节点
tmk1234567890的博客
06-27 405
C语言单单链表的算法之遍历节点
C语言单链表删除结点
2302_79422829的博客
04-08 318
程序功能：建立一个单向链表，头指针是list，链表中每个结点包含姓名、基本工资信息，编写del_list函数删除链表中等于某给定基本工资的所有结点。要求在主函数中先建立单向链表（注：当输入基本工资为0时，表示输入结束。），再输入一个给定基本工资，然后调用del_list函数删除链表中等于给定基本工资的所有结点，最后输出删除后的链表信息。
c语言单链表销毁、清空
qq_42449028的博客
08-02 2673
清空指从首元结点开始删除每一个结点，并将头结点的next指针置为null。由于头结点不能删除，所以删除时循环需从首元结点开始，最后对头结点做单独置空。销毁指从头结点开始删除每一个结点。...
C语言单链表实现多项式相加
08-29
C语言单链表实现多项式相加 多项式是数学中的一种重要概念，表示为一个变量的幂的和。多项式相加是指将两个或多个多项式进行加法运算，结果仍然是一个多项式。在计算机科学中，实现多项式相加需要使用数据结构和...
C语言单链表实现19个功能完全详解.zip_C语言_C语言单链表_单链表
09-20
在C语言中，单链表是一种基础且重要的数据结构，它在编程中有着广泛的应用。本文将详细解析如何使用C语言来实现单链表，并涵盖了19种不同的操作功能，帮助你深入理解这一核心概念。 单链表由一系列节点组成，每个...
C语言单链表删除（无备注）
04-05
数据结构典型范例，单链表删除操作（注：因实验需要，没有直接汉语注释和输入提醒）
如何让GCC生成编译过程的中间文件(.i/.s/.o)?gcc 1.c和g++ 1.c有什么区别?gcc 1.c和g++ 1.c预处理有什么区别?
编程语言技巧经验分享
11-10 716
可以用--save-temps选项指示GCC生成编译过程中的中间文件。
2024年，Rust开发语言，现在怎么样了?
LiangGang365的专栏
10-27 2286
Rust到底好不好用，最终还是要看具体的业务场景应用。比如，目前用Rust来编写纯UI的前端，可能还不是很成熟。但在内存管理、安全性和性能优化等领域，Rust无疑是一种非常优秀的语言选择。国内华为、字节、百度、阿里、美团等在通用组件、基础平台系统都在使用rust，其他国内数据库厂商、交易所、理想汽车、小鹏汽车等，以及大量在区块链、游戏行业提供的远程职位
华为云：云服务器ECS实战部署.docx
最新发布
11-10
华为云：云服务器ECS实战部署.docx
【光学】基于matlab OAM涡旋光束(拉盖尔-高斯光束)【Matlab仿真 7508期】.zip
11-10
【光学】基于matlab OAM涡旋光束(拉盖尔-高斯光束)【Matlab仿真 7508期】.zip
C语言单链表实现贪吃蛇游戏详解
C语言单链表贪吃蛇小游戏是一种经典的编程实践，它将C语言的基础数据结构和控制流程结合在一起，为学习者提供了一个直观的实战案例。本文档详细介绍了如何使用C语言实现一款控制台版的贪吃蛇游戏，主要涉及到以下几...
评论 17
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值