単連結リスト（データ構造）（C言語）

これは、特に非セントリ ビットの一方向非循環リンク リストを指します。

目次

バックグラウンド

コンセプト

単一リンクリストの実装

見通しのヒント

単一リンクリスト構造定義

単一リンクリストの印刷

pheadがアサートされない理由について

単連結リストの論理構造と物理構造について

単一リンクリストの末尾挿入

セカンダリポインタが使用される理由について

テールプラグの性質について

尾部発見の全過程の説明

単一リンクリストを出力するためにセカンダリポインタを渡す必要がない理由について

単一リンクリストの動的アプリケーションノード

シングルリンクリストヘッドプラグ

単一リンクリストの末尾削除

単一リンクリストの先頭を削除する

リンクされたリストの検索

単一リンクリストは、pos 位置の前に x を挿入します (pos 位置に挿入すると理解することもできます)。

単一リンクリストは、pos 位置より前の値を削除します (pos 位置の値を削除すると理解することもできます)。

単一リンクリストは pos 位置の後に x を挿入します 

単一リンクリストは、pos 位置の後の値を削除します

ヘッダーポインタを通さずにposの前に挿入・削除する方法について（独創的）

単一リンクリストの破棄

合計コード (結果を直接確認したい場合は、ここで確認できます)

---

バックグラウンド

前回の記事では、シーケンス テーブルについて学びました。

ただし、シーケンシャル テーブルには連続した物理スペースが必要であり、次のような欠点があります。

1. 中間/先頭の挿入と削除、時間計算量は O(N) です。

2. 容量を増やすには、新しいスペースを申請し、データをコピーし、古いスペースを解放する必要があります。消費量も多くなるでしょう。

3. 容量の増加は通常 2 倍であり、ある程度のスペースの無駄が必ず発生します。たとえば、現在の容量が 100 で、いっぱいになると 200 に増やされます。さらに 5 個のデータを挿入し続けます。その後データは挿入されないため、95 個のデータ スペースが無駄になります。

上記の問題をより適切に解決するために、リンク リストを拡張しました。

---

コンセプト

リンクされたリストは、 物理的な 記憶構造における非順次的かつ非順次的な記憶 構造 あり、データ要素の論理的順序は、リンクされたリストにおける ポインタ 実現される。リンクリストの１つのデータは、１つのメモリブロックに格納される。リンク リストは一連のノードで構成され (リンク リストの各要素はノードと呼ばれます)、ノードは実行時に動的に生成できます。各ノードは 2 つの部分で構成されます。1 つはデータ要素を格納するための データ 、もう 1 つは次のノードのアドレスを格納するための ポインタ 。

単結合リストは チェーン アクセス データ構造であり、任意のアドレスを持つストレージ ユニットの グループ (このストレージ ユニットのグループは連続または不連続のいずれかです) を使用して、 線形リスト内のデータ要素を格納します。リンクされたリスト内のデータ は ノードによって表されます( 各ノードには 2 つの部分が含まれます。1 つはデータ要素を格納するためのデータ フィールドであり、もう 1 つは次のノードのアドレスを格納するためのポインタ フィールドです。)、各ノードの構成 : 要素+ポインタ 、要素はデータを格納する 記憶 、ポインタは各ノードを接続する アドレス 。

単結合リスト内の各ノードの格納アドレスは、その先行ノードの次のフィールドに格納され、開始ノードには先行ノードがないため、ヘッド ポインタ head は開始ノードを指すように設定されます。連結リストは先頭ポインタによって 一意に 、単一連結リストは先頭ポインタの名前によって名前を付けることができます。終端ノードにはサクセサが存在しないため、終端ノードのポインタフィールドは空、つまり NULL になります。

---

単一リンクリストの実装

見通しのヒント

SList.h は、  参照されるヘッダー ファイル、単一リンク リストの定義、および関数の宣言に使用されます。

関数の定義にはSList.c  を使用します。

Test.c    はリンクリスト機能のテストに使用します。

単一リンクリスト構造定義

SList.h の下

#pragma once//使同一个文件不会被包含(include)多次,不必担心宏名冲突

//先将可能使用到的头文件写上
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

typedef int SLTDataType;//假设结点的数据域类型为 int

//单链表的结构体定义
typedef struct SListNode
{
	SLTDataType data;//结点的数据域，用来存储数据元素
	struct SListNode* next;//结点的指针域，用来存储下一个结点地址的指针域
    //next的意思就是下一个结点的指针，上一个结点存的是下一个结点的地址
    //每个结点都是结构体指针类型
	//有些人会把上一行代码写成SListNode* next;这是不对的，因为C语言中 
    //struct SListNode 整体才是一个类型(但C++可以)
	//或者写成SLTNode* next;这也是错的，因为编译器的查找规则是从上忘下找
}SLTNode;

単一リンクリストの印刷

単連結リストを理解するには、まず単連結リストのプリントを書きます。

SList.h の下

//链表的打印——助于理解链表
void SLTPrint(SLTNode* phead);

SList.c の下

#include "SList.h"//别忘了

//链表的打印
void SLTPrint(SLTNode* phead)
{
	//assert(phead);这里并不需要断言phead不为空
	//为什么这里不需要断言phead？
	//空链表可以打印，即phead==NULL可以打印，直接断言就不合适了
	//那空顺序表也可以打印，那它为什么就要断言呢？
	//因为phead是指向第一个存有数据的结点的
	//而顺序表的ps是指向一个结构体
	SLTNode* cur = phead;//将phead赋值给cur，所以cur也指向第一个结点
	while (cur != NULL)//或while(cur)
	{
		printf("%d->", cur->data);//打印的时候加了个箭头更方便理解
		cur = cur->next;//next是下一个结点的地址
		//++cur/cur++;这种是不行的，指针加加，加到的是连续的下一个位置
		//链表的每一个结点都是单独malloc出来的，我们不能保证结点之间的地址是连续的
	}
	printf("NULL\n");
}

pheadがアサートされない理由について

単連結リストの論理構造と物理構造について

                     

                     

                   

                     

印刷する前にデータが必要です

単一リンクリストの末尾挿入

SList.h の下

// 单链表尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x);
//用二级指针，解释看下文,x为要插入的数据

セカンダリポインタが使用される理由について

SList.c の下

// 单链表尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);//pphead是plist的地址，不能为空
    //注意区分几个断言的判断，plist有可能是空，pphead一定不能为空

	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));//先创建个结点
	if (newnode == NULL)//如果malloc失败
	{
		perror("malloc fail");
		return;
	}
	//如果malloc成功
	newnode->data = x;//插入的数据
	newnode->next = NULL;//初始化为空
	//找尾(尾插之前先找到尾)
	if (*pphead == NULL)//若链表为空
	{
		*pphead = newnode;
	}
	else//若链表不为空
	{
		SLTNode* tail = *pphead;
		while (tail->next != NULL)//对于不为空的链表：尾插的本质
                                  //是原尾结点要存新尾结点的地址
		{
			tail = tail->next;
		}
		tail->next = newnode;
		/*有些同学会写成:
		while (tail != NULL)
		{
			tail = tail->next;
		}
		tail = newnode;*/
	}
}

テールプラグの性質について

 

 と

尾部発見の全過程の説明

↓

 

 ↓

Test.c の下

#include "SList.h"//别忘了

//用于函数功能的测试
void TestSList1()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);

	SLTPrint(plist);
}

int main()
{
	TestSList1();
	return 0;
}

単一リンクリストを出力するためにセカンダリポインタを渡す必要がない理由について

単一リンクリストを印刷してもポインタは変更されないためです。渡されたポインタ（実パラメータ）を変更したい場合は、実パラメータのアドレスを渡す必要があり、変更されない場合は渡さないでください。

単一リンクリストの動的アプリケーションノード

ヘッド プラグを作成するときに、テール プラグとヘッド プラグの両方をノードに動的に適用する必要があることがわかりました。そのため、最初に再利用する関数を作成できます。

SList.c の下

// 动态申请一个结点
SLTNode* BuySLTNode(SLTDataType x)
{
	//同样不需要断言
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));//先创建个结点
	if (newnode == NULL)//如果malloc失败
	{
		perror("malloc fail");
		return NULL;
	}
	//如果malloc成功
	newnode->data = x;//插入的数据
	newnode->next = NULL;//初始化为空

	return newnode;//返回newnode
}

// 单链表尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
    assert(pphead);//pphead是plist的地址，不能为空

	SLTNode* newnode = BuySLTNode(x);
	//找尾(尾插之前先找到尾)
	if (*pphead == NULL)//若链表为空
	{
		*pphead = newnode;
	}
	else//若链表不为空
	{
		SLTNode* tail = *pphead;
		while (tail->next != NULL)
        //对于不为空的链表：尾插的本质是原尾结点要存新尾结点的地址
		{
			tail = tail->next;
		}
		tail->next = newnode;
		/*有些同学会写成:
		while (tail != NULL)
		{
			tail = tail->next;
		}
		tail = newnode;*/
	}
}

シングルリンクリストヘッドプラグ

 SList.h の下

// 单链表的头插
void SLTPushFront(SLTNode** pphead, SLTDataType x);

SList.c の下

// 单链表的头插
void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	//发现plist不管是否为空,头插的方法都一样
	SLTNode* newnode = BuySLTNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}

Test.c の下

void TestSList1()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);

	SLTPrint(plist);
}

void TestSList2()
{
	SLTNode* plist = NULL;
	SLTPushFront(&plist, 1);
	SLTPushFront(&plist, 2);
	SLTPushFront(&plist, 3);
	SLTPushFront(&plist, 4);

	SLTPrint(plist);
}


int main()
{
	TestSList1();
	TestSList2();
	return 0;
}

単一リンクリストの末尾削除

末尾の削除にはセカンダリ ポインタが必要ですか? 欲しい！

SList.h の下

// 单链表的尾删
void SLTPopBack(SLTNode** pphead);

Test.c の下

void TestSList2()
{
	SLTNode* plist = NULL;
	SLTPushFront(&plist, 1);
	SLTPushFront(&plist, 2);
	SLTPushFront(&plist, 3);
	SLTPushFront(&plist, 4);
	SLTPrint(plist);

	SLTPopBack(&plist);
	SLTPrint(plist);
}


int main()
{
	TestSList2();
	return 0;
}

SList.c の下

次のように書き始める人もいます。

// 单链表的尾删
void SLTPopBack(SLTNode** pphead)
{
    assert(pphead);//pphead是plist的地址，不能为空

	SLTNode* tail = *pphead;
	while (tail->next != NULL)
	{
		tail = tail->next;
	}
	
	free(tail);
	tail = NULL;
}

消す：

ランダムな値が表示される --> ほとんどの場合、ワイルド ポインターが原因です。

 →

 なぜ？

変更された SList.c の 2 つのメソッドを次に示します。

方法 1:

// 单链表的尾删
void SLTPopBack(SLTNode** pphead)
{
	assert(pphead);//pphead是plist的地址，不能为空

    //法一：
	SLTNode* prev=NULL;
	SLTNode* tail = *pphead;
	while (tail->next != NULL)
	{ 
		prev = tail;
		tail = tail->next;
	}
	
	free(tail);
	tail = NULL;
	
	prev->next = NULL;
}

法二：

// 单链表的尾删
void SLTPopBack(SLTNode** pphead)
{
	assert(pphead);//pphead是plist的地址，不能为空

	//法二：
	SLTNode* tail = *pphead;
	while (tail->next->next != NULL)
	{
		tail = tail->next;
	}

	free(tail->next);
	tail->next = NULL;
}

 でも、もう少しセットをテストしてみましょう

Test.c の下

void TestSList2()
{
	SLTNode* plist = NULL;
	SLTPushFront(&plist, 1);
	SLTPushFront(&plist, 2);
	SLTPushFront(&plist, 3);
	SLTPushFront(&plist, 4);
	SLTPrint(plist);

    //尾删四个数据
	SLTPopBack(&plist);
	SLTPrint(plist);
	SLTPopBack(&plist);
	SLTPrint(plist);
	SLTPopBack(&plist);
	SLTPrint(plist);
	SLTPopBack(&plist);
	SLTPrint(plist);
}


int main()
{
	TestSList2();
	return 0;
}

結果：

2 つの方法のうち、最後に残るのは 1 つだけです。

その理由は、ノードが 1 つだけの場合やノードがない場合が考慮されていないためです。

再度変更後のSList.cがこちら

// 单链表的尾删
void SLTPopBack(SLTNode** pphead)
{
	assert(pphead);//pphead是plist的地址，不能为空

	//检查有无结点
	assert(*pphead != NULL);
	//1.只有一个结点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		//2.有多个结点
		/*//法一：
		SLTNode* prev=NULL;
		SLTNode* tail = *pphead;
		while (tail->next != NULL)
		{
			prev = tail;
			tail = tail->next;
		}

		free(tail);
		tail = NULL;

		prev->next = NULL;*/
		//法二：
		SLTNode* tail = *pphead;
		while (tail->next->next != NULL)
		{
			tail = tail->next;
		}

		free(tail->next);
		tail->next = NULL;
	}
}

ノードが 1 つだけ

ノードがありません 

単一リンクリストの先頭を削除する

SList.h の下

// 单链表头删
void SLTPopFront(SLTNode** pphead);

SList.c の下

// 单链表头删
void SLTPopFront(SLTNode** pphead)
{
	//检查有无结点
	assert(*pphead != NULL);

	SLTNode* first = *pphead;
	*pphead = first->next;
	free(first);
	first = NULL;
}

Test.c の下

TestSList3()
{
	SLTNode* plist = NULL;
	SLTPushFront(&plist, 1);
	SLTPushFront(&plist, 2);
	SLTPushFront(&plist, 3);
	SLTPushFront(&plist, 4);
	SLTPrint(plist);

	SLTPopFront(&plist);
	SLTPrint(plist);
	SLTPopFront(&plist);
	SLTPrint(plist);
	SLTPopFront(&plist);
	SLTPrint(plist);
	SLTPopFront(&plist);
	SLTPrint(plist);
}

int main()
{
	TestSList3();
	return 0;
}

リンクされたリストの検索

SList.h の下

// 单链表查找
SLTNode* SLTFind(SLTNode* phead, SLTDataType x);

SList.c の下

// 单链表查找
SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{
	SLTNode* cur = phead;//用cur去遍历,不用phead
	while (cur)//找x
	{
		if (cur->data == x)//如果找到了
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;//如果找不到
}

Test.c の下

void TestSList4()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPrint(plist);

	//将寻找和修改结合
	//eg:值为2的结点*2
	SLTNode* ret = SLTFind(plist, 2);
	ret->data *= 2;
	SLTPrint(plist);
}


int main()
{
	TestSList4();
	return 0;
}

単一リンクリストは、pos 位置の前に x を挿入します (pos 位置に挿入すると理解することもできます)。

SList.h の下

//单链表在pos位置之前插入x(效率较低)(得传头指针)(也可以理解为在pos位置插入)
void SLTInsertBefore(SLTNode** pphead, SLTNode* pos, SLTDataType x);

SList.c の下

//单链表在pos位置之前插入x(也可以理解为在pos位置插入)
void SLTInsertBefore(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead);//pphead是plist的地址，不能为空

	assert(pos);//默认pos一定会找到
	if (pos == *pphead)//如果pos在第一个位置——那就是头插
	{
		SLTPushFront(pphead, x);
	}
	else//如果pos不是第一个位置
	{
		//找到pos的前一个位置
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		SLTNode* newnode = BuySLTNode(x);
		prev->next = newnode;
		newnode->next = pos;
	}
}

Test.c の下

TestSList5()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPrint(plist);

	//寻找值为2的结点
	SLTNode* ret = SLTFind(plist, 2);
	SLTInsertBefore(&plist, ret, 20);//在该结点前插入值为20的结点
	SLTPrint(plist);

}

int main()
{
	TestSList5();
	return 0;
}

単一リンクリストは、pos 位置より前の値を削除します (pos 位置の値を削除すると理解することもできます)。

SList.h の下

// 单链表删除pos位置之前的值(效率较低)(得传头指针)(也可以理解为删除pos位置的值)
void SLTEraseBefore(SLTNode** pphead, SLTNode* pos);

SList.c の下

// 单链表删除pos位置之前的值(也可以理解为删除pos位置的值)
void SLTEraseBefore(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead);
	assert(pos);

	if (*pphead == pos)//如果pos在第一个位置
	{
		SLTPopFront(pphead);//头删
	}
	else//如果不在第一个位置
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
		//pos = NULL;形参的改变不影响实参,加不加这句话都可以
	}
}

Test.c の下

TestSList6()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPrint(plist);

	//寻找值为2的结点
	SLTNode* ret = SLTFind(plist, 2);
	SLTEraseBefore(&plist, ret);
	ret = NULL;//一般在这里置空
	SLTPrint(plist);
}

int main()
{
	TestSList6();
	return 0;
}

単一リンクリストは pos 位置の後に x を挿入します 

SList.h の下

// 单链表在pos位置之后插入x,单链表比较适合这种
void SLTInsertAfter(SLTNode* pos, SLTDataType x);

SList.c の下

次のように書く人もいます。

//单链表在pos位置之后插入x
void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);
	SLTNode* newnode = BuySLTNode(x);
	pos->next = newnode;
	newnode->next=pos->next;
}

結果として：

 したがって、オレンジと紫の 2 つのステップの位置が入れ替わる必要があります。

変更された SList.c

//单链表在pos位置之后插入x
void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);
	SLTNode* newnode = BuySLTNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

Test.c の下

TestSList7()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPrint(plist);

	SLTNode* ret = SLTFind(plist, 2);
	SLTInsertAfter(ret, 20);
	SLTPrint(plist);
}

int main()
{
	TestSList7();
	return 0;
}

単一リンクリストは、pos 位置の後の値を削除します

SList.h の下

// 单链表删除pos位置之后的值,单链表比较适合这种
void SLTEraseAfter(SLTNode* pos);

SList.c の下

// 单链表删除pos位置之后的值
void SLTEraseAfter(SLTNode* pos)
{
	assert(pos);
	assert(pos->next);

	SLTNode* del = pos->next;//保存要删除的结点
	pos->next = pos->next->next;//或者写成pos->next=del->next;
	free(del);
	del = NULL;
}

Test.c の下

TestSList8()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPrint(plist);

	SLTNode* ret = SLTFind(plist, 2);
	SLTEraseAfter(ret);
	SLTPrint(plist);
}

int main()
{
	TestSList8();
	return 0;
}

ヘッダーポインタを通さずにposの前に挿入・削除する方法について（独創的）

挿入: まず単一リンクリストを使用して pos の位置の後に x の関数を挿入し、次に pos と pos->next の値を交換します。

SList.h の下

// 不传头指针,在pos前插入x(也可以理解为在pos位置插入)
void SLTInsertBefore1(SLTNode* pos, SLTDataType x);

SList.c の下

// 不传头指针,在pos前插入x(也可以理解为在pos位置插入)
void SLTInsertBefore1(SLTNode* pos, SLTDataType x)
{
	assert(pos);

	//调用单链表在pos位置之后插入x的函数
	SLTInsertAfter(pos, x);
	
	//交换pos和pos->next的值
	SLTDataType temp;
	temp = pos->data;
	pos->data = pos->next->data;
	pos->next->data = temp;
}

Test.c の下

TestSList9()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPrint(plist);

	SLTNode* ret = SLTFind(plist, 2);
	SLTInsertBefore1(ret,20);
	SLTPrint(plist);
}

int main()
{
	TestSList9();
	return 0;
}

削除: まず pos->next の値を pos に割り当て、次に単一のリンク リストを使用して pos の位置の後の関数を削除します。(ただし、このメソッドは末尾削除はできません)

SList.h の下

// 不传头指针,删除pos位置之前的值(也可以理解为删除pos位置的值)
void SLTEraseBefore1(SLTNode* pos);

SList.c の下

// 不传头指针,删除pos位置之前的值(也可以理解为删除pos位置的值)
void SLTEraseBefore1(SLTNode* pos)
{
	assert(pos);
	assert(pos->next);//不能尾删
	
	SLTNode* del = pos->next;
	pos->data = pos->next->data;
	pos->next = pos->next->next;
	free(del);
	del = NULL;
}

Test.c の下

TestSList10()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPrint(plist);

	SLTNode* ret = SLTFind(plist, 2);
	SLTEraseBefore1(ret);
	SLTPrint(plist);
}

int main()
{
	TestSList10();
	return 0;
}

単一リンクリストの破棄

方法 1 (2 次ポインターを渡さない):

SList.h の下

// 单链表的销毁,不传二级
void SLTDestroy(SLTNode* phead);

SList.c の下

// 单链表的销毁
void SLTDestroy(SLTNode* phead)
{
	SLTNode* cur = phead;
	/*//有些人一开始会这样写
	while (cur)
	{
		//free不是销毁这个指针指向的内存,而是将指针指向的内存还给操作系统
		free(cur);//cur依旧指向free之前的地址
		cur = cur->next;
	}*/

	while (cur)
	{
		SLTNode* tmp = cur->next;
		free(cur);
		cur = tmp;
	}
}

Test.c の下

TestSList11()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPrint(plist);

	SLTDestroy(plist);
	plist = NULL;
}


int main()
{
	TestSList11();
	return 0;
}

方法 2 (2 次ポインターを渡す):

SList.h の下

// 单链表的销毁,传二级
void SLTDestroy1(SLTNode** pphead);

SList.c の下

// 单链表的销毁,传二级
void SLTDestroy1(SLTNode** pphead)
{
	assert(pphead);
	SLTNode* cur = *pphead;
	while (cur)
	{
		SLTNode* tmp = cur->next;
		free(cur);
		cur = tmp;
	}
	*pphead = NULL;
}

Test.c の下

TestSList12()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPrint(plist);

	SLTDestroy1(&plist);
	SLTPrint(plist);
}

int main()
{
	TestSList12();
	return 0;
}

---

合計コード (結果を直接確認したい場合は、ここで確認できます)

SList.h の下

#pragma once//使同一个文件不会被包含(include)多次,不必担心宏名冲突

//先将可能使用到的头文件写上
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

typedef int SLTDataType;//假设结点的数据域类型为 int

// 单链表的结构体定义
//		↓结点  单链表 Singly Linked List
typedef struct SListNode
{
	SLTDataType data;//结点的数据域,用来存储数据元素
	struct SListNode* next;//结点的指针域，用来存储下一个结点地址的指针域
	//next的意思就是下一个结点的指针，上一个结点存的是下一个结点的地址
	//每个结点都是结构体指针类型
	//有些人会把上一行代码写成SListNode* next;
    //这是不对的，因为C语言中 struct SListNode 整体才是一个类型(但C++可以)
	//或者写成SLTNode* next;这也是不对的,因为编译器的查找规则是从上忘下找
}SLTNode;


// 链表的打印——助于理解链表
void SLTPrint(SLTNode* phead);

// 单链表尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x);//用二级指针,x为要插入的数据

// 单链表的头插
void SLTPushFront(SLTNode** pphead, SLTDataType x);

// 单链表的尾删
void SLTPopBack(SLTNode** pphead);

// 单链表头删
void SLTPopFront(SLTNode** pphead);

// 单链表查找
SLTNode* SLTFind(SLTNode* phead, SLTDataType x);

// 单链表在pos位置之前插入x(效率较低)(得传头指针)(也可以理解为在pos位置插入)
void SLTInsertBefore(SLTNode** pphead, SLTNode* pos, SLTDataType x);

// 单链表删除pos位置之前的值(效率较低)(得传头指针)(也可以理解为删除pos位置的值)
void SLTEraseBefore(SLTNode** pphead, SLTNode* pos);

// 单链表在pos位置之后插入x,单链表比较适合这种
void SLTInsertAfter(SLTNode* pos, SLTDataType x);

// 单链表删除pos位置之后的值,单链表比较适合这种
void SLTEraseAfter(SLTNode* pos);

// 不传头指针,在pos前插入x(也可以理解为在pos位置插入)
void SLTInsertBefore1(SLTNode* pos, SLTDataType x);

// 不传头指针,删除pos位置之前的值(也可以理解为删除pos位置的值)
void SLTEraseBefore1(SLTNode* pos);

// 单链表的销毁,不传二级
void SLTDestroy(SLTNode* phead);

// 单链表的销毁,传二级
void SLTDestroy1(SLTNode** pphead);

SList.c の下

#include"SList.h"//别忘了

//链表的打印
void SLTPrint(SLTNode* phead)
{
	//assert(phead);这里并不需要断言phead不为空
	//为什么这里不需要断言？
	//空链表可以打印，即phead==NULL可以打印，直接断言就不合适了
	//那空顺序表也可以打印，那它为什么就要断言呢？
	//因为phead是指向第一个存有数据的结点的
	//而顺序表的ps是指向一个结构体
	SLTNode* cur = phead;//将phead赋值给cur，所以cur也指向第一个结点
	while (cur != NULL)//或while(cur)
	{
		printf("%d->", cur->data);//打印的时候加了个箭头更方便理解
		cur = cur->next;//next是下一个结点的地址
		//++cur/cur++;这种是不行的，指针加加，加到的是连续的下一个位置
		//链表的每一个结点都是单独malloc出来的，我们不能保证结点之间的地址是连续的
	}
	printf("NULL\n");
}

// 动态申请一个结点
SLTNode* BuySLTNode(SLTDataType x)
{
	//同样不需要断言
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));//先创建个结点
	if (newnode == NULL)//如果malloc失败
	{
		perror("malloc fail");
		return NULL;
	}
	//如果malloc成功
	newnode->data = x;//插入的数据
	newnode->next = NULL;//初始化为空

	return newnode;//返回newnode
}

// 单链表尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);//pphead是plist的地址，不能为空
	//注意区分几个断言的判断，plist有可能是空，pphead一定不能为空

	SLTNode* newnode = BuySLTNode(x);
	//找尾(尾插之前先找到尾)
	if (*pphead == NULL)//若链表为空
	{
		*pphead = newnode;
	}
	else//若链表不为空
	{
		SLTNode* tail = *pphead;
		while (tail->next != NULL)
        //对于不为空的链表：尾插的本质是原尾结点要存新尾结点的地址
		{
			tail = tail->next;
		}
		tail->next = newnode;
		/*有些同学会写成:
		while (tail != NULL)
		{
			tail = tail->next;
		}
		tail = newnode;*/
	}
}


// 单链表的头插
void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);//pphead是plist的地址，不能为空

	//发现plist不管是否为空,头插的方法都一样
	SLTNode* newnode = BuySLTNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}

// 单链表的尾删
void SLTPopBack(SLTNode** pphead)
{
	assert(pphead);//pphead是plist的地址，不能为空

	//检查有无结点
	assert(*pphead != NULL);//或者写成assert(*pphead);
	//1.只有一个结点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		//2.有多个结点
		/*//法一：
		SLTNode* prev=NULL;
		SLTNode* tail = *pphead;
		while (tail->next != NULL)
		{
			prev = tail;
			tail = tail->next;
		}

		free(tail);
		tail = NULL;

		prev->next = NULL;*/
		//法二：
		SLTNode* tail = *pphead;
		while (tail->next->next != NULL)
		{
			tail = tail->next;
		}

		free(tail->next);
		tail->next = NULL;
	}
}

// 单链表头删
void SLTPopFront(SLTNode** pphead)
{
	assert(pphead);//pphead是plist的地址，不能为空

	//检查有无结点
	assert(*pphead != NULL);

	SLTNode* first = *pphead;
	*pphead = first->next;
	free(first);
	first = NULL;
}

// 单链表查找
SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{
	SLTNode* cur = phead;//用cur去遍历,不用phead
	while (cur)//找x
	{
		if (cur->data == x)//如果找到了
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;//如果找不到
}

//单链表在pos位置之前插入x(也可以理解为在pos位置插入)
void SLTInsertBefore(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pos);//默认pos一定会找到
	assert(pphead);//pphead是plist的地址，不能为空
	if (pos == *pphead)//如果pos在第一个位置——那就是头插
	{
		SLTPushFront(pphead, x);
	}
	else//如果pos不是第一个位置
	{
		//找到pos的前一个位置
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		SLTNode* newnode = BuySLTNode(x);
		prev->next = newnode;
		newnode->next = pos;
	}
}

// 单链表删除pos位置之前的值(也可以理解为删除pos位置的值)
void SLTEraseBefore(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead);
	assert(pos);

	if (*pphead == pos)//如果pos在第一个位置
	{
		SLTPopFront(pphead);//头删
	}
	else//如果不在第一个位置
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
		//pos = NULL;形参的改变不影响实参,加不加这句话都可以
	}
}

//单链表在pos位置之后插入x
void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);
	SLTNode* newnode = BuySLTNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

// 单链表删除pos位置之后的值
void SLTEraseAfter(SLTNode* pos)
{
	assert(pos);
	assert(pos->next);

	SLTNode* del = pos->next;//保存要删除的结点
	pos->next = pos->next->next;//或者写成pos->next=del->next;
	free(del);
	del = NULL;
}

// 不传头指针,在pos前插入x(也可以理解为在pos位置插入)
void SLTInsertBefore1(SLTNode* pos, SLTDataType x)
{
	assert(pos);

	//调用单链表在pos位置之后插入x的函数
	SLTInsertAfter(pos, x);

	//交换pos和pos->next的值
	SLTDataType temp;
	temp = pos->data;
	pos->data = pos->next->data;
	pos->next->data = temp;
}

// 不传头指针,删除pos位置之前的值(也可以理解为删除pos位置的值)
void SLTEraseBefore1(SLTNode* pos)
{
	assert(pos);
	assert(pos->next);//不能尾删

	SLTNode* del = pos->next;
	pos->data = pos->next->data;
	pos->next = pos->next->next;
	free(del);
	del = NULL;
}

// 单链表的销毁
void SLTDestroy(SLTNode* phead)
{
	SLTNode* cur = phead;
	/*//有些人一开始会这样写
	while (cur)
	{
		//free不是销毁这个指针指向的内存,而是将指针指向的内存还给操作系统
		free(cur);//cur依旧指向free之前的地址
		cur = cur->next;
	}*/

	while (cur)
	{
		SLTNode* tmp = cur->next;
		free(cur);
		cur = tmp;
	}
}

// 单链表的销毁,传二级
void SLTDestroy1(SLTNode** pphead)
{
	assert(pphead);
	SLTNode* cur = *pphead;
	while (cur)
	{
		SLTNode* tmp = cur->next;
		free(cur);
		cur = tmp;
	}
	*pphead = NULL;
}

Test.c の下

#include"SList.h"

void TestSList1()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);

	SLTPrint(plist);
}

void TestSList2()
{
	SLTNode* plist = NULL;
	SLTPushFront(&plist, 1);
	SLTPushFront(&plist, 2);
	SLTPushFront(&plist, 3);
	SLTPushFront(&plist, 4);
	SLTPrint(plist);

	SLTPopBack(&plist);
	SLTPrint(plist);
	SLTPopBack(&plist);
	SLTPrint(plist);
	SLTPopBack(&plist);
	SLTPrint(plist);
	SLTPopBack(&plist);
	SLTPrint(plist);
}

TestSList3()
{
	SLTNode* plist = NULL;
	SLTPushFront(&plist, 1);
	SLTPushFront(&plist, 2);
	SLTPushFront(&plist, 3);
	SLTPushFront(&plist, 4);
	SLTPrint(plist);

	SLTPopFront(&plist);
	SLTPrint(plist);
	SLTPopFront(&plist);
	SLTPrint(plist);
	SLTPopFront(&plist);
	SLTPrint(plist);
	SLTPopFront(&plist);
	SLTPrint(plist);
}

void TestSList4()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPrint(plist);

	//将寻找和修改结合
	//eg:值为2的结点*2
	SLTNode* ret = SLTFind(plist, 2);
	ret->data *= 2;
	SLTPrint(plist);
}

TestSList5()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPrint(plist);

	//寻找值为2的结点
	SLTNode* ret = SLTFind(plist, 2);
	SLTInsertBefore(&plist, ret, 20);//在该结点前插入值为20的结点
	SLTPrint(plist);

}

TestSList6()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPrint(plist);

	//寻找值为2的结点
	SLTNode* ret = SLTFind(plist, 2);
	SLTEraseBefore(&plist, ret);
	ret = NULL;//一般在这里置空
	SLTPrint(plist);
}

TestSList7()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPrint(plist);

	SLTNode* ret = SLTFind(plist, 2);
	SLTInsertAfter(ret, 20);
	SLTPrint(plist);
}

TestSList8()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPrint(plist);

	SLTNode* ret = SLTFind(plist, 2);
	SLTEraseAfter(ret);
	SLTPrint(plist);
}

TestSList9()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPrint(plist);

	SLTNode* ret = SLTFind(plist, 2);
	SLTInsertBefore1(ret, 20);
	SLTPrint(plist);
}

TestSList10()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPrint(plist);

	SLTNode* ret = SLTFind(plist, 2);
	SLTEraseBefore1(ret);
	SLTPrint(plist);
}

TestSList11()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPrint(plist);

	SLTDestroy(plist);
	plist = NULL;
}

TestSList12()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPrint(plist);

	SLTDestroy1(&plist);
	SLTPrint(plist);
}

int main()
{
	//TestSList1();
	//TestSList2();
	//TestSList3();
	//TestSList4();
	//TestSList5();
	//TestSList6();
	//TestSList7();
	//TestSList8();
	//TestSList9();
	//TestSList10();
	//TestSList11();
	TestSList12();
	return 0;
}

修正は大歓迎です❀