数据结构顺序表和链表（中）

// 定义单链表节点数据类型
typedef int SLTDataType;

// 定义单链表节点结构体
typedef struct SListNode
{
    SLTDataType data;        // 数据域，用于存储节点的数据
    struct SListNode* next;  // 指针域，用于指向下一个节点
} SLTNode;

void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
    // 创建一个新节点并初始化
    SLTNode* newnode = SLTBuyNode(x);

    // 如果链表为空，直接将新节点设置为头节点
    if (*pphead == nullptr)
    {
        *pphead = newnode;
    }
    // 如果链表不为空，找到尾节点并将新节点链接到尾部
    else
    {
        SLTNode* ptail = *pphead;  // 从头节点开始
        while (ptail->next)  // 找到尾节点
        {
            ptail = ptail->next;
        }
        ptail->next = newnode;  // 将新节点链接到尾部
    }
}

  void SLTPushFront(SLTNode** pphead, SLTDataType x);//头插

​#include <assert.h>  // 引入 assert 宏

// 在单链表头部插入一个新节点
void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
    // 断言检查：确保传入的二级指针非空
    assert(pphead);

    // 创建并初始化新节点
    SLTNode* newnode = SLTBuyNode(x);

    // 将新节点的 next 指针指向当前的头节点
    newnode->next = *pphead;

    // 更新头指针，使其指向新节点
    *pphead = newnode;
}
​

​  void SLTPopBack(SLTNode** pphead) //尾删

void SLTPopBack(SLTNode** pphead)
{
    // 断言检查：确保传入的二级指针非空且链表不为空
    assert(pphead && *pphead);

    // 如果链表只有一个节点，直接释放该节点并清空头指针
    if ((*pphead)->next == nullptr)
    {
        free(*pphead);  // 释放头节点
        *pphead = nullptr;  // 清空头指针
    }
    else
    {
        // 如果链表有多个节点，找到倒数第二个节点和最后一个节点
        SLTNode* prev = nullptr;  // 初始化前驱节点指针为nullptr
        SLTNode* ptail = *pphead; // 初始化尾节点指针为头节点

        while (ptail->next)  // 遍历链表直到最后一个节点
        {
            prev = ptail;  // 更新前驱节点
            ptail = ptail->next;  // 移动尾节点指针到下一个节点
        }

        // 删除最后一个节点
        prev->next = nullptr;  // 将前驱节点的next指针设为nullptr，断开与尾节点的连接
        free(ptail);  // 释放最后一个节点的内存
        ptail = nullptr;  // 防止悬空指针，将尾节点指针设为nullptr
    }

  void SLTPopFront(SLTNode** pphead); //头删

void SLTPopFront(SLTNode** pphead)
{
    // 断言检查：确保传入的二级指针非空且链表不为空
    assert(pphead && *pphead);

    // 保存下一个节点的地址，以便后续操作
    SLTNode* next = (*pphead)->next;

    // 释放当前头节点的内存
    free(*pphead); 

    // 更新头指针，使其指向下一个节点
    *pphead = next;
}

  SLTNode* SLTFindNode(SLTNode* phead, SLTDataType x) //查找

// 在链表中查找值为 x 的节点
SLTNode* SLTFindNode(SLTNode* phead, SLTDataType x)
{
    SLTNode* pcur = phead; // 初始化当前节点指针为头节点
    while (pcur)          // 遍历链表直到末尾（nullptr）
    {
        if (pcur->data == x) // 如果当前节点的数据等于 x
        {
            return pcur;    // 返回当前节点
        }
        pcur = pcur->next;  // 移动到下一个节点
    }
    return nullptr;        // 如果没有找到，返回 nullptr
}

  void SLTInsert(SLTNode** pphead, SLTNode * pos, SLTDataType x); //指定位置之前插入数据

void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
    // 断言检查：确保传入的二级指针非空且链表不为空，且 pos 节点在链表中
    assert(pphead && *pphead);
    assert(pos);

    // 如果 pos 是头节点，直接在头部插入新节点
    if (pos == *pphead)
    {
        SLTPushFront(pphead, x);
    }
    else 
    {
        // 创建并初始化新节点
        SLTNode* newnode = SLTBuyNode(x);

        // 找到 pos 节点的前驱节点
        SLTNode* prev = *pphead;
        while (prev->next != pos)
        {
            prev = prev->next;
            // 确保 prev 不会越界，即 pos 节点确实在链表中
            assert(prev != nullptr);
        }

        // 将新节点插入到 pos 节点之前
        newnode->next = pos;
        prev->next = newnode;
    }
}

  void SLTErase(SLTNode** pphead, SLTNode* pos); // 指定位置删除结点

// 在链表中删除指定节点 pos
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
    // 断言检查：确保 pos 节点和传入的二级指针非空，且链表不为空
    assert(pos && pphead && *pphead);

    SLTNode* prev = *pphead;  // 初始化前驱节点指针为头节点
    // 遍历链表找到 pos 节点的前驱节点
    while (prev->next != pos)
    {
        prev = prev->next;
        // 确保 prev 不会越界，即 pos 节点确实在链表中
        assert(prev != nullptr);
    }

    // 删除 pos 节点
    prev->next = pos->next;  // 将前驱节点的 next 指针指向 pos 节点的下一个节点
    free(pos);               // 释放 pos 节点的内存
    pos = nullptr;           // 防止悬空指针，将 pos 指针设为 nullptr
}

  void SLTInsertAfter(SLTNode* pos, SLTDataType x); //指定位置之后插入数据

// 在链表中指定节点 pos 之后插入一个新节点
void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
    // 断言检查：确保 pos 节点非空
    assert(pos);

    // 创建并初始化新节点
    SLTNode* newnode = SLTBuyNode(x);

    // 将新节点插入到 pos 节点之后
    newnode->next = pos->next;  // 新节点的 next 指针指向 pos 节点的下一个节点
    pos->next = newnode;       // 将 pos 节点的 next 指针指向新节点
}

  void SLTEraseAfter(SLTNode* pos); //删除pos之后的结点

// 在链表中删除指定节点 pos 之后的节点
void SLTEraseAfter(SLTNode* pos)
{
    // 断言检查：确保 pos 节点非空且 pos 之后有节点
    assert(pos && pos->next);

    // 保存要删除的节点
    SLTNode* del = pos->next;

    // 将 pos 节点的 next 指针指向 del 节点的下一个节点，从而跳过 del 节点
    pos->next = pos->next->next; // (pos.next = del.next)

    // 释放要删除的节点的内存
    free(del);

    // 防止悬空指针，将 del 指针设为 nullptr
    del = nul

  void SListDestroy(SLTNode** pphead); //销毁链表

// 销毁整个单链表，释放所有节点的内存
void SListDestroy(SLTNode** pphead)
{
    // 断言检查：确保传入的二级指针非空
    assert(pphead);

    // 初始化当前节点指针为头节点
    SLTNode* pcur = *pphead;
    // 遍历链表直到末尾（nullptr）
    while (pcur != nullptr)
    {
        // 保存下一个节点的地址，以便后续操作
        SLTNode* next = pcur->next;
        // 释放当前节点的内存
        free(pcur);
        // 移动到下一个节点
        pcur = next;
    }
    // 将头指针设为 nullptr，表示链表已被销毁
    *pphead = nullptr;
}

   这篇的内容就到这里了，欢迎大家讨论，感谢观看。