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("头结点的内存申请失败!\n");
         return NULL;
     }
     phead->pNext = NULL;
     //phead->data   可以赋值也可以不赋值,因为头结点不存储数据
     //.它只是用来标记链表的头部
     //有表头的链表头结点都不存储数据,只是用来标记链表的头部
     return phead;
 }

 //2.写一个创建结点的函数,用来申请结点内存
 PLIST CreateListNode(int data)
 {
     PLIST newNode = (PLIST)malloc(sizeof(LIST));
     if (NULL == newNode)
     {
         printf("结点内存申请失败!\n");
         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 = ; i < pos; i++)
     {
         if (p_Temp1->pNext != NULL)
         {
             p_Temp1 = p_Temp1->pNext;
             if (i>)
             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\n");
 }
 //删除    删除头结点  指定位置删除  尾部删除
 //知道这个逻辑     多画图 多写代码
 //后面还会有双向循环链表 要处理四个指针  现在只需要处理两个 双向循环链表不画图很难理解
 //画图之后会发现很简单 只需要照着画的图去链接各个指针就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 == )
     {
         return ;
     }
     else
     {
         return n + fun(n - );
     }  //5 +4+3+2+1    //函数嵌套调用
     for (int i = ; i < ; i++)
     {
         for (int j = ; j < ; j++)
         {
               ///内循环结束又回到了外循环
         }
     }
 }

 int main()
 {
     PLIST head = CreateListHead();  //创建头部 把堆内存的首地址返回给head
     for (int i = ; i <= ; 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 ;
 }

附：