用C语言实现单链表的增、删、改、查操作

字节旅行者

已于 2025-04-04 20:20:49 修改

阅读量403

点赞数 6

文章标签： c语言开发语言

于 2025-03-01 20:17:44 首次发布

本文链接：https://blog.youkuaiyun.com/2301_79681669/article/details/145937912

版权

一、带头结点单链表的基本操作（头结点不存储数据）

二、单链表就是用链式存储方式来实现的线性表

三、导入头文件：

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

其中<stdlib.h>里面有用于分配内存的malloc（）函数，还有用来释放内存的free（）函数。

四、定义单链表结点类型

typedef struct LNode      //定义单链表的结点类型
{
    int data;              //每个节点存放一个数据元素
    struct LNode *next;     //指针指向下一个节点
}LNode ,*LinkList;

typedef 是C语言中的一个关键字，作用是为已有的数据类型取一个新的名字。这样可以让代码更简洁，也更容易理解。

在这段代码中，typedef 做了两件事：

为 struct LNode 这个结构体类型取了一个别名叫做 LNode。

为指向 struct LNode 的指针类型（也就是 struct LNode *）取了一个别名叫做 LinkList。

LNode 是 struct LNode 的别名。LinkList 是 struct LNode * 的别名。通过 typedef，代码更简洁，LNode 替代 struct LNode，LinkList 替代 struct LNode *。

五、创建一个带有头结点的单链表

// 初始化链表（带空头结点）
LinkList initList() 
{
    LinkList L = (LinkList)malloc(sizeof(LNode));
    if (L == NULL) 
    {
        printf("内存分配失败！\n");
        exit(-1); // 该语句不像return一样终止函数，而是直接终止整个程序，并向操作系统返回-1，而不是向调用函数返回值，且exit（）函数里面必须填写一个整数，不能空着
    }
    L->next = NULL; // 头结点的next指向空
    return L;
}

这里的 L 是头指针，在 main（）函数里面已经定义了 LinkList L；

六、插入函数（中间插入）“增”

// 增：在指定位置插入元素（位置从1开始）
int insertAt(LinkList L, int pos, int value) 
{
    if (L == NULL || pos < 1) 
        return -1;
    LinkList p = L;
    int j = 0;
    while (p != NULL && j < pos - 1) 
    {
        p = p->next;
        j++;
    }
    if (p == NULL) 
        return -1;
    LinkList newNode = (LinkList)malloc(sizeof(LNode));
    if (newNode == NULL) 
        return -1;
    newNode->data = value;
    newNode->next = p->next;
    p->next = newNode;
    return 0;
}

如何增加一个结点元素，带有头结点的单链表中头结点为0号位置，紧跟其后的为1号位置，依次类推，在第i个位置插入元素就是说插入之后这个元素是在i号位置上的。上面部分关键代码就是下面这个。

    newNode->data = value;
    newNode->next = p->next;
    p->next = newNode;

七、删除操作（删除第 i 个位置的结点）

// 删：删除指定位置的元素（位置从1开始），并返回删除的值
int deleteAt(LinkList L, int pos, int *deletedValue) 
{
    if (L == NULL || L->next == NULL || pos < 1) 
        return -1;
    LinkList p = L;
    int j = 0;
    while (p->next != NULL && j < pos - 1) 
    {
        p = p->next;
        j++;
    }
    if (p->next == NULL) 
        return -1;
    LinkList q = p->next;
    p->next = q->next;
    *deletedValue = q->data;
    free(q);
    return 0;
}

在上面的删除操作中，形参列表里面有一个 int *deletedValue，其实在main（）函数中就定义了int value;它用来存放被删除元素的值。删除操作的关键步骤是：

    LinkList q = p->next;
    p->next = q->next;
    *deletedValue = q->data;
    free(q);

free(q);在头文件<stdlib.h>中，用来释放q所指向的那部分内存空间。

八、头插法就是在头结点后面插入一个新结点，然后在申请一个新的结点插入在头结点的后面，每次都是在头结点后面插入。

九、尾插法就是第一个结点插在头结点后面，第二个结点插在第一个结点后面，依次类推。

十、完整代码如下：

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

// 定义单链表结点结构
typedef struct LNode 
{
    int data;            // 数据域
    struct LNode * next; // 指针域
} LNode, * LinkList;

// 初始化链表（带空头结点）
LinkList initList() 
{
    LinkList L = (LinkList)malloc(sizeof(LNode));
    if (L == NULL) 
    {
        printf("内存分配失败！\n");
        exit(-1); // 该语句不像return一样终止函数，而是直接终止整个程序，并向操作系统返回-1，而不是向调用函数返回值，且exit（）函数里面必须填写一个整数，不能空着
    }
    L->next = NULL; // 头结点的next指向空
    return L;
}

// 头插法：在链表头部插入元素
int insertHead(LinkList L, int value) 
{
    if (L == NULL) 
        return -1;
    LinkList newNode = (LinkList)malloc(sizeof(LNode));
    if (newNode == NULL) 
        return -1;// 这里如果没有分配到内存的话我想程序继续执行，就用这个语句，而如果我想要整个程序终止，就用exit(-1);这个，上面的头结点那里如果没有内存后面就不能继续
    newNode->data = value;
    newNode->next = L->next;
    L->next = newNode;
    return 0;
}

// 尾插法：在链表尾部插入元素
int insertTail(LinkList L, int value) 
{
    if (L == NULL) 
        return -1;
    LinkList newNode = (LinkList)malloc(sizeof(LNode));
    if (newNode == NULL) 
        return -1;
    newNode->data = value;
    newNode->next = NULL;
    LinkList p = L;
    while (p->next != NULL) 
    {
        p = p->next;
    }
    p->next = newNode;
    return 0;
}

// 增：在指定位置插入元素（位置从1开始）
int insertAt(LinkList L, int pos, int value) 
{
    if (L == NULL || pos < 1) 
        return -1;
    LinkList p = L;
    int j = 0;
    while (p != NULL && j < pos - 1) 
    {
        p = p->next;
        j++;
    }
    if (p == NULL) 
        return -1;
    LinkList newNode = (LinkList)malloc(sizeof(LNode));
    if (newNode == NULL) 
        return -1;
    newNode->data = value;
    newNode->next = p->next;
    p->next = newNode;
    return 0;
}

// 删：删除指定位置的元素（位置从1开始），并返回删除的值
int deleteAt(LinkList L, int pos, int *deletedValue) 
{
    if (L == NULL || L->next == NULL || pos < 1) 
        return -1;
    LinkList p = L;
    int j = 0;
    while (p->next != NULL && j < pos - 1) 
    {
        p = p->next;
        j++;
    }
    if (p->next == NULL) 
        return -1;
    LinkList q = p->next;
    p->next = q->next;
    *deletedValue = q->data;
    free(q);
    return 0;
}

// 改：修改指定位置的元素（位置从1开始）
int updateAt(LinkList L, int pos, int newValue) 
{
    if (L == NULL || L->next == NULL || pos < 1) 
        return -1;
    LinkList p = L->next;
    int j = 1;
    while (p != NULL && j < pos) 
    {
        p = p->next;
        j++;
    }
    if (p == NULL) 
        return -1;
    p->data = newValue;
    return 0;
}

// 查：按位查找（位置从1开始）
int findByPos(LinkList L, int pos, int *value) 
{
    if (L == NULL || L->next == NULL || pos < 1) 
        return -1;
    LinkList p = L->next;
    int j = 1;
    while (p != NULL && j < pos) 
    {
        p = p->next;
        j++;
    }
    if (p == NULL) 
        return -1;
    *value = p->data;
    return 0;
}

// 按值查找：返回第一个匹配值的节点位置（从1开始），未找到返回-1
int findByValue(LinkList L, int value) 
{
    if (L == NULL || L->next == NULL) 
        return -1;
    LinkList p = L->next;
    int pos = 1;
    while (p != NULL) 
    {
        if (p->data == value) 
            return pos;
        p = p->next;
        pos++;
    }
    return -1;
}

// 打印链表
void printList(LinkList L) 
{
    if (L == NULL || L->next == NULL) 
    {
        printf("链表为空\n");
        return;
    }
    LinkList p = L->next;
    printf("链表内容：");
    while (p != NULL) 
    {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
}

// 主函数测试
int main() 
{
    LinkList L = initList();
    int value;

    // 测试头插法
    insertHead(L, 1);
    insertHead(L, 2);
    insertHead(L, 3);
    printList(L); // 预期：3 2 1

    // 测试尾插法
    insertTail(L, 4);
    insertTail(L, 5);
    printList(L); // 预期：3 2 1 4 5

    // 测试增
    insertAt(L, 2, 10);
    printList(L); // 预期：3 10 2 1 4 5

    // 测试删
    deleteAt(L, 3, &value);
    printf("删除的值：%d\n", value); // 预期：2
    printList(L); // 预期：3 10 1 4 5

    // 测试改
    updateAt(L, 1, 30);
    printList(L); // 预期：30 10 1 4 5

    // 测试按位查找
    if (findByPos(L, 2, &value) == 0) 
    {
        printf("位置2的值：%d\n", value); // 预期：10
    }

    // 测试按值查找
    int pos = findByValue(L, 4);
    printf("值4的位置：%d\n", pos); // 预期：4

    // 释放链表内存
    while (L) 
    {
        LinkList temp = L;
        L = L->next;
        free(temp);
    }
    return 0;
}