链表的大致思维导图：

链表的相关概念和解释： 

1. 节点（Node）：链表中的每个元素都是一个节点，节点包含数据和指向下一个节点的指针。

2. 头节点（Head Node）：链表的第一个节点称为头节点，它存储链表的起始位置。

3. 尾节点（Tail Node）：链表的最后一个节点称为尾节点，它的指针指向NULL，表示链表的结束。

4. 单向链表（Singly Linked List）：每个节点只有一个指针，指向下一个节点。

5. 双向链表（Doubly Linked List）：每个节点有两个指针，一个指向前一个节点，一个指向后一个节点，可以实现双向遍历。

6. 循环链表（Circular Linked List）：尾节点的指针指向链表的头节点，形成一个循环。

7. 插入（Insertion）：在链表的特定位置插入一个新的节点。

8. 删除（Deletion）：从链表中删除一个节点。

9. 遍历（Traversal）：按顺序访问链表中的每个节点。

---

 

单链表的增删查改各个功能的实现

创建一个空链表

    SLTNode* head = NULL;

创建一个新节点

// 创建新节点
SLTNode* SLTCreateNode(SLTDataType x)//传新节点的数值
{
    SLTNode* newNode = (SLTNode*)malloc(sizeof(SLTNode));
    
    //创建失败
    if (newNode == NULL)
    {
        printf("内存分配失败\n");
        exit(1);//退出程序
    }

    //创建成功
    newNode->data = x;//赋值数据
    newNode->next = NULL;//将后一个节点设置成空指针
    return newNode;
}

遍历并打印链表

// 打印链表中的所有节点
void SLTPrint(SLTNode* phead)//传的是首节点地址的解引用
{
    printf("链表节点：");
    SLTNode* curr = phead;//将首节点赋值给结构体指针
    while (curr != NULL)//没有走到最后一个节点（NULL）时，继续寻找下一个节点
    {
        printf("%d->", curr->data);//打印节点中的数据
        curr = curr->next;//将下一个节点的指针赋值给原指针，进入下一个节点
    }
    printf("NULL\n");//走完最后一个节点打印空指针
}

在链表头部插入节点

// 头部插入节点
void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
    // 创建新节点
    SLTNode* newNode = SLTCreateNode(x);

    // 将新节点链接到原头节点之前
    newNode->next = *pphead;

    // 更新 头节点为新节点
    *pphead = newNode;
}

在链表尾部插入节点

// 尾部插入节点
void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
    // 创建新节点
    SLTNode* newNode = SLTCreateNode(x);

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

    // 找到尾节点并将新节点链接到尾部
    SLTNode* curr = *pphead;//创建一个临时指针curr，并将其初始化为头指针的值（即指向链表的第一个节点）。
    while (curr->next != NULL)
    {
        curr = curr->next;
    }

    curr->next = newNode;//将新节点newNode链接到链表的尾部，使得链表中原来的最后一个节点的next指针指向新节点。
}

 查找节点

// 查找节点
SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{
    SLTNode* curr = phead;
    while (curr != NULL)
    {
        if (curr->data == x)
        {
            return curr; // 找到匹配的节点
        }
        curr = curr->next;
    }
    return NULL; // 未找到匹配的节点
}

效果： 

 

在指定位置之前插入节点

// 在指定位置之前插入数据
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
    // 如果插入位置为头节点，则使用头部插入函数
    if (*pphead == pos)
    {
        SLTPushFront(pphead, x);
        return;
    }

    // 创建新节点
    SLTNode* newNode = SLTCreateNode(x);

    // 找到插入位置的前一个节点
    SLTNode* curr = *pphead;
    while (curr != NULL && curr->next != pos)
    {
        curr = curr->next;
    }

 

删除指定位置的节点

// 删除指定节点
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
    // 如果删除位置为头节点，则使用头部删除函数
    if (*pphead == pos)
    {
        SLTPopFront(pphead);
        return;
    }

    // 找到删除位置的前一个节点
    SLTNode* curr = *pphead;
    while (curr != NULL && curr->next != pos)
    {
        curr = curr->next;
    }

    // 跳过删除位置的节点，链接到下一个节点
    curr->next = curr->next->next;

    // 释放删除位置节点的内存空间
    free(pos);
}

在指定节点之后插入节点

// 在指定位置之后插入数据
void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
    // 创建新节点
    SLTNode* newNode = SLTCreateNode(x);

    // 将新节点链接到指定位置之后
    newNode->next = pos->next;
    pos->next = newNode;
}

删除指定节点之后的节点

// 删除指定节点之后的节点
void SLTEraseAfter(SLTNode* pos)
{
    // 如果指定位置的下一个节点为空，无需删除
    if (pos->next == NULL)
    {
        return;
    }

    // 保存待删除的下一个节点指针
    SLTNode* nextNode = pos->next;

    // 跳过待删除的下一个节点，链接到下下个节点
    pos->next = pos->next->next;

    // 释放待删除节点的内存空间
    free(nextNode);
}

删除头节点

// 删除头节点
void SLTPopFront(SLTNode** pphead)
{
    // 如果链表为空，直接返回
    if (*pphead == NULL)
    {
        return;
    }

    // 保存原头节点的下一个节点指针
    SLTNode* nextNode = (*pphead)->next;

    // 释放原头节点的内存空间
    free(*pphead);

    // 更新头节点为原头节点的下一个节点
    *pphead = nextNode;
}

删除尾节点

// 删除尾节点
void SLTPopBack(SLTNode** pphead)
{
    // 如果链表为空，直接返回
    if (*pphead == NULL)
    {
        return;
    }

    // 如果只有一个节点，释放该节点并将头节点置为空
    if ((*pphead)->next == NULL)
    {
        free(*pphead);
        *pphead = NULL;
        return;
    }

    // 找到尾节点的前一个节点
    SLTNode* curr = *pphead;
    while (curr->next->next != NULL)
    {
        curr = curr->next;
    }

    // 释放尾节点的内存空间
    free(curr->next);

    // 将尾节点的前一个节点的指针指向NULL，表示链表的结束
    curr->next = NULL;
}

销毁链表

// 销毁链表
void SListDestroy(SLTNode** pphead)
{
    // 释放所有节点的内存空间
    SLTNode* curr = *pphead;
    while (curr != NULL)
    {
        SLTNode* temp = curr;
        curr = curr->next;
        free(temp);
    }

    // 将头节点指针置为空
    *pphead = NULL;
}