单链表以及打印插入与删除操作

引入：有些同学初步学习链表的时候难免发现与数组有很高的相似性，在大多数的情况下二者可以相互替代，那么什么情况下链表可以发挥其独特的优势呢？不妨看看接下来的故事。

        你是一个珠宝商人，你有五个宝物想要存储到银行的保险柜里，由于容量限制，每一个保险柜里只能放一个宝物。现在你来到银行，你很快想到一个点子，把五个宝物放到相邻的五个保险柜里，这样就方便取出了，但是情况不容乐观，由于保险柜所剩不多，无法找到连续的五个保险柜，只有一些分散的保险柜（剩余的保险柜总量大于5）那么如何存储呢？同时你为了方便管理，你决定只随身携带一把钥匙，这可以做到吗？

        答案是肯定的：方法如下。先打开第一个保险柜，把宝物1存进去（对应的钥匙为钥匙1），随后再打开一个保险柜，把宝物2和钥匙1存进去，随后再打开保险柜3，存入宝物3和钥匙2，直至第五个保险柜，存入宝物5和钥匙4，最后把钥匙5随身携带。至此，你做到了只拿一把钥匙就可以管理所有的保险柜里的宝物了！！当你想要取出宝物的时候，只需要依次打开保险柜，获取下一个保险柜的钥匙，直至打开存入对应宝物的柜子，取出宝物，再把钥匙归为原位就好了。

        在这个过程中，分散的保险柜就对应链表中的节点，而最后剩下的钥匙就是头指针。使用一个头指针就可以做到维护整个链表。正如数组知道数组名（首地址）就可以维护整个数组。是不是很简单啊？

        如果想要取出一个宝物并且减去一个保险柜怎么做呢？答案是把想要减去的保险柜B里的钥匙拿出来放到上一个保险柜A里，再把原来上一个保险柜A里的钥匙还给银行。

        以上过程就是删除节点，注意必须还钥匙（也就是释放空间），如果不还钥匙，则下一个人无法使用对应的保险柜（每个保险柜只对应一把钥匙），对于电脑，就是内存泄漏（memory leak)。这是非常严重的。

        有了存宝物的思想，我们就可以引入链表了。

---

命名风格

Sequence List   --SLT

SLTDatatype--链表中数据的类型

SLTNode--链表节点

SLTPrint--打印链表

SLTBuyNode--添加新节点

SLTPushFront--头插

SLTPushBack--尾插

SLTPopFront--头删

SLTPopBack--尾删

newnode--新节点

pnewnode--维护新节点的指针

phead--链表头指针

pphead--头指针的指针 

 代码实现

#include<stdio.h>
#include<stdlib.h>//malloc使用
#include<assert.h>//assert函数使用
typedef int SLTDataType;//此处存储int的值，以后可以改变存的变量
typedef struct SListNode
{
    SLTDataType data;
    struct SListNode* next;//此处SLTNode未定义，不能直接写，必须用SListNode*
}SLTNode; 

//打印链表

void SLTPrint(SLTNode* phead)
{
    SLTNode* cur = phead;//开一个表示当前位置的指针，以防一一混淆
    while (cur != NULL)
    {
        printf("%d->", cur->data);
        cur = cur->next;
    }
    printf("NULL\n");
} 

//创建一个新的节点

SLTNode* SLTBuyNode()
{
    SLTNode* newnode = NULL;
    newnode = (SLTNode*)malloc(sizeof(SLTNode));
    assert(newnode);//保证malloc成功再返回
    return newnode;
}

//头插

void SLTPushFront(SLTNode** pphead,SLTDataType data)//使用二级指针的原因是这样可以改变一级指针的值
{
    if (*pphead == NULL)//  如果为空，单独处理
    {
        SLTNode* pnewnode = SLTBuyNode();
        pnewnode->data = data;
        pnewnode->next = NULL;
        *pphead = pnewnode;
    }
    else//  不为空则可以找到pnewnode指向的节点
    {
        SLTNode* pnewnode = SLTBuyNode();
        pnewnode->data = data;
        pnewnode->next = *pphead;
        *pphead = pnewnode;
    }
} 

//尾插

void SLTPushBack(SLTNode** pphead, SLTDataType data)
{
    if (*pphead == NULL)
    {
        SLTNode* pnewnode = SLTBuyNode();
        pnewnode->data = data;
        pnewnode->next = NULL;
        *pphead = pnewnode;
    }
    else
    {
        SLTNode* q = *pphead;
        while (q->next != NULL)
        {
            q = q->next;
        }
        SLTNode* pnewnode = SLTBuyNode();
        pnewnode->data = data;
        pnewnode->next = NULL;
        q->next = pnewnode;
    }
} 

//头删
void SLTPopFront(SLTNode** pphead)
{
    assert(*pphead);
    if ((*pphead)->next == NULL)//注意一定要有括号不然->会先结合pphead导致报错
    {
        free(*pphead);
        *pphead = NULL;
    }
    else
    {
        SLTNode* p = *pphead;//把管理头节点的指针记下来
        *pphead = (*pphead)->next;
        free(p);
    }
} 

//尾删

 void SLTPopBack(SLTNode** pphead)
{
    assert(*pphead);
    if ((*pphead)->next == NULL)//注意一定要有括号不然->会先结合pphead导致报错
    {
        free(*pphead);
        *pphead = NULL;
    }
    else
    {
        SLTNode* p1 = *pphead;//记录p2前一个指针方便修改对应空间的指针为空
        SLTNode* p2 = (*pphead)->next;//维护待删除空间的指针
        while (p2->next != NULL)
        {
            p1 = p1->next;
            p2 = p2->next;
        }
        free(p2);
        p1->next = NULL;//因为对应空间已被释放，必须将其指针赋值为空，不然可能非法访问
    }
}

 

SLNode* SLFind(SLNode* phead, SLDataType x)
{
    //assert(phead);空链表可以查找，不需要断言
    SLNode* cur = phead;
    while (cur)//此处不能是cur->next否则会遗漏掉最后一个节点的查找，无法进入循环
    {
        if (cur->data == x)
        {
            return cur;
        }
        cur = cur->next;
    }
    return NULL;
}//可以用来修改节点的值。妙啊

//ps:不是每个地方都需要断言的，可以为空的时候不需要断言，删除的时候才需要断言

//在pos后面插入，不需定义前驱指针，方便一些
void SLInsertBack(SLNode* pos, SLDataType x)
{
    assert(pos);
    //不需要传二级指针，原因定义不插在空节点之后
    /*if (pos->next==NULL)
    {
        SLPushBack(pphead, x);
    }*/   //可以与后面合并

    SLNode* pnewnode = SLBuyNode();
    pnewnode->data = x;
    pnewnode->next = pos->next;
    pos->next = pnewnode;
}

//删除一个节点前面的节点
void SLErase(SLNode** pphead, SLNode* pos)
{
    assert(pphead);
    assert(pos);

    //如果只有一个节点，按头删处理
    if (pos == *pphead)
    {
        SLPopFront(pphead);
    }

    // 两个节点以上找到前驱节点
    else
    {
        SLNode* prev = *pphead;
        while (prev->next != pos)
        {
            prev = prev->next;
        }
        prev->next = pos->next;
        free(pos);
    }
}

//删除一个节点后面的节点
void SLEraseBack(SLNode* pos)
{
    assert(pos);
    assert(pos->next);//后面必须要有节点才能删除
    SLNode* p = pos->next;
    pos->next = p->next;
    free(p);
}

int main()
{
    SLTNode* phead = NULL;

     //用于测试的部分
    return 0;
}