单链表C语言版

已于 2022-04-16 16:06:15 修改
阅读量1.6k 收藏 12
点赞数 23
分类专栏： 数据结构 文章标签： c语言 数据结构
于 2022-03-19 22:46:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/iwkxi/article/details/123600166
版权
本文详细介绍了单链表的概念、分类，并以无头单向非循环链表为例，展示了C语言实现链表的增删查改操作，包括头插、尾插、头删、尾删、查找、插入和删除等方法。同时，通过代码分析了错误与正确实现的区别，以及如何优化链表操作的效率。
摘要由CSDN通过智能技术生成

文章目录

0.前言

在这里插入图片描述

1.链表的概念及结构

概念：链表是一种物理存储结构上非连续，非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。

在这里插入图片描述

现实数据结构中 在这里插入图片描述

2.链表的分类

实际中链表的结构非常多样，以下情况组合起来就有8种链表结构：

  1. 单向或者双向 在这里插入图片描述
  2. 带头或者不带头 在这里插入图片描述
  3. 循环或者非循环 在这里插入图片描述
    虽然有这么多的链表的结构，但是我们实际中最常用还是两种结构： 在这里插入图片描述
  • 无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。
  • 带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了，后面我们代码实现了就知道了。

3单链表的实现

我们还是采用分文件的方式实现。

3.1 Slist.h

在这里插入图片描述

#pragma once
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
// 1、无头+单向+非循环链表增删查改实现
typedef int SLTDateType;
typedef struct SListNode
{
 SLTDateType data;
 struct SListNode* next; 
}SListNode;
// 动态申请一个节点
SListNode* BuySListNode(SLTDateType x);
// 单链表打印
void SListPrint(SListNode* phead);
// 单链表尾插
void SListPushBack(SListNode** phead, SLTDateType x);
// 单链表的头插
void SListPushFront(SListNode** phead, SLTDateType x);
// 单链表的尾删
void SListPopBack(SListNode** phead);
// 单链表头删
void SListPopFront(SListNode** phead);
// 单链表查找
SListNode* SListFind(SListNode* phead, SLTDateType x);
// 单链表在pos位置之后插入x
// 分析思考为什么不在pos位置之前插入？
void SListInsertAfter(SListNode* pos, SLTDateType x);
// 单链表删除pos位置之后的值
// 分析思考为什么不删除pos位置？
void SListEraseAfter(SListNode* pos);
void SListDestroy(SListNode** pphead);

3.2 Slist.c

3.2.1 打印链表

在这里插入图片描述

void SListPrint(SListNode* phead)
{
	SListNode* cur = phead;
	while(cur != NULL)
	{
		printf("%d->",cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}

3.2.2 动态开辟一个节点

SListNode* BuySListNode(SLTDateType x)
{
	SListNode* newnode = (SListNode*)malloc(sizeof(SLTDataType));
	if(newnode == NULL)
	{
		printf("malloc faile\n");
		exit(-1);
	}
	else
	{
		newnode->data = x;
		newnode->next = NULL;
	}
	
}

3.2.3 尾插

链表为空：
在这里插入图片描述
链表不为空：
在这里插入图片描述

void SListPushBack(SListNode* phead, SLTDateType x)
{
	SLitNode* newnode = BuySListNode(x);
	if(phead == NULL)
	{
		phead = newnode;
	}
	else
	{
		SListNode* tail = phead;
		while(tail->next != NULL)
		{
			tail = tail->next;
		}
		tail->next = newnode;
}

大家看这种写法有没有问题？
在这里插入图片描述
调试发现slist根本没有插入数据，这是为什么？
在这里插入图片描述
正确的写法：

void SListPushBack(SListNode** pphead, SLTDateType x)
{
	SListNode* newnode = BuySListNode(x);
	if(*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		SListNode* tail = *pphead;
		while(tail->next != NULL)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}

3.2.4 头插

在这里插入图片描述

void SListPushFront(SListNode** pphead, SLTDataType x)
{
	SListNode* newnode = BuySListNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}

3.2.5 尾删

多个节点：
在这里插入图片描述
一个节点：
在这里插入图片描述

空链表：直接return;

void SListPopBack(SListNode** pphead)
{
	assert(pphead);

	// 也可以暴力检查为空的情况
	//assert(*pphead != NULL);

	// 1、空
	// 2、一个节点
	// 3、多个节点
	if (*pphead == NULL)  // 温柔检查
	{
		return;
	}
	else if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SListNode* prev = NULL;
		SListNode* tail = *pphead;
		while (tail->next != NULL)
		{
		prev = tail;
		tail = tail->next;
		}

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

3.2.7 头删

void SListPopFront(SListNode** pphead)
{
	assert(pphead);

	// 1、空
	// 2、非空
	if (*pphead == NULL)
	{
		return;
	}
	else
	{
		SListNode* next = (*pphead)->next;
		free(*pphead);
		*pphead = next;
	}
}

非空：
在这里插入图片描述
空链表直接return;

3.2.8 单链表查找

SListNode* SListFind(SListNode* phead, SLTDataType x)
{
	SListNode* cur = phead;
	while (cur != NULL)
	{
		if (cur->data == x)
		{
			return cur;
		}

		cur = cur->next;
	}

	return NULL;
}

3.2.8 单链表插入数据(在pos之前还是之后？）

如果在pos之前插入，又要考虑pos是不是第一个节点的情况，很是复杂。
在这里插入图片描述
pos之前：

void SListInsert(SListNode** pphead, SListNode* pos, SLTDataType x)
{
	assert(pphead);
	assert(pos);

	// 1、pos是第一个节点
	// 2、pos不是第一个节点
	if (pos == *pphead)
	{
		SListPushFront(pphead, x);
	}
	else
	{
		SListNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}

		SListNode* newnode = BuySListNode(x);
		prev->next = newnode;
		newnode->next = pos;
	}
}

如果是在pos之后插入，就显得简洁多了。
在这里插入图片描述
pos之后：

void SListInsertAfter(SListNode* pos, SLTDataType x)
{
	assert(pos);
	SListNode* newnode = BuySListNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

3.2.9 单链表删除pos的数据（pos还是之后）

同理：
在这里插入图片描述
pos是第一个节点就调用头删
pos之前：

// 删除pos 位置
void SListErase(SListNode** pphead, SListNode* pos)
{
	assert(pphead);
	assert(pos);

	if (*pphead == pos)
	{
		SListPopFront(pphead);
	}
	else
	{
		SListNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}

		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}

pos之后：
在这里插入图片描述

void SListEraseAfter(SListNode* pos)
{
	assert(pos);

	SListNode* next = pos->next;
	if (next)
	{
		pos->next = next->next;
		free(next);
		next = NULL;
	}
}

3.2.10 删除单链表

在这里插入图片描述

void SListDestroy(SListNode** pphead)
{
	assert(pphead);

	SListNode* cur = *pphead;
	while (cur)
	{
		SListNode* next = cur->next;
		free(cur);
		cur = next;
	}

	*pphead = NULL;
}

3.2.11 SList.c完整代码

#define _CRT_SECURE_NO_WARNINGS 1
#include "SList.h"

void SListPrint(SListNode* phead)
{
	SListNode* cur = phead;
	while (cur != NULL)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}

SListNode* BuySListNode(SLTDateType x)
{
	SListNode* newnode = (SListNode*)malloc(sizeof(SListNode));
	if (newnode == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	else
	{
		newnode->data = x;
		newnode->next = NULL;
	}

	return newnode;
}

void SListPushBack(SListNode** pphead, SLTDateType x)
{
	assert(pphead);

	SListNode* newnode = BuySListNode(x);
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		// 找尾
		SListNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}

		tail->next = newnode;

		// 错误写法，这里没有链接起来
		/*SListNode* tail = *pphead;
		while (tail != NULL)
		{
		tail = tail->next;
		}

		tail = newnode;*/
	}
}

void SListPushFront(SListNode** pphead, SLTDateType x)
{
	assert(pphead);

	SListNode* newnode = BuySListNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}

void SListPopBack(SListNode** pphead)
{
	assert(pphead);

	// 也可以暴力检查为空的情况
	//assert(*pphead != NULL);

	// 1、空
	// 2、一个节点
	// 3、多个节点
	if (*pphead == NULL)  // 温柔检查
	{
		return;
	}
	else if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		/*SListNode* prev = NULL;
		SListNode* tail = *pphead;
		while (tail->next != NULL)
		{
		prev = tail;
		tail = tail->next;
		}

		free(tail);
		tail = NULL;
		prev->next = NULL;*/

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

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

void SListPopFront(SListNode** pphead)
{
	assert(pphead);

	// 1、空
	// 2、非空
	if (*pphead == NULL)
	{
		return;
	}
	else
	{
		SListNode* next = (*pphead)->next;
		free(*pphead);
		*pphead = next;
	}
}

SListNode* SListFind(SListNode* phead, SLTDateType x)
{
	SListNode* cur = phead;
	while (cur != NULL)
	{
		if (cur->data == x)
		{
			return cur;
		}

		cur = cur->next;
	}

	return NULL;
}

// 在pos位置之前插入
void SListInsert(SListNode** pphead, SListNode* pos, SLTDateType x)
{
	assert(pphead);
	assert(pos);

	// 1、pos是第一个节点
	// 2、pos不是第一个节点
	if (pos == *pphead)
	{
		SListPushFront(pphead, x);
	}
	else
	{
		SListNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}

		SListNode* newnode = BuySListNode(x);
		prev->next = newnode;
		newnode->next = pos;
	}
}

void SListInsertAfter(SListNode* pos, SLTDateType x)
{
	assert(pos);
	//SListNode* next = pos->next;
	//SListNode* newnode = BuySListNode(x);

	//pos->next = newnode;
	//newnode->next = next;

	SListNode* newnode = BuySListNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

// 删除pos 位置
void SListErase(SListNode** pphead, SListNode* pos)
{
	assert(pphead);
	assert(pos);

	if (*pphead == pos)
	{
		SListPopFront(pphead);
	}
	else
	{
		SListNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}

		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}

void SListEraseAfter(SListNode* pos)
{
	assert(pos);

	SListNode* next = pos->next;
	if (next)
	{
		pos->next = next->next;
		free(next);
		next = NULL;
	}
}

void SListDestroy(SListNode** pphead)
{
	assert(pphead);

	SListNode* cur = *pphead;
	while (cur)
	{
		SListNode* next = cur->next;
		free(cur);
		cur = next;
	}

	*pphead = NULL;
}

3.3 Test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "SList.h"

void TestSList1()
{
	/*SListNode* slist = NULL;
	SListNode* n1 = malloc(sizeof(SListNode));
	SListNode* n2 = malloc(sizeof(SListNode));
	SListNode* n3 = malloc(sizeof(SListNode));
	n1->data = 1;
	n2->data = 2;
	n3->data = 3;
	n1->next = n3;
	n3->next = n2;
	n2->next = NULL;
	slist = n1;*/

	SListNode* slist = NULL;
	SListNode* n1 = malloc(sizeof(SListNode));
	SListNode* n2 = malloc(sizeof(SListNode));
	SListNode* n3 = malloc(sizeof(SListNode));
	n1->data = 1;
	n2->data = 2;
	n3->data = 3;
	n1->next = n2;
	n2->next = n3;
	n3->next = NULL;
	slist = n1;

	SListPrint(slist);
}

void SwapInt(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

void SwapPInt(int** pp1, int** pp2)
{
	int* tmp = *pp1;
	*pp1 = *pp2;
	*pp2 = tmp;
}

void TestSList2()
{
	SListNode* slist = NULL; //空链表
	//SListPushBack(slist, 1);
	//SListPushBack(slist, 2);
	//SListPushBack(slist, 3);
	//SListPushBack(slist, 4);
	for (int i = 0; i < 4; ++i)
	{
		SListPushBack(&slist, i);
	}
	SListPrint(slist);

	// 函数中想改变实参int变量，要传int*
	int a = 0, b = 1;
	SwapInt(&a, &b);

	// 函数中想改变实参int*变量，要传int**  
	int* pa = &a, * pb = &b;
	//SwapInt(pa, pb);
	SwapPInt(&pa, &pb);
}

void TestSList3()
{
	SListNode* slist = NULL; //空链表
	SListPushBack(&slist, 1);
	SListPushBack(&slist, 2);
	SListPushBack(&slist, 3);
	SListPushBack(&slist, 4);

	SListPopBack(&slist);
	SListPopBack(&slist);
	SListPopBack(&slist);
	SListPopBack(&slist);
	SListPopBack(&slist);
	SListPrint(slist);
}

void TestSList4()
{
	SListNode* slist = NULL; //空链表
	SListPushBack(&slist, 1);
	SListPushBack(&slist, 2);
	SListPushBack(&slist, 3);
	SListPushBack(&slist, 4);

	SListPopFront(&slist);

	SListNode* pos = SListFind(slist, 3);
	if (pos)
	{
		printf("找到了:%p\n", pos);
		// 修改
		pos->data *= 10;
	}

	SListPrint(slist);
}

void TestSList5()
{
	SListNode* slist = NULL; //空链表
	SListPushBack(&slist, 1);
	SListPushBack(&slist, 2);
	SListPushBack(&slist, 3);
	SListPushBack(&slist, 4);
	SListPrint(slist);

	SListNode* pos = SListFind(slist, 3);
	if (pos)
	{
		SListInsert(&slist, pos, 30);
	}
	SListPrint(slist);

	pos = SListFind(slist, 1);
	if (pos)
	{
		SListInsert(&slist, pos, 30);
	}
	SListPrint(slist);
}

void TestSList6()
{
	SListNode* slist = NULL; //空链表
	SListPushBack(&slist, 1);
	SListPushBack(&slist, 2);
	SListPushBack(&slist, 3);
	SListPushBack(&slist, 4);
	SListPushBack(&slist, 5);
	SListPrint(slist);

	SListNode* pos = SListFind(slist, 3);
	if (pos)
	{
		SListErase(&slist, pos);
	}
	SListPrint(slist);

	pos = SListFind(slist, 1);
	if (pos)
	{
		SListErase(&slist, pos);
	}
	SListPrint(slist);
}

int main()
{
	TestSList6();

	return 0;
}

4运行结果

在这里插入图片描述

Yuucho
关注
专栏目录
数据结构——单链表（C语言）
Melody_my的博客
10-03 276
1.头插法创建两个升序单链表 2.使用两个单链表来合并两个单链表并按从大到小顺序排列 3.结果打印 4.在合并链表中查找指定的值 5.求表长 6.删除指定值 7.指定位置插入值 #include<stdio.h> #include<stdlib.h> typedef struct LNode{ int data; struct LNode *next; }LNode,*LinkList; LinkList initLinkList(){ LNode* h.
单链表(C语言版）
weixin_74999790的博客
03-17 630
单链表的英文是：Single Linked List（简称：SL,区别于顺序表的 SeqList 或 SQL)//int data;//为结构体指针，是指针，不是结构体，结构体里面不可嵌套结构体 };
单链表(C语言)
09-29
C语言的单链表，有存储、查询、删除等功能，代码简单，有注释。适合初学者
单链表（C语言）
qq_41607217的博客
03-31 399
单链表（C语言） Status init_Link(&L); 初始化操作 Status hCreate(&L,n); 头插 Status rCreate(&L,n); 尾插 ElemType get_Link(&L,i); 按位取元素 Status delete_Link(&L,i); 删除 Status empty_Link(&L); 判空 LinkList.h /* *项目名: LinkList *文件名: LinkList.h *创建者: CaoPeng
单链表(c语言）
weixin_48086091的博客
03-17 240
单链表
单链表（c语言版）
瑞_板凳精神
03-10 310
模拟手机类型管理 #include<stdio.h> #include<malloc.h> #include<string.h> #include<stdlib.h> typedef struct Phone { int price; char brand[8]; //int price2; struct Phone *next; }phone; phone *insert(phone *old,phone *new_) { if (old ==
单链表（C语言版）
10-11
对单链表操作 #include <stdio.h> #include<malloc.h> struct LNode { int data; struct LNode *next; }; struct LNode *create(int n) { int i; struct LNode *head,*p1,*p2; head=(struct LNode*)malloc(sizeof(struct LNode)); head->data=0; head->next=NULL; 。。。。。
单链表C语言版本
m0_59519697的博客
05-08 112
文章目录前言一、基础概念二、单链表操作总结 前言 新人小白学习记录，个人学习笔记 如有错误，还请指正，感谢各位。 一、基础概念 链表：链表是一种物理存储上非连续，数据元素的逻辑顺序通过链表中的指针链接次序，实现的一种线性存储结构。 特点： 链表由一系列节点（链表中每一个元素称为节点）组成，节点在运行时动态生成（malloc），每个节点包括两个部分： 一个是存储数据元素的数据域 另一个是存储下一个节点地址的指针域 二、单链表操作 定义 typedef struct Node { int data
建立学生信息无头结点单链表C语言版.pdf
06-10
"建立学生信息无头结点单链表C语言版" 本文档介绍了使用 C 语言建立学生信息无头结点单链表的实现。单链表是一种基础的数据结构，广泛应用于各个领域。 1. 单链表的定义 单链表是指每个结点仅有一个指针域的链表...
单链表（C语言版本）
12-02
简单的链表程序，初始化，创建，插入等 内涵注释，便于理解，适用于对c语言有一定基础的朋友
C语言的单链表
04-01
二.内核链表 内核链表是一种链表，Linux内核中的链表都是用这种形式实现的 1.特性 内核链表是一种双向循环链表，内核链表的节点节点结构中只有指针域 使用内核链表的时候，将内核链表作为一个成员放入到一个结构体中使用 我们在链表中找到内核链表结构的地址，通过这个地址就可以找到外部大结构体的地址，通过大结构体就可以访问其中的成员 优势： 内核链表突破了保存数据的限制，可以用内核链表来保存任何数据(使用一种链表表示各种类型的数据，通用性很强) 内核链表中只有指针域，维护起来更加方便，效率更高 2.使用 内核链表在内核中已经被实现，我们只需要调用其接口直接使用即可 内核链表的实现代码在内核源代码的list.h文件中 3.源代码分析 （1）节点结构： struct list_head { struct list_head *next, *prev;//前置指针 后置指针 }; （2）初始化 #define INIT_LIST_HEAD(ptr) do { \ (ptr)->next = (ptr); (ptr)->prev = (ptr); \ } while (0) （3）插入 //从头部插入 static inline void list_add(struct list_head *new, struct list_head *head)//传入要插入的节点和要插入的链表 { __list_add(new, head, head->next); } //从尾部插入 static inline void list_add_tail(struct list_head *new, struct list_head *head) { __list_add(new, head->prev, head); } （4）通过节点找到外部结构体的地址 //返回外部结构体的地址，第一个参数是节点地址，第二个参数是外部结构体的类型名，第三个参数是节点在外部结构体中的成员名 #define list_entry(ptr, type, member) ((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member))) （5）遍历内核链表 //遍历内核链表 #define list_for_each(pos, head) \ for (pos = (head)->next; pos != (head); \ pos = pos->next) //安全遍历内核链表 #define list_for_each_safe(pos, n, head) \ for (pos = (head)->next, n = pos->next; pos != (head); \ pos = n, n = pos->next) 二.内核链表 内核链表是一种链表，Linux内核中的链表都是用这种形式实现的 1.特性 内核链表是一种双向循环链表，内核链表的节点节点结构中只有指针域 使用内核链表的时候，将内核链表作为一个成员放入到一个结构体中使用 我们在链表中找到内核链表结构的地址，通过这个地址就可以找到外部大结构体的地址，通过大结构体就可以访问其中的成员 优势： 内核链表突破了保存数据的限制，可以用内核链表来保存任何数据(使用一种链表表示各种类型的数据，通用性很强) 内核链表中只有指针域，维护起来更加方便，效率更高 2.使用 内核链表在内核中已经被实现，我们只需要调用其接口直接使用即可 内核链表的实现代码在内核源代码的list.h文件中 3.源代码分析 （1）节点结构： struct list_head { struct list_head *next, *prev;//前置指针 后置指针 }; （2）初始化 #define INIT_LIST_HEAD(ptr) do { \ (ptr)->next = (ptr); (ptr)->prev = (ptr); \ } while (0) （3）插入 //从头部插入 static inline void list_add(struct list_head *new, struct list_head *head)//传入要插入的节点和要插入的链表 { __list_add(new, head, head->next); } //从尾部插入 static inline void list_add_tail(struct list_head *new, struct list_head *head) { __list_add(new, head->prev, head); } （4）通过节点找到外部结构体的地址 //返回外部结构体的地址，第一个参数是节点地址，第二个参数是外部结构体的类型名，第三个参数是节点在外部结构体中的成员名 #define list_entry(ptr, type, member) ((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member))) （5）遍历内核链表 //遍历内核链表 #define list_for_each(pos, head) \ for (pos = (head)->next; pos != (head); \ pos = pos->next) //安全遍历内核链表 #define list_for_each_safe(pos, n, head) \ for (pos = (head)->next, n = pos->next; pos != (head); \ pos = n, n = pos->next) 二.内核链表 内核链表是一种链表，Linux内核中的链表都是用这种形式实现的 1.特性 内核链表是一种双向循环链表，内核链表的节点节点结构中只有指针域 使用内核链表的时候，将内核链表作为一个成员放入到一个结构体中使用 我们在链表中找到内核链表结构的地址，通过这个地址就可以找到外部大结构体的地址，通过大结构体就可以访问其中的成员 优势： 内核链表突破了保存数据的限制，可以用内核链表来保存任何数据(使用一种链表表示各种类型的数据，通用性很强) 内核链表中只有指针域，维护起来更加方便，效率更高 2.使用 内核链表在内核中已经被实现，我们只需要调用其接口直接使用即可 内核链表的实现代码在内核源代码的list.h文件中 3.源代码分析 （1）节点结构： struct list_head { struct list_head *next, *prev;//前置指针 后置指针 }; （2）初始化 #define INIT_LIST_HEAD(ptr) do { \ (ptr)->next = (ptr); (ptr)->prev = (ptr); \ } while (0) （3）插入 //从头部插入 static inline void list_add(struct list_head *new, struct list_head *head)//传入要插入的节点和要插入的链表 { __list_add(new, head, head->next); } //从尾部插入 static inline void list_add_tail(struct list_head *new, struct list_head *head) { __list_add(new, head->prev, head); } （4）通过节点找到外部结构体的地址 //返回外部结构体的地址，第一个参数是节点地址，第二个参数是外部结构体的类型名，第三个参数是节点在外部结构体中的成员名 #define list_entry(ptr, type, member) ((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member))) （5）遍历内核链表 //遍历内核链表 #define list_for_each(pos, head) \ for (pos = (head)->next; pos != (head); \ pos = pos->next) //安全遍历内核链表 #define list_for_each_safe(pos, n, head) \ for (pos = (head)->next, n = pos->next; pos != (head); \ pos = n, n = pos->next) C语言下的单链表，可以增加，删除，查找，销毁节点。
单链表-C语言
mh_sun
04-14 210
// 单链表 #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <string.h> #include <stdlib.h> typedef int ElemType; /*定义单链表结点类型*/ typedef struct LNode { ElemType data; // 数据域...
单链表——c语言
HBINen的博客
03-10 2838
c语言实现单链表的基本操作，简单易懂，内有gif图帮助理解
C语言单链表
最新发布
myCs05的博客
01-18 709
【代码】C语言单链表。
单链表C语言
qq_52303089的博客
09-25 100
单链表就是用结构体创建一个个节点（数据域与指针域），各节点依次串连成表 #include<stdio.h> #define flag 0 #include<malloc.h> typedef int status; typedef int elemtype; typedef struct Lnode{ elemtype data; struct Lnode*next; }Lnode,*linklist; linklist h; linklist greatlist1(){
数据结构单链表c语言实现
03-26
数据结构的单链表C语言版完整实现，本人知识初学者实力浅浅，可能对于大佬来说只是rubb**。如果同样是初学者的话，可能对于你或许有些用处。如果帮助到你很开心，如果你觉得有些low希望可以提出宝贵的建议 ！！
C语言中的单链表
热门推荐
博观而约取
07-07 1万+
前言：对于大多数人来说，链表可能有点摸不着头脑，可能会问，为什么要用链表，多麻烦，我直接定义一个数组那不是很简单方便。其实链表就是动态的分配内存，用多少，开辟多少，这样内存空间就不会浪费。比如当我们定义一个数组 int a[10]来存放用户的信息,这时编译器就为数组分配了4*10 = 40个字节，但是有时候我们我们并不知道具体有多少个用户，这时候你直接定义出10个或者20个是不是会感觉有点浪费。数...
C语言——单链表
qq_62755767的博客
11-23 5515
一，链表的定义 链表是一种常见的采用动态存储分配方式的数据结构。在链表中，有一个头指针变量，用这个指针保存一个地址，头指针指向一个变量，这个变量称为元素。链表中，每一个元素包括两部分：数据部分和指针部分。数据部分用来存放元素中包含的数据，指针部分用来指向下一个元素 。（最后一个元素指向NULL） 在链表中，第一个结点前虚假一个头结点，头指针指向头结点，头结点的指针域指向第一个实际有效结点，该节点可以称为首元结点。 确定一个链表需要一个参数：头指针，通过头指针可以推算出链表其他所有的参数 二，单链表
c语言链表的复制,c 语言 复杂链表的复制
weixin_42512723的博客
05-21 845
//头文件#pragmaoncetypedefintDataType;typedefstructComplexNode{DataType_data;//数据structComplexNode*_next;//指向下一个节点的指针structComplexNode*_random;//指向随机节点}ComplexNode,*pComplexNode;voidBuyNode...
评论 16
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Yuucho

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值