【初阶数据结构】实现带哨兵位的单向不循环链表

1.认识链表

1.1 概念

链表是⼀种物理存储结构上⾮连续、⾮顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。

1.2 保存数据的方式

链表由若干个节点组成，每一个节点都是独⽴申请下来的空间。
节点的组成主要有两个部分：数据域和指针域，即当前节点要保存的数据和保存下⼀个节点的地址（指针变量）。

1.3 分类

带头节点和不带头节点的单链表，具体区别请参考下面博主的文章，本文实现的是更具优势的带头节点的单链表。
愿天堂没有C++

1.4 补充说明

1） 链式结构在逻辑上是连续的，在物理结构上不一定连续
2） 节点一般是从堆上申请的
3） 从堆上申请来的空间，是按照一定策略分配出来的，每次申请的空间可能连续，可能不连续

2.代码实现

2.1 创建文件

SList.h：包含头文件，函数的声明
SList.c：函数功能的具体实现过程
Test.c：测试函数功能的实现

2.2 创建单链表

SList.h

//使用typedef重命名类型——提高链表的通用性
typedef int SLDataType;
//本文是实现存储整形数据的顺序表,如果想利用现有的顺序表代码逻辑存储其他数据，
//只需要将这里的int改为对应的数据类型名称，而不需要去具体过程中更改
					   
//自定义节点数据类型
typedef struct SListNode
{
	//数据域
	SLDataType data;
	//指针域
	struct SListNode *next;
}SLTNode;

2.3 初始化单链表

创建一个空的单链表，即只有一个头节点的单链表。
为了更加灵活的存储数据，我们选择使用malloc开辟动态内存空间，需要在SList.h中包含stdlib.h。

SList.c

void SLTInit(SLTNode** pphead)//pphead为slist的地址
{
    //检查传入指针是否为空
    if (NULL == pphead)
    {
        perror("InitPphead");
        exit(1);
    }

    //开辟动态内存空间
    *pphead = (SLTNode*)malloc(sizeof(SLTNode));//*pphead等价于slist
    //检查内存分配是否成功
    if (NULL == *pphead)
    {
        perror("InitMalloc");
        exit(1);
    }

    //设置头节点的数据域和指针域
    (*pphead)->data = 0; //头节点的数据域一般不存储有效数据，可以设为0或其他值
    (*pphead)->next = NULL; //头节点的指针域指向空，表示链表为空
}

注意 参数类型为二级指针，才能在函数内部修改指针域的值，并且让这个修改能够反映到函数外部

2.4 创建新节点

SList.c

SLTNode* SLTCrtNode(SLTDataType n)
{
    SLTNode* newNode = (SLTNode*)malloc(sizeof(SLTNode));
    if (NULL == newNode)
    {
        perror("CrtMalloc");
        exit(1);
    }

    newNode->data = n;
    newNode->next = NULL;

    return newNode;
}

2.5 从尾部插入新节点

SList.c

void SLTPushBack(SLTNode** pphead, SLTDataType n)
{
    if (NULL == pphead)
    {
        perror("PuBpphead");
        exit(1);
    }

    //创建新节点
    SLTNode* newNode = SLTCrtNode(n);

    //寻找尾节点
    SLTNode* ptail = *pphead;//*pphead为头节点，ptail记录尾节点
    while (ptail->next)//尾节点本身不为空，只是其指针域指向空
    {
        ptail = ptail->next;
    }
    //即使链表为空（即头节点的指针域指向空，即首元节点为空）
    //也可以将头节点的指针域指向新节点，即构造首元节点，实现尾插操作

    //插入
    ptail->next = newNode;
}

注意 其使用一级指针也可以，但是为了接口头统一化，仍然选择二级指针

2.6 打印单链表

SList.c

void SLTPrint(SLTNode **pphead)
{
    SLTNode* pcur = *pphead;//slist
    while (pcur)
    {
        printf("%d-->", pcur->data);
        pcur = pcur->next;
    }
    printf("NULL\n");
}

测试初始化、尾插和打印

2.7 从头部插入新节点

SList.c

void SLTPushFront(SLTNode** pphead, SLTDataType n)
{
    if (NULL == pphead)
    {
        perror("PuFpphead");
        exit(1);
    }

    SLTNode *newNode = SLTCrtNode(n);

    newNode->next = (*pphead)->next;
    (*pphead)->next = newNode;
}

2.8 从尾部删除节点

SList.c

void SLTPopBack(SLTNode** pphead)
{
    if (NULL == pphead)
    {
        perror("PoBpphead");
        exit(1);
    }

    //链表不能为空（即头节点的指针域不能指向空，即不能没有首元节点）
    if (NULL == (*pphead)->next)
    {
        perror("slist is empty");
        exit(1);
    }

    SLTNode* ptail = (*pphead)->next;//(*pphead)->next为首元节点

    SLTNode* prev = *pphead;//*pphead为头节点，prev记录尾节点的前一个节点
    //为了在删除尾节点后，使尾节点的前一个节点的指针域指向空

    //寻找尾节点
    while (ptail->next)
    {
        prev = ptail;
        ptail = ptail->next;
    }
    //即使链表只有一个节点（即首元节点的指针域指向空）
    //也可以使头节点的指针域指向空，再释放首元节点，实现尾删操作

    //使尾节点的前一个节点的指针域指向空
    prev->next = NULL;

    //销毁尾节点
    free(ptail);
    ptail = NULL;
}

2.9 从头部删除节点

SList.c

void SLTPopFront(SLTNode** pphead)
{
    if (NULL == pphead)
    {
        perror("PoFpphead");
        exit(1);
    }

    //链表不能为空（即头节点的指针域不能指向空，即不能没有首元节点）
    if (NULL == (*pphead)->next)
    {
        perror("slist is empty");
        exit(1);
    }
    
    //删除首元节点
    //创建变量next保存第二个节点，即首元节点的指针域指向的节点
    SLTNode* next = (*pphead)->next->next;
    //释放首元节点
    free((*pphead)->next);
    //使原来的第二个节点成为新的首元节点
    (*pphead)->next = next;
}

2.10 通过数据域查找节点，返回其对应的位置

SList.c

SLTNode* SLTFind(SLTNode** pphead, SLTDataType n)
{
    if (NULL == pphead)
    {
        perror("Findpphead");
        exit(1);
    }

    //遍历查找
    SLTNode* pcur = (*pphead)->next;
    while (pcur)
    {
        if (n == pcur->data)
        {
            return pcur;
        }
        pcur = pcur->next;
    }

    //没有找到
    return NULL;
}

2.11 通过数据域指定节点，在其之前、之后插入

SList.c

void SLTInsertBefore(SLTNode** pphead, SLTNode* pos, SLTDataType n)
{
    if (NULL == pphead)
    {
        perror("IBpphead");
        exit(1);
    }
    if (NULL == *pphead)
    {
        perror("slist is empty");
        exit(1);
    }
    if (NULL == pos)
    {
        perror("IBpos");
        exit(1);
    }

    //创建新节点
    SLTNode* newnode = SLTCrtNode(n);
    
    //插入
    //找到pos的前驱节点
    SLTNode* prev = *pphead;//头节点
    while (prev->next != pos)//pos的前驱节点的指针域指向pos节点
    {
        prev = prev->next;
    }
    newnode->next = pos;
    prev->next = newnode;
    //即使pos就是第一个节点，即首元节点
    //也可以直接使头节点的指针域指向新节点，新节点指向pos
    //使新节点成为首元结点
}

void SLTInsertAfter(SLTNode* pos, SLTDataType n)
{
    if (NULL == pos)
    {
        perror("IApos");
        exit(1);
    }

    //创建新节点
    SLTNode* newnode = SLTCrtNode(n);
    
    //插入
    newnode->next = pos->next;
    pos->next = newnode;
    //必须先让新节点指向原来pos的下一个节点，再让pos指向新节点
    //如果先让pos指向新节点，那么就无法再找到原来pos的下一个节点
}

注意 必须先用SLTFind函数查找指定位置，再将其的返回值作为参数pos传入“插入函数”

2.12 通过数据域删除指定节点

SList.c

void SLTErase(SLTNode** pphead, SLTNode* pos)
{
    //检查
    if (NULL == pphead)
    {
        perror("Epphead");
        exit(1);
    }
    if (NULL == *pphead)
    {
        perror("slist is empty");
        exit(1);
    }
    if (NULL == pos)
    {
        perror("Epos");
        exit(1);
    }

    //删除
    //让pos的前一个节点指向pos的后一个节点
    SLTNode* prev = *pphead;//*pphead是头节点
    while (prev->next != pos)
    {
        prev = prev->next;
    }
    prev->next = pos->next;
    //释放pos节点
    free(pos);
    pos = NULL;
    //即使pos就是第一个节点，即首元节点，
    //也可以直接使头节点的指针域指向pos的下一个节点，
    //实现删除首元节点的效果
}

2.13 销毁链表

SList.c

void SLTDestroy(SLTNode** pphead)
{
    //检查
    if (NULL == pphead)
    {
        perror("Dpphead");
        exit(1);
    }
    if (NULL == *pphead)
    {
        perror("slist is empty");
        exit(1);
    }

    SLTNode* pcur = *pphead;
    while (pcur)//如果节点为空，就不执行释放操作
    {
        //先保存下一个节点
        SLTNode* next = pcur->next;
        //再释放当前节点
        free(pcur);
        //再找到下一个节点
        pcur = next;
    }
    
    //将头指针置为空
    *pphead = NULL;
}