单链表

• 1. 单链表
• • 1.1 单链表的优缺点
  • 1.2 单链表的基本操作
• 2.实现单链表的代码准备
• 3. 顺序表代码实现
• • 3.1 单链表结构体的定义
  • 3.2 声明单链表中需要实现的功能
  • 3.3 单链表的打印
  • 3.4 为需要插入的数据创建新节点
  • 3.5 单链表——头插
  • 3.6 单链表——头删
  • 3.7 单链表——尾插
  • 3.8 单链表——尾删
  • 3.9 单链表 ——查找
  • 3.10 在指定位置之前插入
  • 3.11 在指定位置之后插入
  • 3.12 在指定位置之前插入
  • 3.13 删除指定位置pos节点
  • 3.14 删除指定节点pos之后的节点
  • 3.15 销毁链表
• 4.完整代码

1. 单链表

• 单链表是一种线性的数据结构，其中的结点通过指针链接在一起。与数组不同，单链表中的结点不一定存储在连续的内存位置上。每个节点包含两部分：一是存储的数据，另一个是指针——指向列表中的下一个元素的地址。它可以动态地添加或删除元素，而不用大规模移动其他元素。

1.1 单链表的优缺点

1. 单链表的优点
   • 动态大小：随时添加或删除元素。
   • 插入和删除操作快：不需要移动元素，只需要更新指针。
2. 单链表的缺点
   • 访问速度慢：要访问链表中的某个元素，需要从头开始遍历链表。
   • 额外的空间开销：每个节点都需要额外的指针空间。

1.2 单链表的基本操作

1. 创建空链表：初始化一个头指针指向 NULL。
2. 插入节点——头插
3. 插入节点——尾插
4. 插入节点——指定位置之前插入
5. 插入节点——指定位置之后插入
6. 删除节点：——尾删
7. 删除节点——头删
8. 删除节点——指定位置的结点
9. 删除节点——指定位置之后的结点
10. 查找节点：可以在链表中查找具有特定值的节点。
11. 打印链表：可以按顺序访问链表中的每个节点。
12. 销毁链表：释放链表中所有节点所占的内存。

2.实现单链表的代码准备

1. SList.h: 头文件
   • 头文件包含了单链表相关的数据结构的定义和函数声明。它是公共接口，用于获取其他源文件如何使用单链表的功能等信息。同时保持代码的清晰性和可维护性。
2. SList.c: 实现文件
   • 实现文件包含了单链表功能的具体实现细节。隐藏实现细节，便于维护和更新。使头文件更加精简，只包含必要的声明，具体的实现则在 .c 文件中进行。
3. Test.c: 测试文件
   • 测试文件用于测试单链表的功能。包含主函数 main 以及一系列测试用例来验证单链表的正确性。确保测试代码不会干扰到单链表的实现，使测试变得更加独立。

3. 顺序表代码实现

在实现顺序表时需要用到的头文件：
,,

3.1 单链表结构体的定义

在SList.h中定义数据结构：

#include  #include  #include  typedef int SLTDataType; typedef struct SListNode { 	SLTDataType data;//存储节点的实际数据 	struct SListNode* next;//指向下一个节点的指针 }SLTNode; 

1. typedef int SLTDataType;
   • typedef：关键字 typedef 用于定义类型别名，即为现有的类型起一个新的名字。
   • SLTDataType;：这里定义了一个类型别名 SLTDataType，它实际上就是 int 类型。
2. typedef struct SListNode { ... } SLTNode;
   • struct SListNode：定义了一个 SListNode 的结构体类型。
   • SLTDataType data;：结构体中包含一个 data 的成员，其类型为 SLTDataType（即 int）。
   • struct SListNode* next;：结构体中包含一个名为 next 的成员，它指向 SListNode 类型的指针，用于连接单链表中的下一个节点。
3. SLTNode
   • SLTNode：这是 typedef 为 struct SListNode 定义的一个类型别名。

3.2 声明单链表中需要实现的功能

在SList.h中声明：

#include  #include  #include   typedef int SLTDataType; typedef struct SListNode { 	SLTDataType data; 	struct SListNode* next; }SLTNode;  //链表的打印 void SLTPrint(SLTNode* phead); //开辟空间 SLTNode* SLTBuyNode(SLTDataType x);  //头部插入删除/尾部插入删除 void SLTPushBack(SLTNode** pphead, SLTDataType x); void SLTPushFront(SLTNode** pphead, SLTDataType x); void SLTPopBack(SLTNode** pphead); void SLTPopFront(SLTNode** pphead);  //查找 SLTNode* SLTFind(SLTNode* phead, SLTDataType x); //在指定位置之前插入数据 void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x); //删除pos节点 void SLTErase(SLTNode** pphead, SLTNode* pos); //在指定位置之后插入数据 void SLTInsertAfter(SLTNode* pos, SLTDataType x); //删除pos之后的节点 void SLTEraseAfter(SLTNode* pos); //销毁链表 void SListDesTroy(SLTNode** pphead); 

3.3 单链表的打印

• 为了方便其他功能在测试时更加直观的观察，先实现单链表的打印,遍历单链表：

//链表的打印 void SLTPrint(SLTNode* phead) { 	SLTNode* pcur = phead; 	while (pcur != NULL) 	{ 		printf("%d -> ", pcur->data); 		pcur = pcur->next; 	} 	printf("NULL\n"); } 

3.4 为需要插入的数据创建新节点

1. 分配内存：
   • SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));：使用 malloc 函数为新节点分配内存。这里分配的内存大小为 sizeof(SLTNode)，即新节点的大小。
2. 检查内存分配结果：
   • if (newnode == NULL)：检查 malloc 函数是否成功分配内存。如果 newnode 为 NULL，说明内存分配失败。
   • perror("malloc fail!");：如果内存分配失败，使用 perror 函数输出错误信息。
     exit(1);：如果内存分配失败，使用 exit(1) 终止程序执行。1 是一个非零值，表示程序异常终止。
3. 初始化新节点：
   • newnode->data = x;：将新节点的数据域设置为传入的参数 x。
   • newnode->next = NULL;：将新节点的 next 指针设置为 NULL。这表示新节点是链表的最后一个节点（如果链表为空）或新节点还没有与链表连接起来。
     返回新节点：
   • return newnode;：返回指向新节点的指针。

SLTNode* SLTBuyNode(SLTDataType x) { 	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode)); 	if (newnode == NULL) 	{ 		perror("malloc fail!"); 		exit(1); 	} 	newnode->data = x; 	newnode->next = NULL;  	return newnode; } 

3.5 单链表——头插

1. 参数检查：
   • assert(pphead);：确保传入的指针 pphead 不是 NULL。如果 pphead 是 NULL，assert 会断言失败，避免后续代码试图访问未初始化的指针。
2. 创建新节点：
   • SLTNode* newnode = SLTBuyNode(x);：调用 SLTBuyNode 函数创建一个新的节点，并将数据 x 存储在新节点中。
3. 更新新节点的 next 指针：
   • newnode->next = *pphead;：将新节点的 next 指针设置为当前链表的头结点。将新节点与原链表连接起来。
4. 更新头指针：
   • *pphead = newnode;：更新头指针 pphead，使其指向新节点。确保了 pphead 指向链表的新头结点。

//头插 void SLTPushFront(SLTNode** pphead, SLTDataType x) { 	assert(pphead); 	SLTNode* newnode = SLTBuyNode(x);//为头插申请空间 	newnode->next = *pphead;//将新数据与原来头节点联系起来 	*pphead = newnode;//保证指针pphead里面始终指向头节点 } 

3.6 单链表——头删

1. 参数检查：
   assert(pphead && *pphead)：保证传入的指针 pphead 不是 NULL，并且 pphead 指向的链表头结点也不为 NULL。如果 pphead 或者 *pphead 是 NULL，assert 会断言失败，避免后续代码试图访问未初始化的指针或删除空节点。
2. 保存下一个节点的指针：
   SLTNode* next = (*pphead)->next;：获取当前链表头结点的下一个节点的指针。在删除头结点之后，将头指针更新为下一个节点。
3. 释放头结点占用的内存：
   free(*pphead);：释放当前链表头结点占用的内存。确保资源的有效回收，避免内存泄漏。
4. 更新头指针：
   *pphead = next;：更新头指针 pphead，使其指向下一个节点。如果链表中只有一个节点，那么 next 为 NULL，这将使 pphead 也指向 NULL，表示链表为空。

//头删 void SLTPopFront(SLTNode** pphead) { 	assert(pphead && *pphead); 	SLTNode* next = (*pphead)->next; 	free(*pphead); 	*pphead = next; } 

3.7 单链表——尾插

1. 参数检查：
   assert(pphead);：保证传入的指针 pphead 不是 NULL。如果 pphead 是 NULL，assert 会断言失败，避免后续代码试图访问未初始化的指针。
2. 创建新节点：
   SLTNode* newnode = SLTBuyNode(x);：调用 SLTBuyNode 函数创建一个新的节点，并将数据 x 存储在新节点中。SLTBuyNode 函数为新节点分配内存，并初始化节点。
3. 处理空链表的情况：
   if (*pphead == NULL)：检查链表是否为空。如果是空链表，则直接将新节点设置为头结点。
   *pphead = newnode;：将新节点设置为头结点，此时链表中只有一个节点。
4. 处理非空链表的情况：
   SLTNode* ptail = *pphead;：定义一个指针 ptail，初始化为链表的头结点。
   while (ptail->next != NULL)：遍历链表直到找到最后一个节点。
   ptail = ptail->next;：移动 ptail 指针到下一个节点。
   ptail->next = newnode;：将新节点连接到链表的末尾。

//链表的尾插 void SLTPushBack(SLTNode** pphead, SLTDataType x) { 	assert(pphead); 	SLTNode* newnode = SLTBuyNode(x);  	//空链表和非空链表两种情况 	if (*pphead == NULL) 	{ 		*pphead = newnode; 	} 	else 	{ 		SLTNode* ptail = *pphead; 		//找尾 		while (ptail->next != NULL) 		{ 			ptail = ptail->next; 		} 		ptail->next = newnode; 	} } 

3.8 单链表——尾删

1. 参数检查：
   • assert(pphead && *pphead);：确保传入的指针 pphead 不是 NULL，并且 pphead 指向的链表头结点也不为 NULL。如果 pphead 或者 *pphead 是 NULL，assert 会断言失败，避免后续代码试图访问未初始化的指针或删除空节点。
2. 处理空链表的情况：
   • if (*pphead == NULL)：检查链表是否为空。如果链表为空，那么 *pphead 保持为 NULL，表示链表仍然为空。
   • *pphead = NULL;：如果链表已经为空，那么再次设置 *pphead 为 NULL
3. 处理非空链表的情况：
   • SLTNode* ptail = *pphead;：定义一个指针 ptail，初始化为链表的头结点。
   • SLTNode* prev = *pphead;：定义另一个指针 prev，初始化为链表的头结点。prev 用于记录最后一个节点的前一个节点。
   • while (ptail->next != NULL)：遍历链表直到找到最后一个节点。
   • prev = ptail;：移动 prev 指针到下一个节点。
   • ptail = ptail->next;：移动 ptail 指针到下一个节点。
   • free(ptail);：释放最后一个节点占用的内存。
   • ptail = NULL;：将 ptail 设置为 NULL，以避免悬空指针。
   • prev->next = NULL;：将最后一个节点的前一个节点的 next 指针设置为 NULL，切断与最后一个节点的链接。

//尾删 void SLTPopBack(SLTNode** pphead) { 	assert(pphead && *pphead); 	if ((*pphead) == NULL) 	{ 		*pphead = NULL; 	} 	else 	{ 		SLTNode* ptail = *pphead; 		SLTNode* prev = *pphead;  		while (ptail->next != NULL) 		{ 			prev = ptail; 			ptail = ptail->next; 		} 		free(ptail); 		ptail = NULL; 		prev->next = NULL; 	} } 

3.9 单链表 ——查找

1. 初始化指针：
   • SLTNode* pcur = phead;：定义一个指针 pcur，初始化为链表的头结点。
2. 遍历链表：
   • while (pcur)：遍历链表，只要 pcur 不为 NULL（即还有节点未遍历），就继续循环。
3. 检查节点数据：
   • if (pcur->data == x)：检查当前节点是否等于查找的目标值 x。
   • return pcur;：如果找到了匹配的节点，立即返回该节点的指针。
4. 移动指针：
   • pcur = pcur->next;：如果没有找到匹配的节点，则将 pcur 指针移动到下一个节点，继续搜索。
5. 返回结果：
   • 如果遍历完整个链表都没有找到匹配的节点，则返回 NULL。

//查找 SLTNode* SLTFind(SLTNode* phead, SLTDataType x) { 	SLTNode* pcur = phead; 	while (pcur) 	{ 		if (pcur->data == x) 		{ 			return pcur; 		} 		pcur = pcur->next; 	} 	return NULL; } 

3.10 在指定位置之前插入

1. 参数检查：
   • assert(pphead && *pphead);：确保传入的指针 pphead 不是 NULL，并且 pphead 指向的链表头结点也不为 NULL。如果 pphead 或者 *pphead 是 NULL，assert 会断言失败,避免后续代码试图访问未初始化的指针。
   • assert(pos);：确保 pos 参数不是 NULL，pos 指向链表中的一个有效节点。
2. 创建新节点：
   • SLTNode* newnode = SLTBuyNode(x);：调用 SLTBuyNode 函数创建一个新的节点，并将数据 x 存储在新节点中。
3. 处理头插的情况：
   • if (pos == *pphead)：如果 pos 指向的是链表的头结点，那么这实际上是一个头插操作。
   • SLTPushFront(pphead, x);：调用 SLTPushFront 函数执行头插操作。
4. 处理非头插的情况：
   • SLTNode* prev = *pphead;：定义一个指针 prev，初始化为链表的头结点。
   • while (prev->next != pos)：遍历链表，直到找到 pos 的前一个节点。
   • prev = prev->next;：移动 prev 指针到下一个节点。
   • newnode->next = pos;：将新节点的 next 指针设置为 pos。
   • prev->next = newnode;：将 pos 的前一个节点的 next 指针设置为新节点。

//指定位置插入之前数据 void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x) { 	assert(pphead && *pphead); 	assert(pos); 	SLTNode* newnode = SLTBuyNode(x);  	//若pos == *pphead,说明头插，可以直接调用头插函数 	if (pos == *pphead) 	{ 		SLTPushFront(pphead, x); 	} 	else 	{ 		SLTNode* prev = *pphead; 		while (prev->next != pos) 		{ 			prev = prev->next; 		} 		newnode->next = pos; 		prev->next = newnode; 	} } 

3.11 在指定位置之后插入

1. 参数检查：
   assert(pos);：确保 pos 不是 NULL。
2. 创建新节点：
   SLTNode* newnode = SLTBuyNode(x);：调用 SLTBuyNode 函数创建一个新的节点，并将数据 x 存储在新节点中。
3. 更新新节点的 next 指针：
   newnode->next = pos->next;：将新节点的 next 指针设置为 pos 节点的下一个节点。将新节点与原链表连接起来。
4. 更新 pos 节点的 next 指针：
   pos->next = newnode;：将 pos 节点的 next 指针设置为新节点。将 pos 节点与新节点连接起来。

//在指定位置之后插入数据 void SLTInsertAfter(SLTNode* pos, SLTDataType x) { 	assert(pos); 	SLTNode* newnode = SLTBuyNode(x);  	newnode->next = pos->next; 	pos->next = newnode; } 

3.12 在指定位置之前插入

1. 参数检查：确保 pphead 和 *pphead 都不是 NULL，并且 pos 也不是 NULL。
2. 创建新节点：使用 SLTBuyNode 函数创建新节点，并设置新节点的数据域。
3. 处理头插的情况：如果 pos 指向的是头结点，直接调用头插函数。
4. 处理非头插的情况：
   • 遍历链表找到 pos 的前一个节点。
   • 将新节点的 next 指针设置为 pos。
   • 将 pos 的前一个节点的 next 指针设置为新节点。

//指定位置插入之前数据 void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x) { 	assert(pphead && *pphead); 	assert(pos); 	SLTNode* newnode = SLTBuyNode(x);  	//若pos == *pphead,说明头插，可以直接调用头插函数 	if (pos == *pphead) 	{ 		SLTPushFront(pphead, x); 	} 	else 	{ 		SLTNode* prev = *pphead; 		while (prev->next != pos) 		{ 			prev = prev->next; 		} 		newnode->next = pos; 		prev->next = newnode; 	} } 

3.13 删除指定位置pos节点

1.参数检查：确保 pphead 和 *pphead 都不是 NULL，并且 pos 也不是 NULL。
2. 处理头节点删除的情况：如果 pos 指向的是头结点，直接调用头删函数。
3. 处理非头节点删除的情况：

• 遍历链表找到 pos 的前一个节点。
• 修改 pos 的前一个节点的 next 指针，跳过 pos。
• 释放 pos 节点占用的内存，并将 pos 设置为 NULL。

void SLTErase(SLTNode** pphead, SLTNode* pos) { 	assert(pphead && *pphead); 	assert(pos); 	if (pos == *pphead)//pos是头节点 	{ 		SLTPopFront(pphead); 	} 	else 	{ 		SLTNode* prev = *pphead; 		while (prev->next != pos) 		{ 			prev = prev->next; 		} 		prev->next = pos->next; 		free(pos); 		pos = NULL; 	} } 

3.14 删除指定节点pos之后的节点

1. 参数检查：确保 pos 和 pos->next 都不是 NULL。
2. 保存要删除的节点：使用 del 指针指向要删除的节点。
3. 修改 pos 节点的 next 指针：将 pos 节点的 next 指针设置为 del 节点的下一个节点。
4. 释放 del 节点占用的内存：释放 del 节点占用的内存。
5. 将 del 设置为 NULL：将 del 设置为 NULL，避免悬空指针。

//删除pos之后的结点 void SLTEraseAfter(SLTNode* pos) { 	assert(pos && pos->next); 	SLTNode* del = pos->next; 	pos->next = del->next; 	free(del); 	del = NULL; } 

3.15 销毁链表

1. 参数检查：确保 pphead 和 *pphead 都不是 NULL。
2. 遍历链表并释放内存：
   • 使用 pcur 指针遍历链表。
   • 保存当前节点的下一个节点的指针。
   • 释放当前节点占用的内存。
   • 移动 pcur 指针到下一个节点。
3. 设置头指针为 NULL：遍历完成后，将头指针设置为 NULL。

//销毁链表 void SListDesTroy(SLTNode** pphead) { 	assert(pphead && *pphead); 	SLTNode* pcur = *pphead; 	while (pcur) 	{ 		SLTNode* next = pcur->next; 		free(pcur); 		pcur = next; 	} 	*pphead = NULL; } 

4.完整代码

SList.h:

#define _CRT_SECURE_NO_WARNINGS 1 #include  #include  #include   typedef int SLTDataType; typedef struct SListNode { 	SLTDataType data; 	struct SListNode* next; }SLTNode;   //链表的打印 void SLTPrint(SLTNode* phead); //开辟空间 SLTNode* SLTBuyNode(SLTDataType x);  //头部插入删除/尾部插入删除 void SLTPushBack(SLTNode** pphead, SLTDataType x); void SLTPushFront(SLTNode** pphead, SLTDataType x); void SLTPopBack(SLTNode** pphead); void SLTPopFront(SLTNode** pphead);  //查找 SLTNode* SLTFind(SLTNode* phead, SLTDataType x); //在指定位置之前插入数据 void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x); //删除pos节点 void SLTErase(SLTNode** pphead, SLTNode* pos); //在指定位置之后插入数据 void SLTInsertAfter(SLTNode* pos, SLTDataType x); //删除pos之后的节点 void SLTEraseAfter(SLTNode* pos); //销毁链表 void SListDesTroy(SLTNode** pphead); 

SList.c:

#pragma once #include "SList.h"  //链表的打印 void SLTPrint(SLTNode* phead) { 	SLTNode* pcur = phead; 	while (pcur != NULL) 	{ 		printf("%d -> ", pcur->data); 		pcur = pcur->next; 	} 	printf("NULL\n"); }  //开辟空间 SLTNode* SLTBuyNode(SLTDataType x) { 	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode)); 	if (newnode == NULL) 	{ 		perror("malloc fail!"); 		exit(1); 	} 	newnode->data = x; 	newnode->next = NULL;  	return newnode; }  //链表的尾插 void SLTPushBack(SLTNode** pphead, SLTDataType x) { 	assert(pphead); 	SLTNode* newnode = SLTBuyNode(x);  	//空链表和非空链表两种情况 	if (*pphead == NULL) 	{ 		*pphead = newnode; 	} 	else 	{ 		SLTNode* ptail = *pphead; 		//找尾 		while (ptail->next != NULL) 		{ 			ptail = ptail->next; 		} 		ptail->next = newnode; 	} }  //头插 void SLTPushFront(SLTNode** pphead, SLTDataType x) { 	assert(pphead); 	SLTNode* newnode = SLTBuyNode(x);//为头插申请空间 	newnode->next = *pphead;//将新数据与原来头节点联系起来 	*pphead = newnode;//保证指针pphead里面始终指向头节点 }  //尾删 void SLTPopBack(SLTNode** pphead) { 	assert(pphead && *pphead); 	if ((*pphead) == NULL) 	{ 		*pphead = NULL; 	} 	else 	{ 		SLTNode* ptail = *pphead; 		SLTNode* prev = *pphead;  		while (ptail->next != NULL) 		{ 			prev = ptail; 			ptail = ptail->next; 		} 		free(ptail); 		ptail = NULL; 		prev->next = NULL; 	} }  //头删 void SLTPopFront(SLTNode** pphead) { 	assert(pphead && *pphead); 	SLTNode* next = (*pphead)->next; 	free(*pphead); 	*pphead = next; }  //查找 SLTNode* SLTFind(SLTNode* phead, SLTDataType x) { 	SLTNode* pcur = phead; 	while (pcur) 	{ 		if (pcur->data == x) 		{ 			return pcur; 		} 		pcur = pcur->next; 	} 	return NULL; }   //指定位置插入之前数据 void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x) { 	assert(pphead && *pphead); 	assert(pos); 	SLTNode* newnode = SLTBuyNode(x);  	//若pos == *pphead,说明头插，可以直接调用头插函数 	if (pos == *pphead) 	{ 		SLTPushFront(pphead, x); 	} 	else 	{ 		SLTNode* prev = *pphead; 		while (prev->next != pos) 		{ 			prev = prev->next; 		} 		newnode->next = pos; 		prev->next = newnode; 	} }  //在指定位置之后插入数据 void SLTInsertAfter(SLTNode* pos, SLTDataType x) { 	assert(pos); 	SLTNode* newnode = SLTBuyNode(x);  	newnode->next = pos->next; 	pos->next = newnode; }  //删除pos结点 void SLTErase(SLTNode** pphead, SLTNode* pos) { 	assert(pphead && *pphead); 	assert(pos); 	if (pos == *pphead)//pos是头节点 	{ 		SLTPopFront(pphead); 	} 	else 	{ 		SLTNode* prev = *pphead; 		while (prev->next != pos) 		{ 			prev = prev->next; 		} 		prev->next = pos->next; 		free(pos); 		pos = NULL; 	} }  //删除pos之后的结点 void SLTEraseAfter(SLTNode* pos) { 	assert(pos && pos->next); 	SLTNode* del = pos->next; 	pos->next = del->next; 	free(del); 	del = NULL; }  //销毁链表 void SListDesTroy(SLTNode** pphead) { 	assert(pphead && *pphead); 	SLTNode* pcur = *pphead; 	while (pcur) 	{ 		SLTNode* next = pcur->next; 		free(pcur); 		pcur = next; 	} 	*pphead = NULL; } 

Test.c:

#define _CRT_SECURE_NO_WARNINGS 1 #include "SList.h" void SListTest() { 	//测试尾插 	SLTNode* plist = NULL; 	SLTPushBack(&plist, 1); 	SLTPushBack(&plist, 3); 	SLTPushBack(&plist, 1); 	SLTPushBack(&plist, 4); 	SLTPrint(plist); 	SLTPushBack(&plist, 5); 	SLTPushBack(&plist, 2); 	SLTPushBack(&plist, 0); 	SLTPrint(plist);  	//测试头插 	SLTPushFront(&plist, 0); 	SLTPushFront(&plist, 2); 	SLTPushFront(&plist, 5); 	SLTPrint(plist);  	//测试尾删 	SLTPopBack(&plist); 	SLTPopBack(&plist); 	SLTPopBack(&plist); 	SLTPrint(plist);  	//测试头删 	SLTPopFront(&plist); 	SLTPrint(plist); 	SLTPopFront(&plist); 	SLTPrint(plist); 	SLTPopFront(&plist); 	SLTPrint(plist);  	//测试查找 	SLTNode* find = SLTFind(plist, 3); 	if (find == NULL) 	{ 		printf("没有找到！\n"); 	} 	else 	{ 		printf("找到了！\n"); 	}  	//测试指定位置之前插入数据 	/*SLTNode* find = SLTFind(plist, 3);*/ 	SLTInsert(&plist, find, 520); 	SLTPrint(plist);  	//测试指定位置之后插入数据 	SLTInsertAfter(find,1314); 	SLTPrint(plist);  	测试删除pos结点 	//SLTErase(&plist, find); 	//SLTPrint(plist);  	//测试删除pos之后结点 	SLTEraseAfter(find); 	SLTPrint(plist);  	//销毁链表 	SListDesTroy(&plist); 	SLTPrint(plist); }  int main() { 	SListTest(); 	return 0;  }