用纯C实现单链表

已于 2023-02-06 07:46:20 修改
阅读量675 收藏 3
点赞数 12
分类专栏： C的数据结构 文章标签： c语言 链表 数据结构
于 2023-01-06 12:55:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wutongguo/article/details/127823435
版权

前言

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

链表的创建

需要创建一个小项目工程
创建三个文件
⭐SListNode.h放单链表的头文件，函数声明
⭐SListNode.c放单链表的函数
⭐test.c是主函数，存放框架，测试函数

(1)创建一个链表

首先，我们可以类比顺序表，在创建顺序表的时候，是用一个结构体来创建的,所以我们可以用结构体创建，包括数据和下一个结构体的地址(用来找到下一个地址)

typedef int SLTDataType;
 
typedef struct SListNode
{
	SLTDataType data;
	struct SListNode* next;
}SLT;

为什们用动态开辟？

首先我们知道局部变量出了作用域，就自己消除了，如果我们在一个函数中自己申请空间用来创建结构体，如果我们出了这个函数，我们就找不到这个链表，但是如果用动态空间，所开辟的空间在堆上存放，即便我们出了作用域，我们都来能找到这个链表，这就是我们动态开辟的原因。

(2)动态开辟单个链表

我们上面创建一个链表，只是创建了一个结构体，只是每一个链表中的元素有什们，而我们这个是给链表装东西，将链表的内容填充了。

//动态开辟一个链表
SLTNode* BuySLTNode(SLDataType n)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("malloc");
		exit(-1);
	}
	newnode->data = n;
	newnode->next = NULL;
	return newnode;
}

(3)创建n个链表

我们开辟完单个链表，链表的内容都有了，但是这个链表只有一个，我们要创建的链表不是只有一个，是需要我们将他们都串起来。所以我们下一步就是创建n个链表。具体的注意事项，我们都放在了代码的注释当中。

//创建n个链表
SLTNode* CreatSLT(int n)
{
	//这是为了省事，直接用循环创建n个单个链表
	int i = 0;
	//头指针是不能动的，因为最后返回的是链表的头指针
	//所以我们设置一个尾指针，先和头指针相同，移动的
	//时候移动尾指针就好了。
	SLTNode* phead = NULL;
	SLTNode* ptail = NULL;
	for (i = 0; i < n; i++)
	{
		SLTNode* newnode = BuySLTNode(i);
		//如果头指针是空指针，
		//那么先将头指针和尾指针还有新创建的单个链表设为相等
		if (phead == NULL)
		{
			phead = ptail = newnode;
		}
		else
		{
			ptail->next = newnode;
			ptail = newnode;
		}
	}
	return phead;
}

(4)打印链表

我们上面创建了链表，我们为了显示我们的链表，我们就要打印链表，进而显示我们链表，我们怎么打印链表，就仔细看代码就可以了，大家多看看注释，这很重要。

//打印链表
void PrintSLT(SLTNode* phead)
{
	//我们想一想，如果链表为空可不可以打印
	//很显然是可以的，我们打印一个空指针就很OK
	//所以我们不对他进行断言

	//我们一般不动我们的头指针，
	//所以我们要找一个东西代替他
	SLTNode* cur = phead;
	//我们打印肯定需要循环，是循环就需要条件，
	//我们循环的条件就是
	//直到我们遇到最后一个链表的next了，也就是空指针的时候
	while (cur ！= NULL)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	//因为最后一个肯定是空指针
	//为了打印的美观，我们打印一个空指针
	printf("NULL");
	
}

(5)单链表的尾插

现在我们将一个简易的链表做了出来，我们要实现链表的功能。
首先实现尾插的功能，但是有很多注意的事项，我们先看两段有点问题的代码，首先先自己想一下问题是什们，然后自己再看答案，我们只要解决了这个问题我们的功能基本上就解决了

问题一

//单链表尾插
void SLTPushBack(SLTNode* phead, SLDataType n)
{
	SLTNode* newnode = BuySLTNode(n);
	SLTNode* tail = phead;
	while (tail)
	{
		tail = tail->next;
	}
	tail = newnode;
}

其实这个问题还是比较容易发现的，只要我们画个图，我们就能发现这个条件其实是有问题的，当tail结束循环的时候tail等于NULL，而让我们新创建的链表等于空指针，没有任何作用。所以这个条件有问题。
其实这个问题还是很简单的，还有一个问题才是重点。我们先修改这个代码

问题二

//单链表尾插
void SLTPushBack(SLTNode* phead,SLTDataType n)
{
	SLTNode* newnode = BuySLTNode(n);
	SLTNode* tail = phead;
	while (tail->next)
	{
		tail = tail->next;
	}
	tail->next= newnode;
}

现在我们将循环的条件改变了，当tail的next等于空指针，我们在将tail的next赋值位新链表的地址我们就很好的修改了。

但是如果我们的链表为空的时候，我们能不能在尾插内容呢？
答案显而易见，当然是可以的，但是这时tail是NULL,我们在进行这个条件的时候tail->next，这时就发生了空指针的解引用。

这时候有的同学就说，我们可以用if条件区别一下空指针就可以了呀。我们先看代码。和调试。

//单链表尾插
void SLTPushBack(SLTNode* phead,SLDataType n)
{
	SLTNode* newnode = BuySLTNode(n);
	SLTNode* tail = phead;
	if (phead == NULL)
	{
		tail = phead = newnode;
	}
	else
	{
		while (tail->next)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}

我们发现在我们进行测试的时候，我们开头是空指针的时候，并没有尾插上，到底是什们原因呢？
在这里插入图片描述

我们知道，形参的改变并不会影响实参。我们在进行尾插的时候，传的是一级指针，在我们的函数调用中phead是NULL，在if条件下将phead赋值为newnode,但是再出了这个函数后，我们的phead还是NULL，并不会改变，因为，形参的改变并不会影响实参。

如果我们不理解，可以不要将phead想象成一个指针，就把他当作一个整型，在函数中，我们改变他，只是在函数的作用域中有用，一旦出了这个作用域，那么改变的量就不会起作用，他是多少就是多少，如果想在函数中改变他的值，我们就需要传该数的指针，通过改变指针的方式，才能改变该数的实参。

所以我们想要改变phead，我们需要通过phead的指针来改变phead也就要用到二级指针。

//单链表尾插
void SLTPushBack(SLTNode** pphead,SLDataType n)
{
	SLTNode* newnode = BuySLTNode(n);
	
	if (*pphead == NULL)
	{
		 *pphead = newnode;
	}
	else
	{
		SLTNode* tail = *pphead;
		while (tail->next)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}

(6)单链表的尾删

单链表尾删，我们就是将最后一个链表的上一个链表的next设置为NULL
怎么找最后一个链表的上一个链表，具体操作看代码注释。

//单链表尾删
void SLTPopBack(SLTNode* phead)
{
	//我们在移动的时候一般不移动phead
	//所以我们一般都使用另一个来代替phead
	SLTNode* tail = phead;
	//因为我们要将tail的前面的链表找到所以
	//创建一个prev
	SLTNode* prev = NULL;
	while (tail->next)
	{
		prev = tail;
		tail = tail->next;
	}
	free(tail);
	//将prev的next滞空，就相当于删除了
	prev->next = NULL;
}

这个其实也是有问题的，我们如果只剩下一个结点，我们要找tail前一个结点就没有，所以我们这个需要分类讨论。
请看下面代码

//单链表尾删
void SLTPopBack(SLTNode* phead)
{
	//我们只有一个结点，分类讨论
	if (phead->next == NULL)
	{
		free(phead);
		//和上面一样的问题
		phead = NULL;
	}
	else
	{
		//我们在移动的时候一般不移动phead
		//所以我们一般都使用另一个来代替phead
		SLTNode* tail = phead;
		//因为我们要将tail的前面的链表找到所以
		//创建一个prev
		SLTNode* prev = NULL;
		while (tail->next)
		{
			prev = tail;
			tail = tail->next;
		}
		free(tail);
		//将prev的next滞空，就相当于删除了
		prev->next = NULL;
	}
	
}

我们其实还有问题，在注释上也写到了，我们形参的改变不影响实参的改变，并不能将phead变为空指针，所以我们还是要用二级指针。

//单链表尾删
void SLTPopBack(SLTNode** pphead)
{
	//如果链表为空，我们就不能再删了
	//需要断言
	assert(*pphead);
	//我们只有一个结点，分类讨论
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		//我们在移动的时候一般不移动phead
		//所以我们一般都使用另一个来代替phead
		SLTNode* tail = *pphead;
		//因为我们要将tail的前面的链表找到所以
		//创建一个prev
		SLTNode* prev = NULL;
		while (tail->next)
		{
			prev = tail;
			tail = tail->next;
		}
		free(tail);
		//将prev的next滞空，就相当于删除了
		prev->next = NULL;
	}
}

(7)单链表的头插

其实我们的单链表的头插和头删，还是要用二级指针。
头插其实很简单，就是先创建一个结点，然后将结点的next赋值为第一个节点的地址，就可以了。

//单链表的头插
void SLTPushFront(SLTNode** pphead, SLDataType n)
{
	SLTNode* newnode = BuySLTNode(n);
	newnode->next = *pphead;
	//头插完，将插完的第一个设为头结点
	*pphead = newnode;
}

(8)单链表的头删

头删就是将头结点放到下一个结点就行

//单链表头删
void SLTPopFront(SLTNode** pphead)
{
	//防止空指针的解引用
	assert(*pphead);
	SLTNode* next = (*pphead)->next;
	free(*pphead);
	*pphead = next;
}

(9)链表的查找

因为我们后面要进行，在链表的中间进行添加和删除，我们就是需要，先找到我们需要在哪里添加和删除，我们就要进行查找。因为查找我们不需要进行修改头指针，所以我们就不需要用二级指针。用一级指针就可以了。
我们知道了为什们查找，所以我们就看下面的代码吧。

//链表的查找
SLTNode* SLTFind(SLTNode* phead, SLDataType n)
{
	SLTNode* cur = phead;
	while (cur)
	{
		if (cur->data == n)
			return cur;
		else
			cur = cur->next;
	}
	return NULL;
}

(10)在pos后插入

我们先用查找函数，找到我们要插入的位置，也就是pos,然后我们再将需要插入的东西插入就可以了。

//在pos后进行插入
void SLTInsertAfter(SLTNode* pos, SLDataType n)
{
	assert(pos);
	SLTNode* newnode = BuySLTNode(n);
	newnode->next = pos->next;
	pos->next = newnode;
}

(11)在pos前插入

其实是一样的道理，但是我们需要找到pos前的结点，我们就需要从头开始寻找，找到pos前的结点，然后在进行改变。
但是如果我们在第一个结点前插入，我们就变成了头插，我们就需要改变头指针，所以我们就要用二级指针。

//在pos前进行插入
void SLTInsertFront(SLTNode** pphead,SLTNode* pos, SLDataType n)
{
	assert(pos);
	
	if (*pphead == pos)
	{
		SLTPushFront(pphead, n);
	}
	else
	{
		SLTNode* cur = *pphead;
		while (cur->next != pos)
		{
			cur = cur->next;
		}
		SLTNode* newnode = BuySLTNode(n);
		cur->next = newnode;
		newnode->next = pos;
	}
}

(12)删除pos之后的结点

这个非常简单，我们直接看代码，注释有解释。

//删除pos之后
void SLTEraseAfter(SLTNode* pos)
{
	assert(pos);
	//如果pos是最后一个，那么我们还删什们
	//就直接返回就行，不删除
	if (pos->next == NULL)
	{
		return;
	}
	else
	{
		SLTNode* nextNode = pos->next;
		pos->next = nextNode->next;
		free(nextNode);
		//nextNode = NULL;
	}
}

(13)删除pos位置的结点

这个类比就行了，直接看代码，非常简单的。我们删除还可能是头删，所以我们还是用二级指针。注释解释

//删除pos位置
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pos);
	//就是头删就直接调用就可以了
	if (*pphead == NULL)
	{
		SLTPopFront(pphead);
	}
	else
	{
		SLTNode* cur = *pphead;
		while (cur->next != pos)
		{
			cur = cur->next;
		}
		cur->next = pos->next;
		free(pos);
	}
}

(14)单链表的释放

就是动态开放完，然后再用free释放。直接上代码

//单链表的释放
void SLTDestroy(SLTNode** pphead)
{
	SLTNode* cur = *pphead;
	//循环一个一个释放
	while (cur)
	{
		SLTNode* next = cur->next;
		free(cur);
		cur = next;
	}
}

总结

其实对于我们的单链表，我们就基本上讲完了，其中最关键的问题，也是最难的问题就是我们要理解为什们要用二级指针。只要理解了这一点，我相信大家一定可以钻研明白。

还有一个问题就是，我们对于在主函数，就不进行包装了，我们自己测试就可以了，我们最后将函数的声明和实现给大家。
希望大家一起进步一起加油！！！！！

SListNode.h代码

#pragma once
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
typedef int SLDataType;

//创建一个单链表
typedef struct SListNode
{
	SLDataType data;
	struct SListNode* next;
}SLTNode;

//动态开辟一个链表
SLTNode* BuySLTNode(SLDataType n);

//创建n个链表
SLTNode* CreatSLT(int n);

//打印链表
void PrintSLT(SLTNode* phead);

//链表的尾插
void SLTPushBack(SLTNode** pphead, SLDataType n);

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

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

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

//链表的查找
SLTNode* SLTFind(SLTNode* phead, SLDataType n);

//在pos后进行插入
void SLTInsertAfter(SLTNode* pos, SLDataType n);

//在pos前进行插入
void SLTInsertFront(SLTNode** pphead,SLTNode* pos, SLDataType n);

//删除pos位置
void SLTErase(SLTNode** pphead, SLTNode* pos);

//单链表的释放
void SLTDestroy(SLTNode** pphead);

SListNode.c代码

#define _CRT_SECURE_NO_WARNINGS 1
#include"SListNode.h"


//动态开辟一个链表
SLTNode* BuySLTNode(SLDataType n)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("malloc");
		exit(-1);
	}
	newnode->data = n;
	newnode->next = NULL;
	return newnode;
}

//创建n个链表
SLTNode* CreatSLT(int n)
{
	//这是为了省事，直接用循环创建n个单个链表
	int i = 0;
	//头指针是不能动的，因为最后返回的是链表的头指针
	//所以我们设置一个尾指针，先和头指针相同，移动的
	//时候移动尾指针就好了。
	SLTNode* phead = NULL;
	SLTNode* ptail = NULL;
	for (i = 1; i <= n; i++)
	{
		SLTNode* newnode = BuySLTNode(i);
		//如果头指针是空指针，
		//那么先将头指针和尾指针还有新创建的单个链表设为相等
		if (phead == NULL)
		{
			phead = ptail = newnode;
		}
		else
		{
			ptail->next = newnode;
			ptail = newnode;
		}
	}
	return phead;
}

//打印链表
void PrintSLT(SLTNode* phead)
{
	//我们想一想，如果链表为空可不可以打印
	//很显然是可以的，我们打印一个空指针就很OK
	//所以我们不对他进行断言

	//我们一般不动我们的头指针，
	//所以我们要找一个东西代替他
	SLTNode* cur = phead;
	//我们打印肯定需要循环，是循环就需要条件，
	//我们循环的条件就是
	//直到我们遇到最后一个链表的next了，也就是空指针的时候
	while (cur != NULL)
	{
		printf("%d -> ", cur->data);
		cur = cur->next;
	}
	//因为最后一个肯定是空指针
	//为了打印的美观，我们打印一个空指针
	printf("NULL\n");
	
}

//单链表尾插
void SLTPushBack(SLTNode** pphead,SLDataType n)
{
	SLTNode* newnode = BuySLTNode(n);
	
	if (*pphead == NULL)
	{
		 *pphead = newnode;
	}
	else
	{
		SLTNode* tail = *pphead;
		while (tail->next)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}
//单链表尾删
void SLTPopBack(SLTNode** pphead)
{
	//如果链表为空，我们就不能再删了
	//需要断言
	assert(*pphead);
	//我们只有一个结点，分类讨论
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		//我们在移动的时候一般不移动phead
		//所以我们一般都使用另一个来代替phead
		SLTNode* tail = *pphead;
		//因为我们要将tail的前面的链表找到所以
		//创建一个prev
		SLTNode* prev = NULL;
		while (tail->next)
		{
			prev = tail;
			tail = tail->next;
		}
		free(tail);
		//将prev的next滞空，就相当于删除了
		prev->next = NULL;
	}
	
}
//单链表的头插
void SLTPushFront(SLTNode** pphead, SLDataType n)
{
	SLTNode* newnode = BuySLTNode(n);
	newnode->next = *pphead;
	//头插完，将插完的第一个设为头结点
	*pphead = newnode;
}

//单链表头删
void SLTPopFront(SLTNode** pphead)
{
	//防止空指针的解引用
	assert(*pphead);
	SLTNode* next = (*pphead)->next;
	free(*pphead);
	*pphead = next;
}

//链表的查找
SLTNode* SLTFind(SLTNode* phead, SLDataType n)
{
	SLTNode* cur = phead;
	while (cur)
	{
		if (cur->data == n)
			return cur;
		else
			cur = cur->next;
	}
	return NULL;
}

//在pos后进行插入
void SLTInsertAfter(SLTNode* pos, SLDataType n)
{
	assert(pos);
	SLTNode* newnode = BuySLTNode(n);
	newnode->next = pos->next;
	pos->next = newnode;
}

//在pos前进行插入
void SLTInsertFront(SLTNode** pphead,SLTNode* pos, SLDataType n)
{
	assert(pos);
	
	if (*pphead == pos)
	{
		SLTPushFront(pphead, n);
	}
	else
	{
		SLTNode* cur = *pphead;
		while (cur->next != pos)
		{
			cur = cur->next;
		}
		SLTNode* newnode = BuySLTNode(n);
		cur->next = newnode;
		newnode->next = pos;
	}
}

//删除pos之后
void SLTEraseAfter(SLTNode* pos)
{
	assert(pos);
	//如果pos是最后一个，那么我们还删什们
	//就直接返回就行，不删除
	if (pos->next == NULL)
	{
		return;
	}
	else
	{
		SLTNode* nextNode = pos->next;
		pos->next = nextNode->next;
		free(nextNode);
		//nextNode = NULL;
	}
}
//删除pos位置
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pos);
	//就是头删就直接调用就可以了
	if (*pphead == NULL)
	{
		SLTPopFront(pphead);
	}
	else
	{
		SLTNode* cur = *pphead;
		while (cur->next != pos)
		{
			cur = cur->next;
		}
		cur->next = pos->next;
		free(pos);
	}
}

//单链表的释放
void SLTDestroy(SLTNode** pphead)
{
	SLTNode* cur = *pphead;
	//循环一个一个释放
	while (cur)
	{
		SLTNode* next = cur->next;
		free(cur);
		cur = next;
	}
}
桐桐超努力
关注
  • 12
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 5
    评论
专栏目录
c语言实现单链表算法示例分享
09-04
"c语言实现单链表算法示例分享" 单链表是一种基础的数据结构，在计算机科学中广泛应用。下面将详细介绍c语言实现单链表算法的示例。 1. 单链表的定义 单链表是一种链式数据结构，其中每个节点由数据域和指针域...
用C语言实现单链表的各种操作(一)
09-05
本文将详细介绍如何用C语言实现单链表的各种操作。 首先，我们定义链表的结构体`LNode`，它包括一个数据域`ElemType data`和一个指向下一个节点的指针`struct LNode *next`： ```c typedef struct LNode{ ...
链表的纯C实现
weixin_51215850的博客
03-30 1125
这道题是我们学校的题目，感觉挺有意思的，也写了有蛮久，我把的代码和思路大致分析一下，希望能给你们带来一些用处。 题目要求是要把c++改成c，原来的c++代码已经全部给出，我改完之后的代码如下(原来的部分代码我就直接注释掉了，然后再改，这样的话可能方便对比)。 //#include<iostream> //#include<cstdio> //#include<cstdlib> //using namespace std; #include<stdio.h>
【数据结构】C语言实现单链表
SHLYYY
04-30 2907
SLLNode;// 打印 void SLLPrint(SLLNode * phead);// 头插、尾插 void SLLPushFront(SLLNode * * pphead , SLLDataType x);// 头删、尾删 void SLLPopFront(SLLNode * * pphead);// 查找 SLLNode * SLLFind(SLLNode * phead , SLLDataType x);
C语言的链表实现
weixin_73728044的博客
10-16 1598
C语言各种链表学习记录
c语言实现链表（详解）
最新发布
yzc的博客
12-11 854
链表的实现
链表（c语言实现）
热门推荐
zjq_love的博客
03-30 2万+
1.链表的分类 实际中链表的结构非常多样，以下情况组合起来就有8种链表结构： （1）单向或者双向 （2）带头或者不带头 （3）循环或者非循环 虽然有这么多的链表的结构，但是我们实际中最常用还是两种结构： 1. 无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。 2. 带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。 2.无头单向非循环链表的实现 // ...
用C语言实现单链表的各种操作(二)
01-20
用C语言实现单链表的各种操作(一)>主要是单链表的一些最基本的操作，下面，主要是一些其他的典型的算法和测试程序。 代码如下:/* 对单链表进行排序处理*/struct LNode *sort(struct LNode *head){ LinkList *p; ...
C语言实现单链表
08-23
C语言实现单链表
【数据结构】纯c语言版单链表
qq_64484137的博客
08-07 708
老师不会讲的纯c语言版链表的头插头删，尾插尾删，以及节点的创建等等一切操作，走过路过不要错过。 以及一些进阶小技巧
纯C语言实现仿C++STL泛型链表
03-04
纯C语言实现仿C++STL泛型链表，实现了C++STL链表的基本功能，但代码并未做完善的测试，性能也不能保障，主要用于初学者学习
纯C语言实现的通用链表（类）源代码
01-14
纯C语言实现的通用链表（类）源代码，可以供学习参考，内附代码，可执行
数据结构——C语言实现链表
theonly_Love的博客
05-22 1万+
一. 链表的概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。在这里介绍链表中的两种结构
链表实现(C)
m0_62616069的博客
05-05 313
1.链表 链表是线性表，结构中的数据存放也是呈线性结构，但是，数据元素的逻辑顺序是通过链表中的指针链接次序实现的，即存储的空间不像数组一样是相连的，而是随机的。 链表的分类： 1：单向和双向 2：不循环和循环 3：含头节点和不含头节点 头节点一般不用来存放数据 1.2 单链表 单链表即无头单向不循环链表，是所有链表结构中最简单的一个 创建一个单链表： typedef int DateType; typedef struct SingleListNode { DateType date
数据类型——链表的简单实现（C语言实现链表）
weixin_72883322的博客
12-27 677
本博客讲述了链表是什么以及链表要如何实现，用一个使用案例带大家初步了解链表数据结构
数据结构-链表（纯c语言实现）
SIN0212的博客
12-17 554
#include <stdio.h> #include <stdlib.h> typedef struct node{ int date; struct node *next; }LNode,*LinkList; LinkList GreatLinkList(int n){//初始化链表 LinkList p,list=NULL,r; int e; for(in...
数据结构之链表实现（c语言）
m0_64334842的博客
11-09 1539
数据结构之链表介绍
C实现链表
weixin_54792212的博客
03-23 2385
文章目录前言一、链表1.1 链表的概念和结构1.2 链表的分类二、无单非链表的实现2.1 数据结构和接口2.2 接口函数的定义（实现）2.3 接口的调用3.带双循链表的实现3.1 数据结构和接口3.2 接口函数的定义（实现）3.3 接口的调用4. 顺序表和链表的区别4.1 顺序表的优缺点4.2 链表的优缺点 前言 之前的文章用C实现了顺序表，而顺序表有一些缺点： 中间/头部的插入删除，时间复杂度为O(N) 扩容需要申请新空间，拷贝数据，释放旧空间，会有不小的性能消耗 具体扩容时都是当前空间的二倍进行扩容，
使用c语言实现单链表
07-28
单链表是一种常见的数据结构，可以使用C语言来实现。下面是一个简单的单链表的实现示例： ```c #include #include // 定义链表节点结构 typedef struct Node { int data; // 节点存储的数据 struct Node* next...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

桐桐超努力

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

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

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

打赏作者

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

抵扣说明：

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

余额充值