初阶数据结构之单链表详解

目录

一：单链表概念

二：单链表的基本操作

1.定义结点

2.创建链表（初始化链表）

3:新增结点

4.单链表尾插

5.单链表头插

6.单链表尾删

7：单链表头删

8.打印单链表

9.查找单链表结点

10.单链表删除指定结点

11.单链表结点修改

12.单链表结点前插入结点

三：代码总结

[SL List.h](#SL List.h)

[SL Lish.c](#SL Lish.c)

---

开门见山，直接开始讲解。（如有错误请指出，一定改正）

如果对你有所帮助的话，不妨点个赞再走。

一：单链表概念

单链表是一种线性数据结构，其特点是数据元素以节点的形式存储在内存中，这些节点在物理上可能是不连续的（他们的地址可能离的很远）。每个节点由一个数据域和一个指针域组成，数据域用于存储数据，而指针域包含了指向下一个节点的指针（即他们在逻辑上是连续的）。

图示：

同时，单链表可以分为带头结点和不带头结点两种。带头结点的单链表通常有一个头结点，它的指针域指向链表的第一个有效节点（首元节点），这样的设计便于进行一些特殊操作，例如删除所有节点同时保留链表。不带头结点的单链表直接从第一个有效节点开始，没有额外的头结点。

如上图的plist就是链表的头节点。

二：单链表的基本操作

1.定义结点

在实现单链表的操作之前，我们应该把结点定义出来，已知结点内存储结点数据（data）和下一个结点的地址（即一个指向下一个结点的指针），因此我们可以用结构体来定义结点。

//定义结点
typedef int SLTDataType;
typedef struct SListNode
{
	SLTDataType data;//数据域
	struct SListNode *next;//指针域

}SLNode;  

2.创建链表（初始化链表）

可以把链表初始化为两种形式。一种是带头结点的，一种是不带头节点的。

带头结点：

void initList(SLNode*head)//head为单链表头节点的指针
{
    assert(head);
    head = (SLNode*)malloc(sizeof(SLNode));为头节点开辟空间
    head->next = NULL;
}

不带头结点：

void InitList(SLNode * head)
{
	assert(head);
	head=NULL;
}

3:新增结点

当我们在进行单链表的尾插和头插操作时，总要新增一个结点（即把新增加的数据转换成单链表结点类型），因此我们可以单独写一个新增结点的代码实现，当我们进行插入操作时直接引用即可。

//单链表的新增节点
 SLNode* AddList(SLTDataType x)//x为新增的结点数据
{
	SLNode* newnode = (SLNode*)malloc(sizeof(SLNode));为新节点开辟空间
	if (newnode == NULL)
	{
		perror("开辟结点空间失败");
		return NULL;
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}

4.单链表尾插

单链表尾插入结点之前，最后的一个结点是指向NULL的，因此只需要把最后一个结点由原来的指向NULL改为指向新插入的节点即可。

//单链表尾插结点
void PushBackList(SLNode**head,SLTDataType x)
{
	assert(head);
	SLNode* newnode = AddList(x);
	if (*head == NULL)
	{
		*head= newnode;
	}
	else
	{
	    SLNode* tail = *head;
		while (tail->next)
		{
		   tail = tail->next;
		}
		tail->next = newnode;
	}
}

关于这里为什么不传 SLNode*head 而是传 SLNode**head ？在此做一个解释。

首先，在主函数中创建一个指向头节点地址的结构体指针head：SLNode*head。

注意：地址就是指针，指针就是地址。

例如：head既是头结点head的地址，也是指向头节点head的指针。

那么此时我们如果传 head ，实际传给函数的就是head的地址，然后函数用SLNode*head这个一级指针来接收，并且只有当我们要对head的实际值进行修改等操作的时候才需要传给函数他的地址。

而如果我们传的是 &head（对指针取地址），那么我们实际传过去的就是 （指向head的指针的指针）也可以叫做（指向head地址的指针的地址），然后函数需要用SLNode **head这个二级指针来接收，并且只有当我们想要对（head的地址）或者说（指向head的指针）进行修改等操作的时候才需要传给函数&head，在函数中对地址进行操作不影响实际数据。

那么我们的插入操作实际上是要对谁进行操作的呢？

插入操作实际上是对指针（地址）进行操作，例如上面的代码中的 *head=newnode，就是把（新建立结点的地址）赋给了（指向head地址的指针），此时head指向的是newnode的地址。

因此，总的来说，是因为我们想要对指针（地址）进行操作，所以才用二级指针来接收。

希望你们可以理解哈哈。

5.单链表头插

单链表头插就是创建一个新的链表结点，然后把让链表结点指向原来的头节点即可。

//单链表头插结点
void PushFrontList(SLNode** head, SLTDataType x)
{
	assert(head);
    SLNode*newnode=AddList(x);
	SLNode*newhead = newnode;
	newnode->next =*head;
	*head= newhead;
}

6.单链表尾删

单链表尾删就是把单链表最后一个结点空间free掉，然后让单链表倒数第二个结点指向NULL。

但是需要注意两点。

（一)：assert进行断言时，不仅需要断言head还要断言*head。

断言*head是为了确保指向head地址不为空，即断言指向头结点的的指针是否存在（链表是否为空）。

(二)：尾删结点时要区分情况，一种是原链表只有1个结点的情况，一种是链表有多个结点的情况，因为如果链表只有一个结点，那么 while（tail->next）为空会导致进不去循环，导致头节点不能被删除。

//单链表尾删结点
void DelBackList(SLNode** head)
{
	assert(head&&*head);
	if ((*head)->next == NULL)
	{
		free(*head);
		*head = NULL;
	}
	else
	{
		SLNode* tail = *head;
		SLNode* prev = NULL;//创建prev用来保存倒数第二个结点的指针
		while (tail->next)
		{
			prev = tail;
			tail = tail->next;
		}
		free(tail);
        tail=NULL;
		prev->next = NULL;
	}
}

7：单链表头删

单链表头删其实就是把指向头节点的指针指向第二个结点，然后把原本的头节点的空间释放掉，那么第二个结点就成为了头节点。

//单链表头删
void DelFrontList(SLNode** head)
{ 
	assert(head && *head);
	SLNode* agohead = *head;
	*head = (*head)->next;
	free(agohead);
	agohead = NULL;

}

8.打印单链表

打印单链表十分简单，只需传单链表头节点的地址然后写个循环即可。

//打印单链表
void PrintList(SLNode* head)
{
	SLNode* p = head;
	while (p!=NULL)
	{
		printf("%d ", p->data);
		p= p->next;
	}
}

9.查找单链表结点

查找单链表结点就是输入结点的地址，然后遍历链表查找结点即可。

注意：因为我们只是对链表结点的地址进行比较，此时只需传head，用SLNode*head接收即可。

如果找到就返回结点的地址，如果没有找到就返回NULL。

//单链表查找数据
SLNode* FindList(SLNode* head, SLTDataType x)
{
	SLNode* find = head;
	while (find)
	{
		if (find->data == x)
		{
			printf("找到了");
            return find;
		}
		find = find->next;
	}
	printf("没找到");
	return NULL;
}

10.单链表删除指定结点

既然是要删除指定结点，那实际上是对结点地址进行删除，然后free空间，因此也是传&head，用SLNode**head接收。

//单链表删除指定位置结点
void EraseList(SLNode** head, SLNode* pos)
{
	assert(head && pos);
	if (pos == *head)//如果链表只有一个结点，则直接引入头删函数
	{
		DelFrontList(head);
	}
	else
	{
		SLNode* prev = *head;
        SLNode* phead= *head;
		while (phead != NULL)
		{ 
           if(phead==pos)
           {
              phead->next=prev->next;
           }
           prev=phead;
           phead=phead->next;
        }
    }
}

11.单链表结点修改

结点修改十分简单，只需找到结点然后修改他的data即可。

//单链表结点修改
void ModifyList(SLNode* head, SLNode* pos, SLTDataType x)
{
	assert(head && pos);
	SLNode* phead = head;
	while (phead != pos)
	{
		phead = phead->next;
	}
	phead->data=x;
}

12.单链表结点前插入结点

需要分情况讨论。

一种为链表中的头节点，这个结点刚好就是想要插入的那个结点，那么只需直接调用单链表头插函数即可。

另一种情况就是要寻找的结点在其他的位置。

//单链表结点前插
void InsertHeadList(SLNode** head, SLNode* pos, SLTDataType x)
{
	assert(head && pos);
	SLNode* prev = *head;
	SLNode* phead = *head;
	if (phead == pos)
	{
		PushFrontList(phead,x);
	}
	else
	{
		while (phead != pos)
		{
			prev = phead;
			phead = phead->next;
		}
		prev->next = AddList(x);
		AddList(x)->next = phead;
	}
}

13.单链表结点后插入结点

//单链表结点后插
void InsertBackList(SLNode** head, SLNode* pos, SLTDataType x)
{
	assert(head && pos);
	SLNode* phead = *head;
	SLNode* newnode = AddList(x);
	while (phead != pos)
	{
		phead = phead->next;
	}
	newnode->next = phead->next->next;
	newnode = phead->next;

}

14.单链表销毁

因为链表在逻辑结构上并不是连续的，因此我们需要一个节点一个结点地去销毁。

//销毁单链表
void DesTructList(SLNode** head)
{
	assert(head);
	SLNode* phead = *head;
	while (phead != NULL)
	{
		SLNode* next = phead->next;
		free(phead);
		phead=next;
	}
	*head = NULL;

}

三：代码总结

SL List.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

//定义结点
typedef int SLTDataType;
typedef struct SListNode
{
	SLTDataType data;//数据域
	struct SListNode *next;//指针域

}SLNode;  

//单链表初始化
void InitList(SLNode* head);

//单链表的新增节点(把新增的数据转换为结点结构体类型)
SLNode* AddList(SLTDataType x);

//单链表尾插结点
void PushBackList(SLNode**head,SLTDataType x);

//单链表头插结点
void PushFrontList(SLNode**head, SLTDataType x);

//打印单链表
void PrintList(SLNode* head);

//单链表尾删结点
void DelBackList(SLNode** head);

//单链表头删
void DelFrontList(SLNode** head);

//单链表查找数据
SLNode* FindList(SLNode* head,SLTDataType x);

//单链表删除指定位置结点
void EraseList(SLNode** head, SLNode* pos);

//单链表结点前插
void InsertHeadList(SLNode** head, SLNode* pos,SLTDataType x);

//单链表结点后插
void InsertBackList(SLNode**head,SLNode*pos,SLTDataType x);

//单链表结点修改
void ModifyList(SLNode** head, SLNode* pos, SLTDataType x);

//销毁单链表
void DesTructList(SLNode** head);

SL Lish.c

#include"SL List.h"

//单链表初始化
void InitList(SLNode* head)//head为单链表头节点的指针
{
	assert(head);
	head = NULL;
}

//单链表的新增节点
SLNode* AddList(SLTDataType x)//x为新增的结点数据
{
	SLNode* newnode = (SLNode*)malloc(sizeof(SLNode));
	if (newnode == NULL)
	{
		perror("开辟结点空间失败");
		return NULL;
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}

//单链表尾插结点
void PushBackList(SLNode** head, SLTDataType x)
{
	assert(head);
	SLNode* newnode = AddList(x);
	if (*head == NULL)
	{
		*head = newnode;
	}
	else
	{
		SLNode* tail = *head;
		while (tail->next)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}

//单链表头插结点
void PushFrontList(SLNode** head, SLTDataType x)
{
	assert(head);
	SLNode* newnode = AddList(x);
	SLNode* newhead = newnode;
	newnode->next = *head;
	*head = newhead;
}

//打印单链表
void PrintList(SLNode* phead)
{
	SLNode* p = phead;
	while (p!=NULL)
	{
		printf("%d ", p->data);
		p= p->next;
	}
}

//单链表尾删结点
void DelBackList(SLNode** head)
{
	assert(head && *head);
	if ((*head)->next == NULL)
	{
		free(*head);
		*head = NULL;
	}
	else
	{
		SLNode* tail = *head;
		SLNode* prev = NULL;//创建prev用来保存倒数第二个结点的指针
		while (tail->next)
		{
			prev = tail;
			tail = tail->next;
		}
		free(tail);
		tail = NULL;
		prev->next = NULL;
	}
}

//单链表头删
void DelFrontList(SLNode** head)
{
	assert(head && *head);
	SLNode* agohead = *head;
	*head = (*head)->next;
	free(agohead);
	agohead = NULL;

}

//单链表查找数据
SLNode* FindList(SLNode* head, SLTDataType x)
{
	SLNode* find = head;
	while (find)
	{
		if (find->data == x)
		{
			printf("找到了");
			return find;
		}
		find = find->next;
	}
	printf("没找到");
	return NULL;
}

//单链表删除指定位置结点
void EraseList(SLNode** head, SLNode* pos)
{
	assert(head && pos);
	if (pos == *head)//如果链表只有一个结点，则直接引入头删函数
	{
		DelFrontList(head);
	}
	else
	{
		SLNode* prev = *head;
		SLNode* phead = *head;
		while (phead != NULL)
		{
			if (phead == pos)
			{
				phead->next = prev->next;
			}
			prev = phead;
			phead = phead->next;
		}
	}
}

//单链表结点前插
void InsertHeadList(SLNode** head, SLNode* pos, SLTDataType x)
{
	assert(head && pos);
	SLNode* prev = *head;
	SLNode* phead = *head;
	if (*head == pos)
	{
		PushFrontList(head, x);
	}
	else
	{
		while (phead != pos)
		{
			prev = phead;
			phead = phead->next;
		}
		prev->next = AddList(x);
		AddList(x)->next = phead;
	}
}

//单链表结点后插
void InsertBackList(SLNode** head, SLNode* pos, SLTDataType x)
{
	assert(head && pos);
	SLNode* phead = *head;
	SLNode* newnode = AddList(x);
	while (phead != pos)
	{
		phead = phead->next;
	}
	newnode->next = phead->next->next;
	newnode = phead->next;

}

//单链表结点修改
void ModifyList(SLNode** phead, SLNode* pos, SLTDataType x)
{
	assert(phead && pos);
	SLNode* pa = *phead;
	while (pa != pos)
	{
		pa = pa->next;
	}
	pa = AddList(x);
}

//销毁单链表
void DesTructList(SLNode** head)
{
	assert(head);
	SLNode* phead = *head;
	while (phead != NULL)
	{
		SLNode* next = phead->next;
		free(phead);
		phead=next;
	}
	*head = NULL;

}

至此，初阶数据结构之单链表已讲解完毕。

完结撒花。