手动实现单链表操作

于 2025-05-20 08:40:14 发布
阅读量257 收藏 1
点赞数 9
分类专栏： 嵌入式 文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/h2358129875/article/details/148079237
版权

手动实现单链表操作

一、头文件：Linked_list.h

#ifndef LINKED_LIST_H  // 头文件保护宏，防止重复包含
#define LINKED_LIST_H

// 包含常用头文件
#include <stdbool.h>  // 布尔类型
#include <stdlib.h>   // 内存管理函数（malloc/calloc/free）
#include <stdio.h>    // 输入输出函数

// 定义数据类型别名（方便后续修改数据类型）
typedef int DataType;

// 定义链表结点结构
typedef struct node {
    DataType data;      // 数据域，存储具体数据
    struct node *next;  // 指针域，指向下一个结点
} Node;

// 定义链表结构体（管理链表整体信息）
typedef struct {
    Node *head;     // 头指针，指向链表第一个结点
    Node *tail;     // 尾指针，指向链表最后一个结点
    int size;       // 链表长度（结点个数）
} LinkedList;

// 函数声明列表

// 创建空链表
// 返回值：指向新创建链表的指针
LinkedList *create_linked_list();

// 销毁链表（释放所有内存）
// 参数：链表指针
void destroy_linked_list(LinkedList *list);

// 头插法：在头部插入新结点
// 参数：链表指针、新数据
// 返回值：插入成功与否（布尔值）
bool add_before_head(LinkedList *list, DataType new_data);

// 尾插法：在尾部插入新结点
// 参数：链表指针、新数据
// 返回值：插入成功与否（布尔值）
bool add_behind_tail(LinkedList *list, DataType new_data);

// 按索引插入结点（0-based索引）
// 参数：链表指针、索引、新数据
// 返回值：插入成功与否（布尔值）
bool add_by_idx(LinkedList *list, int idx, DataType new_data);

// 按索引搜索结点
// 参数：链表指针、索引
// 返回值：目标结点指针（失败返回NULL）
Node *search_by_idx(LinkedList *list, int idx);

// 按数据值搜索结点（返回首个匹配结点）
// 参数：链表指针、目标数据
// 返回值：目标结点指针（失败返回NULL）
Node *search_by_data(LinkedList *list, DataType data);

// 按数据值删除首个匹配结点
// 参数：链表指针、目标数据
// 返回值：删除成功与否（布尔值）
bool delete_by_data(LinkedList *list, DataType data);

// 扩展：按索引删除结点（0-based索引）
// 参数：链表指针、索引
// 返回值：删除成功与否（布尔值）
bool delete_by_idx(LinkedList *list, int idx);

// 打印链表内容（格式：1 -> 2 -> 3 -> ...）
// 参数：链表指针
void print_list(LinkedList *list);

#endif // !LINKED_LIST_H
#pragma once  // 替代头文件保护宏的另一种方式（部分编译器支持）

二、实现文件：linked_list.c

#include "Linked_list.h"  // 包含自定义头文件

// 创建空链表
// 功能：分配链表结构体内存，初始化头/尾指针和长度
LinkedList *create_linked_list() {
    // calloc自动初始化内存为0，链表初始时head/tail为NULL，size为0
    return calloc(1, sizeof(LinkedList));
}

// 销毁链表
// 功能：释放所有结点内存，再释放链表结构体内存
void destroy_linked_list(LinkedList *list) {
    Node *curr = list->head;  // 从头部开始遍历
    while (curr != NULL) {     // 循环直到所有结点处理完毕
        Node *temp = curr->next;  // 暂存下一个结点指针
        free(curr);              // 释放当前结点内存
        curr = temp;             // 移动到下一个结点
    }
    free(list);  // 释放链表结构体内存
}

// 打印链表
// 功能：按格式输出链表所有结点数据
void print_list(LinkedList *list) {
    Node *curr = list->head;  // 从头部开始遍历
    while (curr != NULL) {
        printf("%d", curr->data);  // 输出当前数据
        if (curr->next != NULL) {   // 非最后一个结点时添加箭头
            printf("->");
        }
        curr = curr->next;  // 移动到下一个结点
    }
    printf("\n");  // 换行
}

// 头插法实现
bool add_before_head(LinkedList *list, DataType new_data) {
    Node *new_node = (Node *)malloc(sizeof(Node));  // 分配新结点内存
    if (new_node == NULL) {                         // 内存分配失败处理
        printf("内存分配失败");
        exit(-1);  // 终止程序（实际开发中可返回错误码）
    }
    new_node->data = new_data;       // 赋值数据域
    new_node->next = list->head;     // 新结点的next指向原头部
    list->head = new_node;           // 头指针指向新结点
    // 处理空链表情况：插入后尾指针也指向新结点
    if (list->tail == NULL) {        
        list->tail = new_node;
    }
    list->size++;  // 长度+1
    return true;
}

// 尾插法实现
bool add_behind_tail(LinkedList *list, DataType new_data) {
    Node *new_node = malloc(sizeof(Node));  // 分配新结点内存
    if (new_node == NULL) {
        printf("内存分配失败");
        exit(-1);
    }
    new_node->data = new_data;       // 赋值数据域
    new_node->next = NULL;           // 尾结点的next必须为NULL
    // 处理空链表情况：头/尾指针均指向新结点
    if (list->tail == NULL) {        
        list->head = new_node;
        list->tail = new_node;
    } else {                        // 非空链表：原尾结点的next指向新结点，更新尾指针
        list->tail->next = new_node;
        list->tail = new_node;
    }
    list->size++;  // 长度+1
    return true;
}

// 按索引插入实现
bool add_by_idx(LinkedList *list, int idx, DataType new_data) {
    // 索引合法性检查（idx范围：0 ~ size）
    if (idx < 0 || idx > list->size) {     
        printf("输入的索引错误\n");
        return false;
    }
    // 特殊情况：索引为0（头插法）或索引为size（尾插法）
    if (idx == 0) {
        return add_before_head(list, new_data);
    }
    if (idx == list->size) {
        return add_behind_tail(list, new_data);
    }
    // 普通情况：找到索引idx-1的结点（前驱结点）
    Node *new_node = malloc(sizeof(Node));  // 分配新结点内存
    if (new_node == NULL) {
        printf("内存分配失败");
        return false;
    }
    new_node->data = new_data;       // 赋值数据域
    Node *prev = list->head;         // 从头部开始遍历
    // 移动prev到idx-1的位置
    for (int i = 0; i < idx - 1; i++) {  
        prev = prev->next;
    }
    // 插入逻辑：新结点的next指向prev的下一个结点，prev的next指向新结点
    new_node->next = prev->next;     
    prev->next = new_node;
    list->size++;  // 长度+1
    return true;
}

// 按索引搜索实现
Node *search_by_idx(LinkedList *list, int idx) {
    // 索引合法性检查（idx范围：0 ~ size-1）
    if (idx < 0 || idx > list->size - 1) {  
        printf("索引不合法");
        return NULL;
    }
    Node *curr = list->head;  // 从头部开始遍历
    // 移动curr到idx的位置
    for (int i = 0; i < idx; i++) {  
        curr = curr->next;
    }
    return curr;  // 返回目标结点
}

// 按数据值搜索实现（返回首个匹配结点）
Node *search_by_data(LinkedList *list, DataType data) {
    Node *curr = list->head;  // 从头部开始遍历
    while (curr != NULL) {     // 遍历直到链表末尾
        if (curr->data == data) {  // 匹配成功，返回当前结点
            return curr;
        }
        curr = curr->next;  // 移动到下一个结点
    }
    return NULL;  // 未找到匹配结点
}

// 按数据值删除实现（删除首个匹配结点）
bool delete_by_data(LinkedList *list, DataType data) {
    Node *curr = list->head;  // 当前结点
    // 处理头结点匹配的情况
    if (curr != NULL && curr->data == data) {  
        list->head = curr->next;  // 头指针指向下一个结点
        if (list->head == NULL) {  // 删除后链表为空，更新尾指针
            list->tail = NULL;
        }
        free(curr);  // 释放头结点内存
        list->size--;  // 长度-1
        return true;
    }
    // 查找后续结点中的匹配项
    Node *prev = curr;       // 前驱结点
    curr = curr->next;       // 当前结点后移一位
    while (curr != NULL) {
        if (curr->data == data) {  // 找到匹配结点
            prev->next = curr->next;  // 前驱结点跳过当前结点
            if (curr->next == NULL) {  // 删除的是尾结点，更新尾指针
                list->tail = prev;
            }
            free(curr);  // 释放当前结点内存
            list->size--;  // 长度-1
            return true;
        }
        prev = curr;       // 前驱后移
        curr = curr->next; // 当前后移
    }
    return false;  // 未找到匹配结点
}

// 按索引删除实现
bool delete_by_idx(LinkedList *list, int idx) {
    // 索引合法性检查（idx范围：0 ~ size-1）
    if (idx < 0 || idx >= list->size) {  
        printf("索引错误");
        return false;
    }
    Node *curr = list->head;  // 当前结点
    Node *prev = NULL;        // 前驱结点
    // 处理删除头结点的情况（idx=0）
    if (idx == 0) {  
        list->head = curr->next;  // 头指针指向下一个结点
        if (list->size == 1) {    // 删除后链表为空，更新尾指针
            list->tail = NULL;
        }
        free(curr);  // 释放头结点内存
        list->size--;  // 长度-1
        return true;
    }
    // 查找索引idx的结点（移动curr到idx位置，prev到idx-1位置）
    for (int i = 0; i < idx; i++) {  
        prev = curr;
        curr = curr->next;
    }
    prev->next = curr->next;  // 前驱结点跳过当前结点
    if (idx == list->size - 1) {  // 删除的是尾结点，更新尾指针
        list->tail = prev;
    }
    free(curr);  // 释放当前结点内存
    list->size--;  // 长度-1
    return true;
}

三、主函数：main.c

#define _CRT_SECURE_NO_WARNINGS  // 禁用VS编译器的安全警告（可选）
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// 计算数组长度的宏（方便数组操作）
#define ARR_SIZE(arr) (sizeof(arr) / sizeof(arr[0]))
#include "Linked_list.h"  // 包含链表头文件

int main(void) {
    // 1. 创建链表
    LinkedList *list = create_linked_list();

    // 2. 头插法测试
    add_before_head(list, 10);
    add_before_head(list, 20);
    add_before_head(list, 30);
    printf("在头部插入30, 20, 10后:\n");
    print_list(list);  // 输出：30->20->10

    // 3. 尾插法测试
    add_behind_tail(list, 40);
    add_behind_tail(list, 50);
    printf("在尾部插入40, 50后:\n");
    print_list(list);  // 输出：30->20->10->40->50

    // 4. 按索引插入测试（索引2插入25）
    add_by_idx(list, 2, 25);
    printf("在索引2插入25后:\n");
    print_list(list);  // 输出：30->20->25->10->40->50

    // 5. 按索引搜索测试（获取索引2的结点）
    Node *node = search_by_idx(list, 2);
    printf("索引2处的元素: %d\n", node->data);  // 输出：25

    // 6. 按数据值搜索测试（查找值为40的结点）
    node = search_by_data(list, 40);
    printf("找到数据40的结点: %d\n", node->data);  // 输出：40

    // 7. 按数据值删除测试（删除值为25的结点）
    delete_by_data(list, 25);
    printf("删除数据25后:\n");
    print_list(list);  // 输出：30->20->10->40->50

    // 8. 按索引删除测试（删除索引0的结点，即30）
    delete_by_idx(list, 0);
    printf("删除索引0处的元素后:\n");
    print_list(list);  // 输出：20->10->40->50

    // 9. 销毁链表（释放内存）
    destroy_linked_list(list);

    return 0;
}

四、关键知识点总结

  1. 链表结构：

    • 每个结点包含数据域和指针域（指向下一个结点）。
    • 链表结构体管理头指针、尾指针和长度，方便快速操作头尾结点。

  2. 内存管理：

    • calloc用于创建链表结构体（自动初始化内存为0）。
    • malloc用于分配结点内存，需手动初始化next指针（尾插法中需设为NULL）。
    • 销毁链表时需先释放所有结点内存，再释放链表结构体内存，避免内存泄漏。

  3. 核心操作：

    • 头插法：时间复杂度 O(1)，更新头指针和尾指针（空链表时）。
    • 尾插法：时间复杂度 O(1)（利用尾指针），需处理空链表情况。
    • 按索引插入/删除：需先找到前驱结点，时间复杂度 O(n)（n为索引值）。
    • 搜索操作：按索引搜索 O(n)，按值搜索 O(n)（需遍历链表）。

  4. 边界处理：

    • 插入/删除时需检查索引合法性（如idx=0或idx=size的情况）。
    • 空链表或单个结点时，头指针和尾指针需同步更新（如删除头结点后若链表为空，尾指针需置NULL）。
C++实现单链表的16种基本操作
weixin_47373497的博客
10-29 2644
C++实现单链表的16种基本操作 链表初始化，头插法创建链表，尾插法创建链表，取值，查找（第i个节点的数据域或者数据域为某个特定值的节点），有顺序的合并两个链表，无顺序的合并两个链表，插入，删除，逆置链表，求链表的节点个数，删除数据域重复的节点，输出链表，判空，置空链表。 以下是我写的头文件的代码 #ifndef DANLIANBIAO_H #define DANLIANBIAO_H #endif #include<iostream> #include<stdio.h> #inclu
C++手动实现单链表类
07-15
C++手动实现带头结点的单链表类，测试环境为Visual Studio 2010
手动实现单链表
03-11 131
？？？有点问题，再试试单链表：指针是指一个数据元素逻辑意义上的存储位置，链式存储机构是基于指针实现的，每一个节点由一个数据元素和一个指针构成。链式存储结构是用指针把相互关联的元素链接起来。在单链表中，每个节点只有一个直接只想后继元素的指针，而双向链表中每个节点有两个指针，一个只想后继节点一个只想前驱节点。单链表的实现节点类：package com.nishizhen.list; publ...
C++实现单链表的基本操作
zhaicheng55的博客
12-27 1316
【代码】C++实现单链表的基本操作。
Java实现单链表及其基本操作
qq_58284486的博客
03-14 8679
目录 什么是单链表？ 带头结点的单链表 不带头结点的单链表 模拟实现不带头结点的单链表 定义结点类 初始化 头插法创建单链表 尾插法创建单链表 打印单链表 单链表的查找 获取单链表的长度 按位置寻找前驱结点 单链表的插入 修改指定位置的值 按值寻找前驱结点 删除第一次出现的key值 删除所有的key值 清空单链表 完整代码 什么是单链表？ 单链表是一种链式存取的数据结构，用一组任意的存储单元存放线性表中的数据元素。链表中的数据是以结点表示...
JAVA实现单链表
2301_80501383的博客
11-05 853
其实这里的头节点并非真正的头，他只是一个引用，总是指向链表第一个对象，这个头并没有一个真正属于自己的对象。在有头链表中，第一个节点前会加一个节点,其next指向第一个节点对象，而其val并不存储元素，这个头是不可改变的，是一个固定的对象。链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的。创建一个findIndexOfkey方法，找到指定节点的前一个节点，让他指向后一个节点。遍历到链表的尾节点，将其next指向 新节点，要注意链表为空时的情况。
Go语言实现单链表
qq_54650406的博客
10-12 270
使用Go 语言实现单链表的基本操作
Java实现单链表的各种操作
zl15290869125的博客
08-14 391
Java实现单链表的各种操作 主要内容：1.单链表的基本操作 　　　　　2.删除重复数据 　　　　　3.找到倒数第k个元素 　　　　 &amp;nbsp; 4.实现链表的反转 　　　　 &amp;nbsp; 5.从尾到头输出链表 　　　　　6.找到中间节点 　　　　　7.检测链表是否有环 　　　　　8.在不知道头指针的情况下删除指定节点 　　　　　9.如何判断两个链表是否相交并找出...
Java实现简单的单链表
wxx17353227396的博客
05-28 385
1、Java实现简单的单链表： 数据结构：单链表的实现-Java 数据结构还是很重要的，就算不是那种很牛逼的，但起码得知道基础的东西，这一系列就算是复习一下以前学过的数据结构和填补自己在这一块的知识的空缺。加油。珍惜校园中自由学习的时光。按照链表、栈、队列、排序、数组、树这种顺序来学习数据结构这门课程把。 一、单链表的概念 链表是最基本的数据结构，其存储的你原理图如下图所示: 上面展示的是一个单...
C语言实现单链表
sgz0527的博客
10-20 2160
C语言实现单链表
Python实现单链表、双链表、循环单链表、循环双链表、顺序表相关操作
05-27
在实现这些链表操作时，Python的动态内存管理为我们提供了便利，无需手动分配和释放内存。然而，理解链表的内部工作原理对于优化算法和设计高效数据结构至关重要。在实际应用中，根据需求选择合适的数据结构，如需要...
在C语言中如何手动实现单链表的插入操作，并分析其时间复杂度？
11-01
在C语言中，手动实现单链表的插入操作首先需要了解单链表的节点结构和基本操作。单链表由一系列节点组成，每个节点包含数据和一个指向下一个节点的指针。以下是实现单链表插入操作的步骤和示例代码： 参考资源链接...
YOLOv11改进 | Neck篇 | 轻量化跨尺度跨通道融合颈部CCFM助力YOLOv11有效涨点
weixin_39818775的博客
05-16 1098
本文提出的CCFM模块通过创新的跨尺度跨通道融合机制，在YOLOv11的Neck部分实现了显著的性能提升。轻量化设计：深度可分离卷积+通道混洗减少计算负担高效特征融合：多尺度特征交互增强小目标检测动态通道适应：注意力机制提升特征表达能力即插即用：可无缝集成到现有YOLO架构实验表明，CCFM在COCO数据集上可实现2.5%的mAP提升，同时减少15%的参数量。该模块特别适合资源受限场景下的实时目标检测应用，为工业部署提供了新的优化方向。
VSCode + Cline AI辅助编程完全指南
keyboard专栏
05-16 1098
自动生成和编辑代码理解和解释复杂代码回答关于代码架构和逻辑的问题执行和修复测试管理Git工作流创建和修改项目文件这个插件让Claude AI的强大能力直接集成到你的编码环境中，大幅提升开发效率。
cmd-bat-批处理-脚本-IE主页修改.zip
05-20
cmd-bat-批处理-脚本-IE主页修改.zip
Delphi 12.3控件之uniGUI-Extras-1.95.0.1600.rar
最新发布
05-20
Delphi 12.3控件之uniGUI-Extras_1.95.0.1600.rar
【数据库安全】MySQL中SQL注入攻击原理与防御措施：提升Web应用安全性设计在MySQL环境下SQL
05-20
内容概要：本文主要介绍了SQL注入的概念、危害及其防范措施。SQL注入是攻击者通过恶意构造输入，使服务器执行非预期的SQL命令的一种攻击方式，常因用户输入未
ORON1.SHX
05-20
使用方法：拷贝到Auto CAD的Fonts下
cmd-bat-批处理-脚本-维护版.zip
05-20
cmd-bat-批处理-脚本-维护版.zip
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值