C++学习（三十五）（C语言部分）之 单链表

 单链表 就好比火车

火车头-->链表头部
火车尾-->链表尾部
火车厢-->链表的节点
火车厢连接的部分-->指针
火车中的内容-->链表节点的的数据
链表节点包含数据域和指针域
数据域存放数据
指针域存放要连接的节点的首地址

在造火车的时候 先是火车头 然后是车厢
--->链表的首节点和之后的节点

先从内存中申请头结点的存储空间
--->PLTST phead=(PLTST)malloc(sizeof(LTST));
首节点在创建时会让指针域指向空
--->既链表的初始化

链表连接的规则，要先连接后断开
对于单链表的插入有两种方法
1、头插法
2、尾插法（比较简单的）

尾插法 申请好一个新的节点后将链表的最后一个节点的指针域指向新节点

头插法 首先创建新节点，找到链表头节点，将指针指向新节点，将新节点指针指向第二节点

单链表测试代码笔记如下：

#include<stdio.h>
#include <stdlib.h> //malloc 要用到

typedef struct Node
{
    int data;  //数据域：用来存放数据
    struct Node* pNext;  //指针域：用来存储下一个结点地址
}LIST,*PLIST;

//1. 创建一个火车头.  相当于创建链表 =用函数来创建一个链表的头部
//创建链表的头部
PLIST CreateListHead()
{
       //1.1 申请内存
    PLIST phead = (PLIST)malloc(sizeof(LIST));
    //1.2 判断是否申请成功
    if (NULL == phead)
    {
        printf("头结点的内存申请失败!
");
        return NULL; 
    }
    phead->pNext = NULL;
    //phead->data   可以赋值也可以不赋值,因为头结点不存储数据
    //.它只是用来标记链表的头部
    //有表头的链表头结点都不存储数据,只是用来标记链表的头部
    return phead;
}

//2.写一个创建结点的函数,用来申请结点内存
PLIST CreateListNode(int data)
{
    PLIST newNode = (PLIST)malloc(sizeof(LIST));
    if (NULL == newNode)
    {
        printf("结点内存申请失败!
");
        return NULL;
    }
    newNode->pNext = NULL;
    newNode->data = data;
    return newNode;
}

//3.插入一个结点   头部插入  指定位置插入  尾部插入
void InsertListHead(PLIST p_list, int data)//1. 要说明要插入的链表是哪一个 2.要插入的数据
{
    //3.1 申请一个结点
    PLIST node = CreateListNode(data);
    //先连接后断开
    node->pNext = p_list->pNext;
    p_list->pNext = node;
}

//4. 尾插法
void InsertListTail(PLIST p_list, int data)
{
    //4.1 申请结点内存
    PLIST node = CreateListNode(data);
    //我们只知道链表的头部  尾部就要去遍历得到
    PLIST p_Temp = p_list;
    //遍历找到尾结点
    while (p_Temp->pNext!=NULL)  //  表达式非0就是真
    {
        p_Temp = p_Temp->pNext;
    }
    //循环结束 就是找到了最后一个结点
    node->pNext = NULL;
    p_Temp->pNext = node;
}

//在链表p_list中的pos位置插入data
void InsertListAppoint(PLIST p_list, int pos, int data)
{
    PLIST node = CreateListNode(data);
    PLIST p_Temp1 = p_list;
    PLIST p_Temp2 = p_list;
    for (int i = 0; i < pos; i++)
    {
        if (p_Temp1->pNext != NULL)
        {
            p_Temp1 = p_Temp1->pNext;
            if (i>0)
            p_Temp2 = p_Temp2->pNext;
        }
        else
        {   //如果pos大于链表结点的个数,就插入到尾部
            p_Temp1->pNext = node;
            node->pNext = NULL;
            return;   //退出函数 不往下执行
        }
    }
    //循环结束  --> 说明我找到了我要插入的位置
    node->pNext = p_Temp1;
    p_Temp2->pNext = node;

}

//  遍历链表的每一个结点
void PrintList(PLIST p_list)
{
    PLIST p_Temp = p_list->pNext; //从头部的下一个结点开始输出里面的数据
    while (p_Temp)
    {
        printf("%d -> ", p_Temp->data);//打印结点里面的数据
        p_Temp = p_Temp->pNext;
    }
    printf("NULL
");
}
//删除    删除头结点  指定位置删除  尾部删除
//知道这个逻辑     多画图 多写代码  
//后面还会有双向循环链表 要处理四个指针  现在只需要处理两个 双向循环链表不画图很难理解
//画图之后会发现很简单 只需要照着画的图去链接各个指针就OK了
void DeleteListHead(PLIST p_list)  //PLIST p_list=head.
{
    PLIST p_Temp = p_list->pNext;
    //先链接还是先释放 
    p_list->pNext = p_Temp->pNext;  //连接
    free(p_Temp);
}

//不用循环 删除所有结点
void DeleteList(PLIST p_list)//函数会执行5  5 4 3 2 1
{
    //满足条件的情况下 自己调用自己
    if (p_list->pNext!=NULL)   //if括号里面不是0就是成立
    {
        DeleteList(p_list->pNext);
    }
    free(p_list);

}

int fun(int n)
{
    if (n == 1)
    {
        return 1;
    }
    else
    {
        return n + fun(n - 1);
    }  //5 +4+3+2+1    //函数嵌套调用
    for (int i = 0; i < 5; i++)
    {
        for (int j = 1; j < 5; j++)
        {
              ///内循环结束又回到了外循环
        }
    }
}

int main()
{
    PLIST head = CreateListHead();  //创建头部 把堆内存的首地址返回给head
    for (int i = 1; i <= 5; i++)
        InsertListHead(head, i);
    PrintList(head);

    ////尾插法
    //InsertListTail(head, 98);
    //PrintList(head);

    ////指定位置插入
    //InsertListAppoint(head, 2, 520);
    //PrintList(head);
    //InsertListAppoint(head, 88, 520);
    //PrintList(head);
    //DeleteListHead(head);
    //PrintList(head);

    DeleteList(head);
    PrintList(head);
    head = NULL;
    return 0;
}

 附：