单向链表的基本操作

最新推荐文章于 2022-10-18 22:42:38 发布
最新推荐文章于 2022-10-18 22:42:38 发布
阅读量178 收藏
点赞数
分类专栏： C
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zyxiaolei/article/details/79771203
版权

此单向链表无头结点，不带环

linklist.h

#define _CRT_SECURE_NO_WARNINGS 1
#pragma once

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>

typedef char LinkType;

typedef struct LinkNode 
{
	LinkType data;
	struct LinkNode* next;
} LinkNode;

void LinkListInit(LinkNode** head);//初始化链表 
LinkNode* LinkListPushBack(LinkNode** head, LinkType value);//尾插一个元素
void LinkListPopBack(LinkNode** head);//尾删一个元素
void LinkListPushFront(LinkNode** head, LinkType value);//头插一个元素
void LinkListPopFront(LinkNode** head);//头删一个元素
LinkNode* LinkListFind(LinkNode* head, LinkType to_find);//查找元素在链表中的位置
void LinkListInsertBefore(LinkNode** head, LinkNode* pos, LinkType value);//在pos之前插入元素
void LinkListInsertAfter(LinkNode** head, LinkNode* pos, LinkType value);//在pos之后插入元素
void LinkListErase1(LinkNode** head, LinkNode* pos);//删除指定位置的元素
void LinkListErase2(LinkNode* head, LinkNode* pos);
void LinkListRemove1(LinkNode** head, LinkType to_delete);//删除指定值的元素
void LinkListRemove2(LinkNode** head, LinkType to_delete);
void LinkListRemoveAll(LinkNode** head, LinkType value);//指定值的所有元素都删掉
int LinkListIsEmpty(LinkNode* head);//判定链表为空
size_t LinkListSize(LinkNode* head);//求链表的元素个数

linklist.c

#include "linklist.h"

//初始化链表
void LinkListInit(LinkNode** head)
{
	if (head == NULL)
		return;
	*head = NULL;
}

LinkNode* LinkListGreateNode(LinkType value)
{
	LinkNode* ptr = (LinkNode*)malloc(sizeof(LinkNode));//(malloc)ptr在堆上创建，可以return ptr
	//LinkNode node;
	//LinkNode* ptr = &node;//错误! ptr在栈上创建，不可以return ptr
	ptr->data = value;
	ptr->next = NULL;
	return ptr;
}

//尾插一个元素到链表中
LinkNode* LinkListPushBack(LinkNode** head, LinkType value)
{
	LinkNode* cur = *head;
	if (head == NULL)
		return NULL;
	if (*head == NULL)
	{
		*head = LinkListGreateNode(value);
		return *head;
	}
	while (cur->next != NULL)
	{
		cur = cur->next;
	}
	cur->next = LinkListGreateNode(value);
	return cur->next;
}

void LinkListDestroyNode(LinkNode* ptr)
{
	free(ptr);
}

//尾删一个元素
void LinkListPopBack(LinkNode** head)
{
	LinkNode* cur = *head;
	if (head == NULL)
		return;
	if (*head == NULL)
		return;
	if (cur->next == NULL)
	{
		LinkListDestroyNode(cur);
		*head = NULL;
		return;
	}
	while (cur->next != NULL)
	{
		if (cur->next->next == NULL)
		{
			LinkNode* to_delete = cur->next;
			cur->next = NULL;
			LinkListDestroyNode(to_delete);
			return;
		}
		cur = cur->next;
	}
}

//头插一个元素
void LinkListPushFront(LinkNode** head, LinkType value)
{
	if (head == NULL)
		return;
	if (*head == NULL)
	{
		*head = LinkListGreateNode(value);
		return;
	}
	LinkNode* new_node = LinkListGreateNode(value);
	new_node->next = *head;
	*head = new_node;
	return;
}

//头删一个元素
void LinkListPopFront(LinkNode** head)
{
	LinkNode* to_delete = *head;
	if (head == NULL)
		return;
	if (*head == NULL)
		return;
	*head = to_delete->next;
	LinkListDestroyNode(to_delete);
}

//查找元素在链表中的位置
LinkNode* LinkListFind(LinkNode* head, LinkType to_find)
{
	LinkNode* cur = head;
	for (; cur != NULL; cur = cur->next)
	{
		if (cur->data == to_find)
			return cur;
	}
	return NULL;
}

//在pos之前插入元素
void LinkListInsertBefore(LinkNode** head, LinkNode* pos, LinkType value)
{
	LinkNode* cur = *head;
	if (head == NULL)
		return;
	if (*head == NULL)
	{
		*head = LinkListGreateNode(value);
		return;
	}
	if (*head = pos)
	{
		LinkListPushFront(head, value);
		return;
	}
	if (pos == NULL)
	{
		LinkListPushBack(head, value);
		return;
	}
	while (cur->next != NULL)
	{
		if (cur->next == pos)
		{
			LinkNode* new_node = LinkListGreateNode(value);
			new_node->next = pos;
			cur->next = new_node;
			return;
		}
		cur = cur->next;
	}
	return;
}

//在pos之后插入元素
void LinkListInsertAfter(LinkNode** head, LinkNode* pos, LinkType value)
{
	LinkNode* new_node = LinkListGreateNode(value);
	if (head == NULL)
		return;
	if (pos == NULL)
		return;
	new_node->next = pos->next;
	pos->next = new_node;
	return;
}

//删除指定位置的元素
void LinkListErase1(LinkNode** head, LinkNode* pos)
{
	LinkNode* cur = *head;
	if (head == NULL)
		return;
	if (*head == NULL)
		return;
	if (*head == pos)
	{
		LinkNode* to_delete = *head;
		*head = to_delete->next;
		LinkListDestroyNode(to_delete);
		return;
	}
	while (cur->next != NULL)
	{
		if (cur->next == pos)
		{
			cur->next = pos->next;
			LinkListDestroyNode(pos);
			return;
		}
		cur = cur->next;
	}
	return;
}

void LinkListErase2(LinkNode* head, LinkNode* pos)
{
	if (head == NULL)
		return;
	if (pos != NULL && pos->next != NULL)
	{
		pos->data = pos->next->data;
		LinkNode* to_delete = pos->next;
		pos->next = to_delete->next;
		LinkListDestroyNode(to_delete);
		return;
	}
	return;
}

//删除指定值的元素
void LinkListRemove1(LinkNode** head, LinkType to_delete)
{
	LinkNode* pos = LinkListFind(*head, to_delete);
	if (head == NULL)
		return;
	if (*head == NULL)
		return;
	LinkListErase1(head, pos);
	return;
}

void LinkListRemove2(LinkNode** head, LinkType to_delete)
{
	if (head == NULL)
		return;
	if (*head == NULL)
		return;
	if ((*head)->data == to_delete)
	{
		LinkNode* delete = *head;
		*head = delete->next;
		LinkListDestroyNode(delete);
		return;
	}
	LinkNode* cur = (*head)->next;
	LinkNode* pre = *head;
	while (cur != NULL)
	{
		if (cur->data == to_delete)
		{
			pre->next = cur->next;
			LinkListDestroyNode(cur);
			return;
		}
		cur = cur->next;
		pre = pre->next;
	}
	return;
}

//指定值的所有元素都删掉
void LinkListRemoveAll(LinkNode** head, LinkType value)
{
	if (head == NULL)
		return;
	if (*head == NULL)
		return;
	while (1)
	{
		LinkNode* pos = LinkListFind(*head, value);
		if (pos == NULL)
			return;
		LinkListErase1(head, pos);
	}
	return;
}

//判定链表为空
int LinkListIsEmpty(LinkNode* head)
{
	return head == NULL ? 1 : 0;
}

//求链表的元素个数
size_t LinkListSize(LinkNode* head)
{
	size_t count = 0;
	LinkNode* cur = head;
	if (head = NULL)
		return -1;
	while (cur != NULL)
	{
		++count;
		cur = cur->next;
	}
	return count;
}
//
//以下为测试代码//
/
#define TEST_HEADER printf("\n**********%s**********\n",__FUNCTION__)
void LinkListPrintf(LinkNode* head, char* msg)
{
	printf("%s\n", msg);
	LinkNode* cur = head;
	for (; cur != NULL; cur = cur->next)
	{
		printf("[%c:%p] -> ", cur->data, cur);
	}
	printf("[NULL]\n");
}

void TestInit()
{
	TEST_HEADER;
	LinkNode* head;
	LinkListInit(&head);
	LinkListPrintf(head, "初始化链表");
	printf("[head]=%p,head=%ld\n", head, (long)head);
}

void TestPushBack()
{
	TEST_HEADER;
	LinkNode* head;
	LinkListInit(&head);
	LinkListPushBack(&head, 'a');
	LinkListPushBack(&head, 'b');
	LinkListPushBack(&head, 'c');
	LinkListPushBack(&head, 'd');
	LinkListPushBack(&head, 'e');
	LinkListPrintf(head, "尾插五个元素");
}

void TestLinkListPopBack()
{
	TEST_HEADER;
	LinkNode* head;
	LinkListInit(&head);
	LinkListPushBack(&head, 'a');
	LinkListPushBack(&head, 'b');
	LinkListPushBack(&head, 'c');
	LinkListPushBack(&head, 'd');
	LinkListPushBack(&head, 'e');
	LinkListPrintf(head, "尾插五个元素");
	LinkListPopBack(&head);
	LinkListPopBack(&head);
	LinkListPrintf(head, "尾删两个元素");
}

void TestPushFront()
{
	TEST_HEADER;
	LinkNode* head;
	LinkListInit(&head);
	LinkListPushBack(&head, 'a');
	LinkListPushBack(&head, 'b');
	LinkListPushBack(&head, 'c');
	LinkListPrintf(head, "尾插三个元素");
	LinkListPushFront(&head, 'd');
	LinkListPushFront(&head, 'e');
	LinkListPrintf(head, "头插两个元素");
}

void TestPopFront()
{
	TEST_HEADER;
	LinkNode* head;
	LinkListInit(&head);
	LinkListPushBack(&head, 'a');
	LinkListPushBack(&head, 'b');
	LinkListPushBack(&head, 'c');
	LinkListPushBack(&head, 'd');
	LinkListPushBack(&head, 'e');
	LinkListPrintf(head, "尾插五个元素");
	LinkListPopFront(&head);
	LinkListPopFront(&head);
	LinkListPrintf(head, "头删两个元素");
}


void TestFind()
{
	TEST_HEADER;
	LinkNode* head;
	LinkListInit(&head);
	LinkListPushBack(&head, 'a');
	LinkNode* pos_b = LinkListPushBack(&head, 'b');
	LinkListPushBack(&head, 'c');
	LinkListPushBack(&head, 'd');
	LinkListPushBack(&head, 'e');
	LinkListPrintf(head, "尾插五个元素");
	LinkNode* pos = LinkListFind(head, 'b');
	printf("pos b expect %p,actual %p\n", pos_b, pos);
}

void TestInsertBefore()
{
	TEST_HEADER;
	LinkNode* head;
	LinkListInit(&head);
	LinkListPushBack(&head, 'a');
	LinkListPushBack(&head, 'b');
	LinkListPushBack(&head, 'c');
	LinkListPrintf(head, "尾插三个元素");
	LinkNode* pos = LinkListFind(head, 'a');
	LinkListInsertBefore(&head, pos, 'd');
	LinkListPrintf(head, "在下标0之前插入元素'd'");
}

void TestInsertAfter()
{
	TEST_HEADER;
	LinkNode* head;
	LinkListInit(&head);
	LinkListPushBack(&head, 'a');
	LinkListPushBack(&head, 'b');
	LinkListPushBack(&head, 'c');
	LinkListPrintf(head, "尾插三个元素");
	LinkNode* pos = LinkListFind(head, 'a');
	LinkListInsertAfter(&head, pos, 'd');
	LinkListPrintf(head, "在下标0之后插入元素'd'");
}

void TestErase()
{
	TEST_HEADER;
	LinkNode* head;
	LinkListInit(&head);
	LinkListPushBack(&head, 'a');
	LinkListPushBack(&head, 'b');
	LinkListPushBack(&head, 'c');
	LinkListPushBack(&head, 'd');
	LinkListPushBack(&head, 'e');
	LinkListPrintf(head, "尾插五个元素");
	LinkNode* pos1 = LinkListFind(head, 'a');
	LinkListErase1(&head, pos1);
	LinkListPrintf(head, "删除下标为0的元素'a'");
	LinkNode* pos2 = LinkListFind(head, 'c');
	LinkListErase2(head, pos2);
	LinkListPrintf(head, "删除下标为1的元素'c'");
}

void TestRemove()
{
	TEST_HEADER;
	LinkNode* head;
	LinkListInit(&head);
	LinkListPushBack(&head, 'a');
	LinkListPushBack(&head, 'b');
	LinkListPushBack(&head, 'c');
	LinkListPushBack(&head, 'd');
	LinkListPushBack(&head, 'e');
	LinkListPrintf(head, "尾插五个元素");
	LinkListRemove2(&head, 'b');
	LinkListPrintf(head, "删除指定值的元素'b'");
}

void TestRemoveAll()
{
	TEST_HEADER;
	LinkNode* head;
	LinkListInit(&head);
	LinkListPushBack(&head, 'a');
	LinkListPushBack(&head, 'b');
	LinkListPushBack(&head, 'b');
	LinkListPushBack(&head, 'b');
	LinkListPushBack(&head, 'c');
	LinkListPrintf(head, "尾插五个元素");
	LinkListRemoveAll(&head, 'b');
	LinkListPrintf(head, "指定值的所有元素'b'都删掉");
}

void TestIsEmpty()
{
	TEST_HEADER;
	LinkNode* head;
	LinkListInit(&head);
	int ret = LinkListIsEmpty(head);
	printf("%d\n", ret);
}

void TestSize()
{
	TEST_HEADER;
	LinkNode* head;
	LinkListInit(&head);
	LinkListPushBack(&head, 'a');
	LinkListPushBack(&head, 'b');
	LinkListPushBack(&head, 'b');
	LinkListPushBack(&head, 'b');
	LinkListPushBack(&head, 'c');
	LinkListPrintf(head, "尾插五个元素");
	size_t size = LinkListSize(head);
	printf("size=%d\n", size);
}

int main()
{
	TestInit();
	TestPushBack();
	TestLinkListPopBack();
	TestPushFront();
	TestPopFront();
	TestFind();
	TestInsertBefore();
	TestInsertAfter();
	TestErase();
	TestRemove();
	TestRemoveAll();
	TestIsEmpty();
	TestSize();
	system("pause");
	return 0;
}

时间复杂度：

姜狗狗的小柚子
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
单向链表基本操作的递归实现
08-10
在本文中，我们将探讨如何使用递归实现单向链表的一些基本操作。 1. **统计节点个数**：`count_listnode`函数通过递归遍历链表，计算节点总数。在递归调用中，它首先检查当前节点是否非空，然后递增计数器`count`，...
带头结点的单向链表的基本操作的实验代码和实验报告
04-14
使用给定数据结构，实现带头结点的单向链表的创建、删除链表、插入结点等操作，每个学生的学号互不相同，学号不同而姓名相同则为不同的学生，每个学生的学号在合并后的链表中不重复，如果出现重复，则删除年龄较小...
链表基本操作
空山新雨后
12-25 217
链表就是C中利用结构体，将数据和下一个结构体的地址封装在一个结构体中形成一个节点，这些节点组合起来就是一个基础的链表，根据需要可以扩展其中的内容来实现不同的需求。 　　实现一个链表需要定义节点，创建，初始化，插入，删除这些基本操作。 　　#include "stdafx.h" #include "stdlib.h" #include "malloc.h"#define OK 0 #define
数据结构入门学习系列-5（链表的基本操作算法）
yingmuliuchuan的博客
10-23 592
链表的基本操作算法：     链表的创建，分为两种，一种是队尾插入，一种是队头插入：     typedef struct LNode { ElemType data; struct LNode *next; } LNode; //创建链表(头插入法) LNode *create_LinkList_Head() { int data; LNode *head,
【C语言】数据结构实验报告--单链表
qq_62775411的博客
10-18 3853
【C语言】数据结构实验报告--单链表
已从数据文件records.txt中读取学生信息，建立了带头结点的学生链表。编写int count(LinkNode* head,int sex)......
热门推荐
建桥之魂的博客
08-02 2万+
已从数据文件records.txt中读取学生信息，建立了带头结点的学生链表。 （1）编写一个函数 int count(LinkNode* head,int sex); 功能是统计学生链表中性别为sex参数（0为男生，1为女生）的人数并返回该值。 （2）编写一个函数 double getMax(LinkNode* head); 功能是统计学生链表中最高的身高并返回该值。 （3）编写一个函数 void deleX(LinkNode* head, int sex); 功能是删除学生链表中性别为sex参数（0为男生
链表的头插，尾插，固定位置插（C语言）Version1
qq_44327755的博客
06-16 174
#小菜鸡的数据结构学习之路 #仿照《大话数据结构》 #仅供学习 #IDE是visio C++6.0 #此篇是带有头结点 #include <stdio.h> #include <string> #include <windows.h> #include <time.h> #include <graphics.h> typedef struct Node { int data; struct Node *next; }node; typedef
单向链表基本操作python实现
xiamoyanyulrq的博客
08-11 1万+
一：基本介绍 单向链表也叫单链表，是链表中最简单的一种形式，它的每个节点包含两个域，一个信息域（元素域）和一个链接域。这个链接指向链表中的下一个节点，而最后一个节点的链接域则指向一个空值。 - 表元素域elem用来存放具体的数据。 - 链接域next用来存放下一个节点的位置（python中的标识） - 变量p指向链表的头节点（首节点）的位置，从p出发能找到表中的任意节点。 二：...
单向链表基本操作的 Python 实现
蕾欧娜与26的博客
06-07 257
单向链表的基本操作的实现 在之前的博客中介绍了三种链表，分别是单链表、单向循环链表以及双向链表。本篇博客将用Python来实现单链表的如下操作。（用到的工具是Python 3) is_empty() : 判断链表是否为空 length() : 返回链表的长度 travel() : 遍历 add(item) : 在头部添加一个节点 append(item) : 在尾部添加一个节点 insert(pos, item) : 在指定位置 pos 添加一个节点 remove(item) : 删除一个节点 searc
单向链表基本操作（C语言实现）
l-jobs的专栏
09-28 1735
最近学数据结构的链表，就把单向链表的基本操作列了出来，包括链表的建立，链表的插入和删除，链表的查询和遍历，链表的销毁，链表的排序与逆序，链表的合成。 1.链表的建立 一般有两种方式建立链表，头插法和尾插法。 使用头插法建立的链表步骤少，但输出顺序和输入的相反，而尾插法建立链表多了一个不存在数据域的头节点和尾节点，但是输出是正序的，而且头节点便于我们的其余操作，所以我们一般用尾插法建链表。
python单向链表的基本操作细节（小白入门）
12-21
【Python 单向链表的基本操作细节】 链表是一种数据结构，它不同于数组，它将数据元素分散在内存的不同位置，而不是连续存储。单向链表是链表的一种形式，其中每个节点包含一个数据元素和一个指向下一个节点的引用...
单向链表的操作____
05-17
单向链表是一种基本的数据结构，它在计算机科学和编程中有着广泛的应用。...这些基本操作是理解和实现更复杂数据结构和算法的基础。在实际应用中，可能需要根据具体需求进行适当的优化和错误处理。
C语言单向链表的基本操作12个
03-06
本篇将详细介绍C语言中单向链表的12个基本操作，这些操作对于理解和应用链表至关重要。 1. **创建链表**: 创建链表首先需要定义一个节点结构体，通常包含数据域和指向下一个节点的指针。然后，我们需要一个头指针来...
经济开发区智慧园区建设方案汇报.pptx
08-13
经济开发区智慧园区建设方案汇报.pptx
STM32资料，用来备份专用
08-13
这个不需要下载，个人使用的。。
Git 基础教程.pdf
最新发布
08-13
Git 基础教程.pdf
信息化发展规划之IT治理优化.pptx
08-13
信息化发展规划之IT治理优化.pptx
财务收入支出记账表.xlsx
08-13
工资表，财务报表，对账表，付款申请，财务报告，费用支出表，财务收支 适用人群：学习不同技术领域的小白或进阶学习者；可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
单向循环链表基本操作
10-15
单向循环链表是一种链表结构，它的最后一个节点指向第一个节点，形成一个环。基本操作包括插入、删除、查找等。 插入操作： 1. 在链表头插入节点：新节点的 next 指向原头节点，尾节点的 next 指向新节点。 2. 在链表尾插入节点：新节点的 next 指向头节点，原尾节点的 next 指向新节点。 3. 在链表中间插入节点：找到要插入位置的前一个节点，新节点的 next 指向前一个节点的 next，前一个节点的 next 指向新节点。 删除操作： 1. 删除链表头节点：头节点的 next 指向下一个节点，尾节点的 next 指向新头节点。 2. 删除链表尾节点：找到尾节点的前一个节点，前一个节点的 next 指向头节点，尾节点被删除。 3. 删除链表中间节点：找到要删除位置的前一个节点，前一个节点的 next 指向要删除节点的下一个节点。 查找操作： 从头节点开始遍历链表，直到找到目标节点或者遍历完整个链表。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值