链表的基本操作（C实现）

最新推荐文章于 2022-06-15 13:31:06 发布
最新推荐文章于 2022-06-15 13:31:06 发布
阅读量1.1k 收藏 15
点赞数 3
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43690795/article/details/107263061
版权

链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。
在这里插入图片描述
实际中链表的结构非常多样，以下情况组合起来就有8种链表结构：

  1. 单向、双向
  2. 带头、不带头
  3. 循环、非循环

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

虽然有这么多的链表的结构，但是我们实际中最常用还是两种结构：
在这里插入图片描述

  1. 无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶。
  2. 带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了。

无头单向非循环链表

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

typedef int DataType;

typedef struct Node
{
	struct Node* _next;
	DataType _data;
}Node;

//实现不带头单向非循环链表
typedef struct LinkList
{
	Node* _head;
}LinkList;

//初始化
void Init(LinkList* lk)
{
	lk->_head = NULL;
}

//创建节点
Node* CreatNode(DataType val)
{
	Node* node = (Node*)malloc(sizeof(Node));
	node->_next = NULL;
	node->_data = val;
	return node;
}

//尾插
void PushBack(LinkList* lk, DataType val)
{
	Node* node = CreatNode(val);
	if (lk->_head == NULL)
	{
		lk->_head = node;
	}
	else
	{
		Node* cur = lk->_head;
		while (cur->_next)
		{
			cur = cur->_next;
		}
		cur->_next = node;
	}
}

//尾删
void PopBack(LinkList* lk)
{
	assert(lk->_head != NULL);
	Node* prev = NULL;
	Node* cur = lk->_head;
	while (cur->_next)
	{
		prev = cur;
		cur = cur->_next;
	}

	if (cur == lk->_head)
	{
		lk->_head = NULL;
	}
	else
	{
		prev->_next = NULL;
	}
	free(cur);
}

//头插
void PushFront(LinkList* lk, DataType val)
{
	Node* node = CreatNode(val);
	if (lk->_head == NULL)
	{
		lk->_head = node;
	}
	else
	{
		node->_next = lk->_head;
		lk->_head = node;
	}
}

//头删
void PopFront(LinkList* lk)
{
	assert(lk->_head != NULL);
	Node* next = lk->_head->_next;
	free(lk->_head);
	lk->_head = next;
}

//在pos位置后插入元素
void InsertAfter(Node* pos, DataType val)
{
	if (pos == NULL)
	{
		return;
	}
	Node* node = CreatNode(val);
	node->_next = pos->_next;
	pos->_next = node;
}

//删除pos位置后的元素
void EraseAfter(Node* pos)
{
	if (pos == NULL)
	{
		return;
	}

	Node* next = pos->_next;
	if (next)
	{
		pos->_next = next->_next;
		free(next);
	}
}

//查找
Node* Find(LinkList* lk, DataType val)
{
	Node* cur = lk->_head;
	while (cur)
	{
		if (cur->_data == val)
		{
			return cur;
		}
		cur = cur->_next;
	}
	return NULL;
}

//销毁
void Destroy(LinkList* lk)
{
	if (lk->_head)
	{
		Node* cur = lk->_head;
		while (cur)
		{
			Node* next = cur->_next;
			free(cur);
			cur = next;
		}
	}
}

//打印链表
void Print(LinkList* lk)
{
	Node* cur = lk->_head;
	while (cur)
	{
		printf("%d ", cur->_data);
		cur = cur->_next;
	}
	printf("\n");
}

//查找链表中倒数第二个节点
Node* FindLastPrev(LinkList* lk)
{
	if (lk->_head == NULL || lk->_head->_next == NULL)
	{
		return NULL;
	}

	Node* cur = lk->_head;
	while (cur->_next->_next)
	{
		cur = cur->_next;
	}
	return cur;
}

//删除链表中第一个遇到的data所在的节点
void Remove(LinkList* lk, DataType val)
{
	if (lk->_head == NULL)
	{
		return;
	}

	Node* cur = lk->_head;
	if (lk->_head->_data == val)
	{
		lk->_head = cur->_next;
		free(cur);
		return;
	}

	while (cur->_next)
	{
		if (cur->_next->_data == val)
		{
			Node* next = cur->_next;
			cur->_next = next->_next;
			free(next);
			return;
		}
		cur = cur->_next;
	}
}

测试用例

void Test()
{
	LinkList ll;
	Init(&ll);
	PushBack(&ll, 1);
	PushFront(&ll, 2);
	PushFront(&ll, 3);
	PushFront(&ll, 4);
	PushFront(&ll, 5);
	PushFront(&ll, 6);
	PushBack(&ll, 2);
	PushBack(&ll, 3);
	PushBack(&ll, 4);
	PushBack(&ll, 5);
	PushBack(&ll, 6);
	PushBack(&ll, 7);
	//654321234567
	Print(&ll);

	PopFront(&ll);
	Print(&ll);
	PopFront(&ll);
	Print(&ll);
	PopFront(&ll);
	Print(&ll);
	PopFront(&ll);
	Print(&ll);
	PopFront(&ll);
	Print(&ll);
	PopFront(&ll);
	Print(&ll);
	PopFront(&ll);
	Print(&ll);

	PushBack(&ll, 1);
	PushFront(&ll, 2);
	PushFront(&ll, 3);
	PushFront(&ll, 4);
	PushFront(&ll, 5);
	PushFront(&ll, 6);
	PushBack(&ll, 2);
	PushBack(&ll, 3);
	PushBack(&ll, 4);
	PushBack(&ll, 5);
	PushBack(&ll, 6);
	PushBack(&ll, 7);
	//65432345671234567
	Print(&ll);
}

void Test2()
{
	LinkList ll;
	Init(&ll);
	PushBack(&ll, 1);
	PushBack(&ll, 2);
	PushBack(&ll, 3);
	PushBack(&ll, 4);
	PushBack(&ll, 5);
	PushBack(&ll, 6);
	PushBack(&ll, 7);
	//1234567
	Print(&ll);

	PopBack(&ll);
	Print(&ll);
	PopBack(&ll);
	Print(&ll);
	PopBack(&ll);
	Print(&ll);
	PopBack(&ll);
	Print(&ll);
	PopBack(&ll);
	Print(&ll);
	PopBack(&ll);
	Print(&ll);
	PopBack(&ll);
	Print(&ll);
}

void Test3()
{
	LinkList ll;
	Init(&ll);
	PushBack(&ll, 1);
	PushBack(&ll, 2);
	PushBack(&ll, 3);
	PushBack(&ll, 4);
	PushBack(&ll, 5);
	PushBack(&ll, 6);
	PushBack(&ll, 7);
	//1234567
	Print(&ll);
}

void Test4()
{
	LinkList ll;
	Init(&ll);
	PushBack(&ll, 1);
	PushBack(&ll, 2);
	PushBack(&ll, 3);
	PushBack(&ll, 4);
	PushBack(&ll, 5);
	PushBack(&ll, 6);
	PushBack(&ll, 7);
	//1234567
	Print(&ll);

	Node* pos = Find(&ll, 5);
	InsertAfter(pos, 100);
	Print(&ll);
}

void Test5()
{
	LinkList ll;
	Init(&ll);
	PushBack(&ll, 1);
	PushBack(&ll, 2);
	PushBack(&ll, 3);
	PushBack(&ll, 4);
	PushBack(&ll, 5);
	PushBack(&ll, 6);
	PushBack(&ll, 7);
	//1234567
	Print(&ll);

	Node* pos = FindLastPrev(&ll);
	InsertAfter(pos, 600);
	Print(&ll);

	PushBack(&ll, 6);
	Print(&ll);
	Remove(&ll, 6);
	Print(&ll);
}

带头双向循环链表

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

typedef int DataType;

typedef struct Node
{
	struct Node* _next;
	struct Node* _prev;
	DataType _data;
}Node;

//带头双向循环链表
typedef struct DoubleLoopList
{
	Node* _head;
}DoubleLoopList;

//创建节点
Node* CreatNode(DataType val)
{
	Node* node = (Node*)malloc(sizeof(Node));
	node->_next = NULL;
	node->_prev = NULL;
	node->_data = val;
	return node;
}

//初始化
void Init(DoubleLoopList* ls)
{
	ls->_head = CreatNode(0);
	ls->_head->_next = ls->_head;
	ls->_head->_prev = ls->_head;
}

//尾插
void PushBack(DoubleLoopList* ls, DataType val)
{
	Node* node = CreatNode(val);
	Node* last = ls->_head->_prev;

	last->_next = node;
	node->_prev = last;

	node->_next = ls->_head;
	ls->_head->_prev = node;
}

//尾删
void PopBack(DoubleLoopList* ls)
{
	if (ls->_head->_next == ls->_head)
	{
		return;
	}

	Node* last = ls->_head->_prev;
	Node* prev = last->_prev;
	prev->_next = ls->_head;
	ls->_head->_prev = prev;
	free(last);
}

//头插
void PushFront(DoubleLoopList* ls, DataType val)
{
	Node* node = CreatNode(val);
	Node* next = ls->_head->_next;

	ls->_head->_next = node;
	node->_prev = ls->_head;

	node->_next = next;
	next->_prev = node;
}

//头删
void PopFront(DoubleLoopList* ls)
{
	if (ls->_head->_next == ls->_head)
	{
		return;
	}

	Node* cur = ls->_head->_next;
	Node* next = cur->_next;
	ls->_head->_next = next;
	next->_prev = ls->_head;
	free(cur);
}

//在pos位置前插入元素
void Insert(Node* pos, DataType val)
{
	Node* node = CreatNode(val);
	Node* prev = pos->_prev;

	node->_next = pos;
	pos->_prev = node;
	prev->_next = node;
	node->_prev = prev;
}

//删除pos所在位置的元素
void Erase(Node* pos)
{
	if (pos == NULL)
	{
		return;
	}

	Node* prev = pos->_prev;
	Node* next = pos->_next;
	free(pos);

	prev->_next = next;
	next->_prev = prev;
}

//查找
Node* Find(DoubleLoopList* ls, DataType val)
{
	if (ls->_head->_next == ls->_head)
	{
		return NULL;
	}

	Node* cur = ls->_head->_next;
	while (cur != ls->_head)
	{
		if (cur->_data == val)
		{
			return cur;
		}
		cur = cur->_next;
	}
	return NULL;
}

//销毁
void Destroy(DoubleLoopList* ls)
{
	Node* cur = ls->_head->_next;
	while (cur != ls->_head)
	{
		Node* next = cur->_next;
		free(cur);
		cur = next;
	}
	free(ls->_head);
	ls->_head = NULL;
}

//打印链表
void Print(DoubleLoopList* ls)
{
	Node* cur = ls->_head->_next;
	while (cur != ls->_head)
	{
		printf("%d ", cur->_data);
		cur = cur->_next;
	}
	printf("\n");
}

测试用例

void Test()
{
	DoubleLoopList ls;
	Init(&ls);
	Print(&ls);

	PushBack(&ls, 1);
	Print(&ls);
	PushBack(&ls, 2);
	Print(&ls);
	PushBack(&ls, 3);
	Print(&ls);
	PushBack(&ls, 4);
	Print(&ls);

	PopBack(&ls);
	Print(&ls);
	PopBack(&ls);
	Print(&ls);
	PopBack(&ls);
	Print(&ls);
	PopBack(&ls);
	Print(&ls);
	PopBack(&ls);
	Print(&ls);

	Destroy(&ls);
}


void Test2()
{
	DoubleLoopList ls;
	Init(&ls);
	PushFront(&ls, 1);
	Print(&ls);
	PushFront(&ls, 2);
	Print(&ls);
	PushFront(&ls, 3);
	Print(&ls);
	PushFront(&ls, 4);
	Print(&ls);

	PopFront(&ls);
	Print(&ls);
	PopFront(&ls);
	Print(&ls);
	PopFront(&ls);
	Print(&ls);
	PopFront(&ls);
	Print(&ls);
	PopFront(&ls);
	Print(&ls);

	Destroy(&ls);
}

void Test3()
{
	DoubleLoopList ls;
	Init(&ls);
	PushBack(&ls, 1);
	PushBack(&ls, 2);
	PushBack(&ls, 3);
	PushBack(&ls, 4);
	Print(&ls);

	Node* pos = Find(&ls, 3);
	Insert(pos, 20);
	Print(&ls);

	Erase(pos);
	Print(&ls);
	Destroy(&ls);
}
一杆梅子酒丶
关注
  • 3
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
实验二 链表基本操作的实现
12-18
【实验课程名称】算法与数据结构 【实验项目名称】链表基本操作的实现
用C++实现链表操作
qq_60012598的博客
02-21 700
用C++实现链表及其相应操作
＜C语言数据结构三＞C语言带你玩转“单向链表”
weixin_43504224的博客
06-15 1207
链表是C语言中比较常用的一种数据结构，相对与上几篇文章的队列结构来说，链表是在一种物理存储单元上非连续、非顺序的存储结构。链表中的每个节点都是通过链表中的指针链接次序实现的；一般来说每个节点都会包含以下两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 链表又会分成很多个类型：单线链表，单向循环链表，双向链表，双向循环链表等； 这篇文章我们主要聊聊单向链表，单向链表又分为以下两种类型：链表的数据定义 链表的创建 链表的插入：头插和尾插 链表的删除：根据数据内容或者节点序号 链表的销毁
链表基本操作的程序实现(转2)
鬼魅叔叔的小窝
10-08 545
#include #include int n=0; typedef struct Node{       struct Node *next;       int info; }Node; Node *create_node()//尾插法 {   Node *head;   Node *pre;   Node *p;   int x;   head=(Node *)malloc(sizeof
【数据结构】链表基本操作的实现详解
qq_46994783的博客
09-13 1059
链表 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。 链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而线性表和顺序表相应的时间复杂度分别是O(logn)和
C语言实现链表基本操作
10-09
在这个主题中，我们将深入探讨如何用C语言实现链表的基本操作，包括创建链表、插入元素、删除元素以及遍历链表。 首先，链表不同于数组，数组中的元素在内存中是连续存储的，而链表中的节点通过指针链接，可以分散...
C语言实现的链表基本操作
10-09
本文将深入探讨如何使用C语言来实现链表的基本操作，包括创建、插入、删除和遍历。 一、链表的节点结构 在C语言中，链表由一系列节点组成，每个节点包含两部分：数据域（存储元素）和指针域（指向下一个节点）。一...
c语言链表的基本操作实现
最新发布
03-28
C语言链表的基本操作主要包括**初始化、创建节点、插入节点、删除节点和查找节点**。具体如下： 1. **初始化**：创建一个空的链表，通常指创建一个头指针，该指针指向NULL，表示链表的开始。 2. **创建节点**：在...
单向链表基本操作的递归实现
08-10
在本文中，我们将探讨如何使用递归实现单向链表的一些基本操作。 1. **统计节点个数**：`count_listnode`函数通过递归遍历链表，计算节点总数。在递归调用中，它首先检查当前节点是否非空，然后递增计数器`count`，...
单链表的基本操作
Change_Improve的博客
09-26 862
一、实验目的： 1、复习C语言程序设计中的知识。 2、掌握线性表的链式存储结构的表示和实现方法。 3、掌握单链表基本操作的算法实现。   二、实验内容： 1．建立单链表。 2．在单链表上实现插入、删除和查找等操作。   三、实验要求：    编写实现单链表的基本算法（初始化、查找、插入、删除等）的函数，并在此基础上设计一个主程序完成如下功能：    ⑴初始化整型单链表H; ...
数据结构单链表的基本操作及实现(C/C++)
06-03
数据结构单链表的基本操作及实现(C/C++)，包括初始化、创建链表、插入元素、删除元素、获取指定位置的元素等
链表基本操作的c语言编程实现,链表及其基本操作的实现（C语言）
weixin_29170327的博客
05-18 813
基于严蔚敏版的《数据结构(C语言版)》实现单链表及其基本操作。1、头文件和结构体：#include #include#includetypedefintElemType;typedefstructLNode{ElemType data;struct LNode *next;}LNode,*LinkList;2、函数声明：int createList(LinkList *L, intn);int g...
【数据结构】链表的基本操作
m0_53171456的博客
03-11 8297
规划 /* 链表的基本操作 */ #include<iostream> #include<algorithm> #define ElemType int using namespace std; typedef struct LNode{ ElemType data; //数据域 LNode *next; //指针域 } *LinkList; //链表的初始化 void IniteList(LinkList &L){ L = new LNode; //创建头结点
链表--基本实现
iEucliwood的博客
12-20 288
数组表的局限 数组实现的表虽然能动态指定，但仍需要对表大小的最大值进行估计，通常需要估计得大一些，而这会浪费大量空间。而且插入和删除得花费是昂贵的，因为需要将部分元素或全部元素都前移或者后移。如果通过N次插入来建立一个表将需要二次时间。 链表 为了避免了插入和删除的线性开销和空间的浪费,我们允许表可以不连续存储，否则表的部分或全部需要整体移动。 链表由一系列不必在内存中相连的结构组成。每个结构均含有表元素和指向该元素后继...
C++ 单链表基本操作分析与实现
tomcat_kk的博客
12-05 4128
链表 　　链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，链表比较方便插入和删除操作。   创建头节点 　　手动new一个新的Node，
数据结构:链表的基本操作实现
m0_58311374的博客
04-25 1596
本文实现的是带头结点的链表 一、链表的定义 typedef struct node { ElemType data; struct node* next; }LNode, *LinkList; 二、基本操作实现 //创建空链表 LinkList Creat_LinkList() { LinkList L = (LinkList)malloc(sizeof(LNode)); if (L) { printf("创建成功\n"); L->next = NULL; } else
链表的基本操作
小橘是橘子的博客
04-30 4711
单链表的简单介绍: 链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始； 链表是使用指针进行构造的列表；又称为结点列表，因为链表是由一个个结点组装起来的； 其中每个结点都有指针成员变量指向列表中的下一个结点； 链表是由结点构成，head指针指向第一个成为表头的结点，而终止于最后一个指向NULL的指针。一般使用时都要定义一个头结点，头结点不存放数据，只是为了方便查找。 一般的单链表的操作(增，删，改，查)如下代码： package com.mrz.test; public class Si
单链表常见操作图文详解
热门推荐
程序猿老樊的博客
04-15 2万+
     单链表的最大特点是可以将物理地址上不连续的数据连接起来，通过指针来对物理地址进行操作，实现增删改查等功能。     单链表分为两种：有头链表和无头链表。     无头单链表，也就是phead一只是一个指针，指向链表的第一个节点。     带头节点的单链表：只不过头结点的data不保存信息。//构建一个节点typedef struct Node { DataType data; ...
链表的基本操作--c语言
qq_51533157的博客
06-25 5947
链表是数据结构中一种最基本的数据结构，它是用链式存储结构实现的线性表。它较顺序表而言在插入和删除时不必移动其后的元素。现在给你一些整数，然后会频繁地插入和删除其中的某些元素，会在其中某些时候让你查找某个元素或者输出当前链表中所有的元素。 下面给你基本的算法描述： 图1：链表类型的定义以及获得链表元素的算法描述 图2：链表的插入算法描述 图3：链表的删除算法描述 图4：链表的创建算法描述 输入 输入数据只有一组，第一行有n+1个整数，第一个整数是这行余下的整数数目n，后面是n个整
C语言实现链表：数据结构与基本操作
当需要在链表中插入、删除或遍历节点时，可以使用这些基本操作作为基础。链表的其他操作，如查找、排序和合并，都是基于这些核心概念的扩展。理解链表的工作原理和如何在C语言中实现它们是编程中非常重要的技能。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值