数据结构 关于单链表的基本操作

最新推荐文章于 2023-05-23 12:05:38 发布
最新推荐文章于 2023-05-23 12:05:38 发布
阅读量222 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ihaha233/article/details/79818713
版权

以下是有关单链表增删查改的一些代码：

linklist.h

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

#define TITLE printf("\n======================%s====================\n",__FUNCTION__);

typedef char LinkType;

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

LinkNode* CreateNode(LinkType value);  //创建结点
void DestroyNode(LinkNode* node); // 销毁结点 

void LinkListInit(pLinkNode* head);  //初始化 
void LinkListPrint(LinkNode* head,const char* msg );//打印
void 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);// 查找元素在链表中的位置,return 这个值对应的节点的地址
void LinkListInsert(LinkNode** head, LinkNode* pos, LinkType value); //指定位置前插入
void LinkListInsertAfter(LinkNode** head, LinkNode* pos, LinkType value);//指定位置后插入
void LinkListErase(LinkNode** head, LinkNode* pos);//删除指定位置元素
void LinkListRemove(LinkNode** head, LinkType to_delete);//删除指定元素
void LinkListRemoveAll(LinkNode** head, LinkType value); //删除指定值的所有元素
int LinkListEmpty(LinkNode* head); //判断链表是否为空，为空返回0，否则返回1
size_t LinkListSize(LinkNode* head);//求链表元素个数
void LinkListReversePrint(LinkNode* head);//逆序打印链表
void LinkListInsertBefore(LinkNode** head, LinkNode* pos, LinkType value);//不遍历链表在pos之前插入

linklist.c

#include "link.h"
#include <stdlib.h>

void LinkListInit(LinkNode** head)
{
	if(head == NULL)
	{
		return;
	}
	*head = NULL;
}


void LinkListPrint(LinkNode* head,const char* msg)
{
	printf("[%s]： ",msg);
	LinkNode* cur = head;
	for(;cur != NULL;cur=cur->next)
	{
		printf("[%c]-> ",cur->data);
	}
	printf("[NULL]");
	printf("\n");
}

LinkNode* CreateNode(LinkType value)
{
	LinkNode* new_node = (LinkNode*)malloc(sizeof(LinkNode));
	new_node->data = value;
	new_node->next = NULL;
	return new_node;
}

void DestroyNode(LinkNode* node)
{
	free(node);
}

void LinkListPushBack(LinkNode** head,LinkType value)
{
	if(head == NULL)
	{
		//非法参数
		return;
	}
	if(*head == NULL)
	{
		//当前是一个空链表，直接将元素插入到头结点
		*head = CreateNode(value);
		return;
	}
	LinkNode* cur = *head;
	while(cur->next!=NULL)
	{
		cur = cur->next;
	}
	LinkNode* new_node = CreateNode(value);
	cur->next = new_node;
	return;
}


void LinkListPopBack(LinkNode** head)
{
	if(head == NULL)
	{
		//非法输入
		return;
	}
	if(*head == NULL)
	{
		//空链表
		return;
	}
	LinkNode* cur = *head;
	if(cur->next == NULL)
	{
		DestroyNode(cur);
	}
	while(cur->next != NULL)
	{
		if(cur->next->next == NULL)
		{
			//找到倒数第二个结点
			LinkNode* to_erase = cur->next;
			cur->next = NULL;
			DestroyNode(to_erase);
		}
		else
		{
		cur = cur->next;
		}
	}
	return;
}

void LinkListPushFront(LinkNode** head, LinkType value)
{
	if(head == NULL)
	{
		return;
	}

	if(*head == NULL)
	{
		*head = CreateNode(value);
		return;
	}
	LinkNode* new_node = CreateNode(value);
	new_node->next = *head;
	*head = new_node;
	return;
}


void LinkListPopFront(LinkNode** head)
{
	if(head == NULL)
	{
		//非法输入
		return;
	}
	if(*head == NULL)
	{
		//空链表，不做任何事情直接返回
		return;
	}
	LinkNode* to_erase = *head;
	*head = (*head)->next;
	DestroyNode(to_erase);
}

LinkNode* LinkListFind(LinkNode* head, LinkType to_find)
{
	if(head == NULL)
	{
		//空链表
		return NULL;
	}
	LinkNode* cur = head;
	while(cur != NULL)
	{
		if(cur->data == to_find)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

void LinkListInsert(LinkNode** head, LinkNode* pos, LinkType value)
{
	if(head == NULL)
	{
		//非法输入
		return;
	}
	if(*head == NULL)
	{
		*head = CreateNode(value);
		return;
	}
	if(*head == pos)
	{
		LinkListPushFront(head,value);
		return;
	}
	if(pos == NULL)
	{
		LinkListPushBack(head,value);
		return;
	}
	LinkNode* cur = *head;
	while(cur->next != NULL)
	{
		if(cur->next == pos)
		{
			LinkNode* new_node = CreateNode(value);
			cur->next = new_node;
			new_node->next = pos;
			return;
		}
		else
		{
			cur = cur->next;
		}
	}
	return;
}

void LinkListInsertAfter(LinkNode** head, LinkNode* pos, LinkType value)
{
	if(head == NULL)
	{
		//非法输入
		return;
	}
	if(*head == NULL)
	{
		LinkListPushBack(head,value);
		return;
	}
	if(pos->next == NULL)
	{
		LinkListPushBack(head,value);
		return;
	}
	if(pos == NULL)
	{
		return;
	}
	LinkNode* next = pos->next;
	LinkNode* new_node = CreateNode(value);
	pos->next = new_node;
	new_node->next = next;
	return;
}


void LinkListErase(LinkNode** head, LinkNode* pos)
{
	if(head == NULL)
	{
		//非法输入
		return;
	}
	if(*head == NULL)
	{
		//空链表
		return;
	}
	if(pos == NULL)
	{
		return;
	}
	LinkNode* cur = *head;
	while(cur != NULL)
	{
		if(cur->next == pos)
		{
			LinkNode* next = pos->next;
			cur->next = next;
			DestroyNode(pos);
			return;
		}
		else
		{
			cur = cur->next;
		}
	}
	return;
}
void LinkListRemove(LinkNode** head, LinkType to_delete)
{
	if(head == NULL)
	{
		//非法输入
		return;
	}
	if(*head == NULL)
	{
		//空链表
		return;
	}
	if((*head)->data == to_delete)
	{
		LinkNode* Delete = *head;
		*head = (*head)->next;
		DestroyNode(Delete);
		return;
	}
	LinkNode* cur = *head;
	while(cur != NULL)
	{
		if(cur->next->data == to_delete)
		{
			LinkNode* Delete = cur->next;
			LinkNode* next = cur->next->next;
			cur->next = next;
			DestroyNode(Delete);
			return;
		}
		else
		{
			cur = cur->next;
		}
	}
	return;
}

void LinkListRemoveAll(LinkNode** head, LinkType value)
{
	if(head == NULL)
	{
		//非法输入
		return;
	}
	if(*head == NULL)
	{
		//空链表
		return;
	}
	LinkNode *cur = *head;  
	while((*head)->data == value)
	{
	  	if(cur->data == value)
	  	{
	  		LinkNode* Delete = cur;
	  		*head = (*head)->next;
	  		cur = cur->next;
	  		DestroyNode(Delete);
		}
	}
	while(cur->next != NULL)
	{
		if(cur->data == value)
		{
			LinkListErase(head,cur);
		}
		cur = cur->next;
	}
	if(cur->data == value)
	{
		LinkListPopBack(head);
	}
}


int LinkListEmpty(LinkNode* head)
{
	if(head == NULL)
	{
		//空链表
		return 0;
	}
	else
	return 1;
}

size_t LinkListSize(LinkNode* head)
{
	if(head == NULL)
	{
		return 0;
	}
	size_t size = 0;
	LinkNode* cur = head;
	while(cur != NULL)
	{
		size++;
		cur = cur->next;
	}
	return size;
}

void LinkListReversePrint(LinkNode* head)
{
	if(head == NULL)
	{
	//	printf("[NULL]\n");
		return;
	}
	LinkListReversePrint(head->next);
	printf("[%c]  ",head->data);
}


void LinkListInsertBefore(LinkNode** head, LinkNode* pos, LinkType value)
{
	if(head == NULL)
	{
		//非法输入
		return;
	}
	if(*head == NULL)
	{
		*head = CreateNode(value);
		return;
	}
	if(pos == NULL)
	{
		return;
	}
	if(pos == *head)
	{
		LinkListPushFront(head,value);
		return;
	}
	LinkNode* new_node = CreateNode(pos->data);
	LinkNode* next = pos->next;
	pos->next = new_node;
	new_node->next = next;
	pos->data = value;
	return;
}

///
//	           以下为测试代码              //
//

void TestInit()
{
	TITLE;
	LinkNode* head;
	LinkListInit(&head);
	//printf("head=%p\n",head);
}

void TestLinkListPushBack()
{
	TITLE;
	LinkNode* head;
	LinkListInit(&head);
	LinkListPushBack(&head,'a');
	LinkListPushBack(&head,'b');
	LinkListPushBack(&head,'c');
	LinkListPushBack(&head,'d');
	LinkListPrint(head,"尾插4个元素");
}

void TestLinkListPopBack()
{	
	TITLE;
	LinkNode* head;
	LinkListInit(&head);
	LinkListPushBack(&head,'a');
	LinkListPushBack(&head,'b');
	LinkListPushBack(&head,'c');
	LinkListPushBack(&head,'d');
	LinkListPopBack(&head);
	LinkListPopBack(&head);
	LinkListPrint(head,"尾删2个元素");
}

void TestLinkListPushFront()
{
	TITLE;
	LinkNode* head;
	LinkListInit(&head);
	LinkListPushFront(&head,'a');
	LinkListPushFront(&head,'b');
	LinkListPushFront(&head,'c');
	LinkListPushFront(&head,'d');
	LinkListPrint(head,"头插4个元素");
}

void TestLinkListPopFront()
{
	
	TITLE;
	LinkNode* head;
	LinkListInit(&head);
	LinkListPushFront(&head,'a');
	LinkListPushFront(&head,'b');
	LinkListPushFront(&head,'c');
	LinkListPushFront(&head,'d');
	LinkListPopFront(&head);
	LinkListPopFront(&head);
	LinkListPrint(head,"头删2个元素");
	LinkListPopFront(&head);
	LinkListPopFront(&head);
	LinkListPrint(head,"再头删2个元素");
	LinkListPopFront(&head);
	LinkListPrint(head,"头删空链表");

}

void TestLinkListFind()
{
	
	TITLE;
	LinkNode* head;
	LinkListInit(&head);
	LinkListPushFront(&head,'a');
	LinkListPushFront(&head,'b');
	LinkListPushFront(&head,'c');
	LinkListPushFront(&head,'d');
	LinkListPrint(head,"查找元素");
	LinkNode* pos = LinkListFind(head,'x');
	printf("pos x expect NULL,pos actual %p\n",pos);
	pos = LinkListFind(head,'c');
	printf("pos actual %p\n",pos);
	
}

void TestLinkListInsert()
{
	
	TITLE;
	LinkNode* head;
	LinkListInit(&head);
	LinkListInsert(&head,head,'b');
	LinkListPrint(head,"对空链表进行插入");
	LinkListInsert(&head,head,'a');
	LinkListPrint(head,"对链表头部进行插入");
	LinkListPushBack(&head,'c');
	LinkListPushBack(&head,'d');
	LinkNode* pos_d = LinkListFind(head,'d');
	LinkListPrint(head,"尾插2个元素");
	LinkListInsert(&head,pos_d,'x');
	LinkListPrint(head,"d之前插入x");
	LinkListInsert(&head,NULL,'e');
	LinkListPrint(head,"NULL之前插入e");
}

void TestLinkListInsertAfter()
{
	
	TITLE;
	LinkNode* head;
	LinkListInit(&head);
	LinkListInsertAfter(&head,head,'a');
	LinkListPrint(head,"对空链表进行插入");
	
	LinkListPushBack(&head,'b');
	LinkListPushBack(&head,'c');
	LinkListPushBack(&head,'d');
	LinkListPrint(head,"尾插3个元素");
	//LinkListInsertAfter(&head,NULL,'x');
	//LinkListPrint(head,"pos为NULL时");
	LinkNode* pos_b = LinkListFind(head,'b');	
	LinkListInsertAfter(&head,pos_b,'x');
	LinkListPrint(head,"在b后插入x");
}
void TestLinkListErase()
{
	
	TITLE;
	LinkNode* head;
	LinkListInit(&head);
	LinkListPushBack(&head,'a');
	LinkListPushBack(&head,'b');
	LinkListPushBack(&head,'c');
	LinkListPushBack(&head,'d');
	LinkListPrint(head,"尾插4个元素");
	LinkNode* to_erase = LinkListFind(head,'b');
	LinkListErase(&head,to_erase);
	LinkListPrint(head,"删除元素b");
}

void TestLinkListRemove()
{
	
	TITLE;
	LinkNode* head;
	LinkListInit(&head);
	LinkListPushBack(&head,'a');
	LinkListPushBack(&head,'b');
	LinkListPushBack(&head,'c');
	LinkListPushBack(&head,'d');
	LinkListPrint(head,"尾插4个元素");
	LinkListRemove(&head,'a');
	LinkListPrint(head,"删除首元素a");
	LinkListRemove(&head,'c');
	LinkListPrint(head,"删除元素c");
}


void TestLinkListRemoveAll()
{
	
	TITLE;
	LinkNode* head;
	LinkListInit(&head);
	LinkListPushBack(&head,'b');
	LinkListPushBack(&head,'b');
	LinkListPushBack(&head,'a');
	LinkListPushBack(&head,'b');
	LinkListPushBack(&head,'c');
	LinkListPushBack(&head,'b');
	LinkListPushBack(&head,'d');
	LinkListPushBack(&head,'b');
	LinkListPrint(head,"尾插8个元素");
	LinkListRemoveAll(&head,'b');
	LinkListPrint(head,"删除元素b");
}

void TestListEmpty()
{
	TITLE;
	LinkNode* head;
	LinkListInit(&head);
	int t = LinkListEmpty(head);
	LinkListPrint(head,"判断链表是否为空，为空返回0，否则返回1");
	printf("espect is 0,actul is %d\n",t);
	LinkListPushBack(&head,'a');
	LinkListPushBack(&head,'b');
	LinkListPushBack(&head,'c');
	LinkListPushBack(&head,'d');
	LinkListPrint(head,"判断链表是否为空，为空返回0，否则返回1");
	t = LinkListEmpty(head);
	printf("espect is 1,actul is %d\n",t);
}


void TestLinkListSize()
{	
	TITLE;
	LinkNode* head;
	LinkListInit(&head);
	int t = LinkListSize(head);
	LinkListPrint(head,"打印空链表");
	printf("expect 0,actul %d\n",t);
	LinkListPushBack(&head,'a');
	LinkListPushBack(&head,'b');
	LinkListPushBack(&head,'c');
	LinkListPushBack(&head,'d');
	LinkListPrint(head,"尾插4个元素");
	t = LinkListSize(head);
	printf("expect 4,actul %d\n",t);
}


void TestLinkListReversePrint()
{	
	TITLE;
	LinkNode* head;
	LinkListInit(&head);
	printf("[逆序打印空链表]：");
	LinkListReversePrint(head);
	LinkListPushBack(&head,'a');
	LinkListPushBack(&head,'b');
	LinkListPushBack(&head,'c');
	LinkListPushBack(&head,'d');
	LinkListPrint(head,"尾插4个元素");
	printf("[逆序打印链表]：");
	LinkListReversePrint(head);
	printf("\n");
}


void TestLinkListInsertBefore()
{	
	TITLE;
	LinkNode* head;
	LinkListInit(&head);
	LinkListInsertBefore(&head,NULL,'x');
	LinkListPrint(head,"向空链表中插入x");
	LinkListPushBack(&head,'a');
	LinkListPushBack(&head,'b');
	LinkListPushBack(&head,'c');
	LinkListPushBack(&head,'d');
	LinkListPrint(head,"尾插4个元素");
	LinkNode* pos_c = LinkListFind(head,'c');
	LinkListInsertBefore(&head,pos_c,'h');
	LinkListPrint(head,"在元素c之前插入h");
}

int main()
{
	TestInit();
	TestLinkListPushBack();
	TestLinkListPopBack();
	TestLinkListPushFront();
	TestLinkListPopFront();
	TestLinkListFind();
	TestLinkListInsert();
	TestLinkListInsertAfter();
	TestLinkListErase();
	TestLinkListRemove();
	TestLinkListRemoveAll();
	TestListEmpty(); 
	TestLinkListSize();
	TestLinkListReversePrint();
	TestLinkListInsertBefore();
	return 0;
}

以下为程序运行结果：




雪碧柠七
关注
专栏目录
链表学习（C语言篇）
weixin_45626617的博客
06-01 280
链表 数据结构中链表是基础中的基础，接下来，学习一下链表 一、创建链表 //创建链表 typedef struct LinkNode//用结构体来创建 { int id;//数据域（用来填写数据） LinkNode* next;//指针域（用来存放下一个结点的指针） }link_node; 二、初始化链表 编写函数：link_node* init_linklist() 建立带有头结点的单向链表，循环创建结点，结点数据域中的数值从键盘输入，以 -1 作为输入结束标志，链表的头结点地址由函数值返回. //
数据结构-单链表基本操作-C语言代码
热门推荐
suxiaorui的博客
01-22 6万+
单链表基本操作 1.头插法建立单链表 2.尾插法建立单链表 3.查找结点 3.修改结点 4.插入结点 5.删除结点 本篇只有c语言代码，具体思路讲解请看这篇博客：数据结构-线性结构-单链表 1.头插法建立单链表 #include<stdio.h> #include<stdlib.h> //单链表的结构定义 typedef struct LNode { int data...
C语言链表
z1236464的博客
02-12 387
链表增删改查
c语言链表基础,【c基础练习】c语言实现链表
weixin_29364297的博客
05-21 105
#define _CRT_SECURE_NO_WARNINGS#include#include#includetypedef struct _LINKNODE{int data;struct _LINKNODE* next;}link_node;//创建节点link_node* init_linklist(){//创建头结点指针link_node* head = NULL;//给头结点分配内存he...
2021-09-28静态链表(考察少)
sticker_start_tag的博客
09-28 129
#define MaxSize 10; struct Node{ ElemType data; int next;//下一个元素的数组下标 }; void testLinkList(){ struct Node a[MaxSize];//数组a作为静态链表 }
c语言单链表增删查
iteye_8110的博客
05-26 106
[code="c"] #ifndef _LINKLIST_H_ #define _LINKLIST_H_ #include #include #include #include typedef unsigned char DataType; typedef struct NODE { DataType c; struct NODE* next; } ...
【数据结构】单链表基本操作
℉f的博客
04-23 1828
单链表基本操作
数据结构：单链表的基本操作
weixin_45213079的博客
08-17 1213
数据结构：单链表的基本操作
数据结构-单链表基本操作的实现
最新发布
Xiao_Ya__的博客
05-23 753
数据结构-单链表基本操作的实现
头歌数据结构单链表的基本操作
05-18
头歌数据结构单链表的基本操作 第1关单链表的插入操作 第2关单链表的删除操作 第3关单链表的按照序号查找值操作 第4关单链表的按照值查找结点位序的操作 第5关单链表的逆置操作 第6关两个有序单链表的合并操作 稳过 ...
C语言 数据结构之单链表基本操作
10-05
单链表的各种操作，适合于初学，也适合于复习 单链表操作介绍 1. 创建头节点 2. 创建有数据节点 3. 判断链表是否为空 4. 遍历链表(有头节点链表) 5. 遍历链表(无头节点链表) 6. 头插、头删、尾插、尾删 7. 按照顺序...
数据结构--单链表操作实验报告
04-12
1.从键盘输入顺序任意的5个整数，按有序插入的要求生成第一个有序单链表，将该链表输出显示。 2.再从键盘输入顺序任意的5个整数，按有序插入的要求生成第二个有序单链表，将该链表输出显示。 3.将这两个有序单链表...
数据结构 二叉树的基本操作(求树的结点数，高度，叶子结点...)
雪碧柠七的博客
06-05 3万+
以下代码所测试的树：根据先序遍历结果(带空结点)，构造一棵树将树的先序遍历放入数组，空结点用*代替char arr[] = "abd**eg***c*f**";再然后，与递归前序遍历树的方法一样，只是将打印该结点换成创建结点即可。代码实现：//根据先序遍历结果(带空结点)，构造一棵树 TreeNode* _TreeCreate(TreeDataType arr[],size_t size,int*...
数据结构 单链表相关习题练习
雪碧柠七的博客
05-10 6499
1.逆序打印单链表采用递归的方法即可实现。//逆序打印单链表 void LinkListReversePrint(LinkNode* head) { if(head == NULL) { return; } LinkListReversePrint(head-&gt;next); printf("[%c] ",head-&gt;...
数据结构 共享栈(一个数组实现两个栈)
雪碧柠七的博客
05-31 1904
题目解析：代码：#include&lt;stdio.h&gt; #define Max_size 1000 typedef char DataType; typedef struct shareStack { DataType data[Max_size]; int top1; int top2; }shareStack; //初始化 void shareStackInit(share...
数据结构 顺序表的简单排列
雪碧柠七的博客
03-20 1446
初始化打印顺序表尾插一个元素只删除第一个指定元素删除所有指定元素判断顺序表是否为空  为空返回1 不为空返回0 冒泡排序#pragma once #include &lt;stdio.h&gt; #define SeqListMax 1000 #define TITLE printf("\n==============%s==============\n",__FUNCTION__); typ...
数据结构 完成顺序栈，链式栈的基本操作
雪碧柠七的博客
04-11 1285
顺序栈的初始化 销毁 入栈 出栈 取栈顶元素 seqstack.h #pragma once #include &lt;stdio.h&gt; #define TITLE printf("\n==========================%s=========================\n",__FUNCTION__); typedef char SeqStackType; ty...
数据结构 实现一个栈：取栈中的最小值的时间复杂度为O(1）
雪碧柠七的博客
05-17 673
解题思路：    每次入栈两个元素，一个为将要入栈的value元素，一个位min最小元素。    第一次入栈时，将该元素设为min值，入栈两次该元素。此后，每次入栈value都需和min值比较，若比min值小，则min数据更新为该值。若大于min，则min不变。    此后，先入栈value元素，后入栈min。这样就保证了栈顶元素始终为最小值min。下面上代码：#include"minStack....
数据结构 分别实现顺序队列和链式队列
雪碧柠七的博客
04-15 452
分别实现顺序队列和链式队列实现入队列, 出队列, 和取队首元素顺序队列seqqueue.h #pragma once #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #define TITLE printf("\n====================%s====================",__FUNCTION__); #de...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值