数据结构《二》链表的实现

最新推荐文章于 2022-02-03 21:56:43 发布
最新推荐文章于 2022-02-03 21:56:43 发布
阅读量350 收藏
点赞数
分类专栏： 数据结构 文章标签： c语言 数据结构 链表 单链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-NC-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wgvwbig/article/details/117130018
版权

链表的实现


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

一、单向无头链表的实现

1.功能实现

01 struct SListNode

typedef int SLTDateType;
typedef struct SListNode
{
	SLTDateType data;
	struct SListNode* next;
}SListNode;

02 动态申请新结点

SListNode* BuySListNode(SLTDateType x) 
{
	SListNode *node = (SListNode*)malloc(sizeof(SListNode));
	if (NULL == node)
	{
		printf("BUYSListNode Error！");
		return NULL;
	}
	node->data = x;
	node->next = NULL;
	return node;
}

03 无头单向链表的打印

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

04 无头单向链表的销毁

void SListDestory(SListNode** pplist)
{
	SListNode *node = NULL;
	if (NULL == *pplist)
	{
		return;
	}
	while (NULL!=(*pplist))
	{
		node = *pplist;
		(*pplist) = (*pplist)->next;
		free(node);
	}
}

05 无头单向链表的头插头删

void SListPushFront(SListNode** pplist, SLTDateType x)
{
	assert(pplist != NULL);
	SListNode *node = BuySListNode(x);
	node->next = *pplist;
	*pplist=node;
}

void SListPopFront(SListNode** pplist)
{
	SListNode *current = NULL;
	assert(pplist != NULL);
	if (NULL==*pplist)
	{
		return;
	}
	else
	{
		current = *pplist;
		*pplist = (*pplist)->next;
		free(current);
	}
}

06 无头单向链表的尾插尾删

void SListPushBack(SListNode** pplist, SLTDateType x)
{
	assert(pplist != NULL);
	SListNode *current = *pplist;
	if (*pplist==NULL)
	{
		*pplist = BuySListNode(x);
	}
	else
	{
		while (current->next)
		{
			current = current->next;
		}
		current->next = BuySListNode(x);
	}
}

void SListPopBack(SListNode** pplist)
{
	assert(pplist != NULL);
	SListNode *current = *pplist;
	if (*pplist == NULL)
	{
		return;
	}
	else if (NULL==(*pplist)->next)
	{
		free(*pplist);
		*pplist = NULL;
	}
	else
	{
		while (current->next->next)
		{
			current = current->next;
		}
		free(current->next);
		current->next = NULL;
	}
}

07 无头单向链表的查找

SListNode* SListFind(SListNode* plist, SLTDateType x)
{
	SListNode *current = plist;
	while (current)
	{
		if (x==current->data)
		{
			return current;
		}
		current = current->next;
	}
	return NULL;
}

08 无头单向链表的按位插入

// 单链表在pos位置之后插入x
void SListInsertAfter(SListNode* pos, SLTDateType x)
{

	SListNode *node = NULL;
	if (NULL == pos)
	{
		printf("POS ERROR\n");
		return;
	}
	node = BuySListNode(x);
	node->next = pos->next;
	pos->next = node;
}

09 无头单向链表的按位删除

// 单链表在pos位置之后删除
void SListEraseAfter(SListNode* pos)
{
	SListNode *node = NULL;
	if (NULL == pos)
	{
		printf("POS ERROR\n");
		return;
	}
	node = pos->next;
	pos->next = node->next;
	free(node);
}

2. 测试代码

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include"slist.h"
void test_Back()
{
	SListNode *head = NULL;
	printf("尾插测试\n");
	SListPushBack(&head, 1);
	SListPrint(head);
	SListPushBack(&head, 2);
	SListPrint(head);
	SListPushBack(&head, 3);
	SListPrint(head);
	SListPushBack(&head, 4);
	SListPrint(head);
	SListPushBack(&head, 5);
	SListPrint(head);
	printf("尾删测试\n");
	SListPopBack(&head);
	SListPrint(head);
	SListPopBack(&head);
	SListPrint(head);
	SListPopBack(&head);
	SListPrint(head);
	SListPopBack(&head);
	SListPrint(head);
	SListPopBack(&head);
	SListPrint(head);
	SListDestory(&head);
}
void test_Front()
{
	SListNode *head = NULL;
	printf("头插测试\n");
	SListPushFront(&head, 1);
	SListPrint(head);
	SListPushFront(&head, 2);
	SListPrint(head);
	SListPushFront(&head, 3);
	SListPrint(head);
	SListPushFront(&head, 4);
	SListPrint(head);
	SListPushFront(&head, 5);
	SListPrint(head);
	printf("头删测试\n");
	SListPopFront(&head);
	SListPrint(head);
	SListPopFront(&head);
	SListPrint(head);
	SListPopFront(&head);
	SListPrint(head);
	SListPopFront(&head);
	SListPrint(head);
	SListPopFront(&head);
	SListPrint(head);
	SListDestory(&head);
}
void test()
{
	SListNode *head = NULL;
	SListPushFront(&head, 1);
	SListPushFront(&head, 2);
	SListPushFront(&head, 3);
	SListPushFront(&head, 4);
	SListPushFront(&head, 5);
	SListPushFront(&head, 6);
	SListPushFront(&head, 7);
	SListPushFront(&head, 8);
	SListPushFront(&head, 9);
	SListPrint(head);
	printf("指定位置之后删除测试：\n");
	SListEraseAfter(SListFind(head, 7));
	SListPrint(head);
	printf("指定位置之后插入测试：\n");
	SListInsertAfter(SListFind(head, 7), 6);
	SListPrint(head);
	SListDestory(&head);
}
int main()
{
	//test_Back();
	//test_Front();
	test();
	return 0;
}

二、双向带头循环链表的实现

1. 功能实现

01 struct LinkNode

typedef int LTDataType;
typedef struct ListNode
{
	LTDataType _data;
	struct ListNode* _next;
	struct ListNode* _prev;
}ListNode;

02 动态申请链表新结点

ListNode* ListCreate(LTDataType x)
{
	ListNode* node = (ListNode*)malloc(sizeof(ListNode));
	if (NULL == node)
	{
		assert(0);
	}
	node->_data = x;
	node->_prev = NULL;
	node->_next = NULL;
	return node;
}

03 双向带头循环链表的初始化

ListNode* ListInit()
{
	ListNode* pHead = ListCreate(0);
	pHead->_next = pHead;
	pHead->_prev = pHead;
	return pHead;
}

04 双向带头循环链表的销毁

void ListDestory(ListNode* pHead)
{
	assert(pHead);
	while (pHead->_next != pHead)
	{
		ListErase(pHead->_next);
	}
	free(pHead);
	pHead = NULL;
}

05 双向带头循环链表的打印

void ListPrint(ListNode* pHead)
{
	assert(pHead);
	ListNode* pcurrent = pHead->_next;
	printf("head --> ");
	while (pHead != pcurrent)
	{
		printf("%d --> ", pcurrent->_data);
		pcurrent = pcurrent->_next;
	}
	printf("head\n");
}

06 双向带头循环链表的查找

ListNode* ListFind(ListNode* pHead, LTDataType x)
{
	assert(pHead);
	ListNode* pcurrent = pHead->_next;
	while (pcurrent != pHead)
	{
		if (x == pcurrent->_data)
			return pcurrent;
		pcurrent = pcurrent->_next;
	}
	return NULL;
}

07 双向带头循环链表的按位插入

void ListInsert(ListNode* pos, LTDataType x)
{
	if (NULL == pos)
	{
		return;
	}
	ListNode* newnode = ListCreate(x);
	newnode->_prev = pos->_prev;
	newnode->_next = pos;
	pos->_prev->_next = newnode;
	pos->_prev = newnode;
}

08 双向带头循环链表的按位删除

void ListErase(ListNode* pos)
{
	if (NULL == pos)
	{
		return;
	}
	pos->_prev->_next = pos->_next;
	pos->_next->_prev = pos->_prev;
	free(pos);
	pos = NULL;
}

09 双向带头循环链表的头插头删

// 双向链表头插
void ListPushFront(ListNode* pHead, LTDataType x)
{
	assert(pHead);
	ListInsert(pHead->_next, x);
}
// 双向链表头删
void ListPopFront(ListNode* pHead)
{
	assert(pHead);
	ListErase(pHead->_next);
}

10 双向带头循环链表的尾插尾删

// 双向链表尾插
void ListPushBack(ListNode* pHead, LTDataType x)
{
	assert(pHead);
	ListInsert(pHead, x);
}
// 双向链表尾删
void ListPopBack(ListNode* pHead)
{
	assert(pHead);
	ListErase(pHead->_prev);
}

2. 测试代码

#include"linklist.h"
int main()
{
	ListNode *head = ListInit();
	//先头插5个元素1，2，3，4，5
	printf("先将1，2，3，4，5头插入链表得：\n");
	ListPushFront(head, 1);
	ListPushFront(head, 2);
	ListPushFront(head, 3);
	ListPushFront(head, 4);
	ListPushFront(head, 5);
	ListPrint(head);
	printf("再将6，7，8尾插入链表得：\n");
	//再尾插3个元素6，7，8
	ListPushBack(head, 6);
	ListPushBack(head, 7);
	ListPushBack(head, 8);
	ListPrint(head);
	//头删1个结点
	printf("头删一个节点得：\n");
	ListPopFront(head);
	ListPrint(head);
	printf("尾删一个节点得：\n");
	ListPopBack(head);
	ListPrint(head);
	printf("找出值等于2的节点并删除:\n");
	ListErase(ListFind(head, 2));
	ListPrint(head);
	printf("在值等于1的元素前插入888:\n");
	ListInsert(ListFind(head, 1), 888);
	ListPrint(head);
	ListDestory(head);
}

以上是我对一些比较常见的链表的实现。如有错误，希望大佬指正。
同时，经过对顺序表和链表的学习，我对链表和顺序表的异同以及优缺点做了总结，在此分享出来一同探讨。

角度顺序表链表
存储存储空间连续存储空间不一定连续
随机插入/删除搬移元素 O(n)不需要搬移元素，直接修改指针指向 O(1)
随机访问支持 O(1)不支持 O(n)
获取下一个元素的方式对下标 + +/- -next/prev
插入需要考虑容量，是否需要扩容不需要考虑容量
空间扩容时才需要再次申请空间频繁向堆申请小的内存块
应用场景元素高效存储+频繁访问任意位置频繁地插入删除
缓存利用率高低
RONIN_WZ
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构部分__2、链表的定义及其操作的实现
Themess的博客
05-11 226
1、单链表的定义： typedef struct LNode{ ElemType data; struct LNode *next; }LNode,*LinkList; LNode表示节点，LinkList指针可以理解为链表，data数据域，next指针域。 2、头插法： LinkList headinsert(LinkList &L) { L=(LinkList)malloc(sizeof(LNode)); L->next=NULL; int x;
复合型数据结构：(双向循环)链表_第2部分
weixin_46201756的博客
12-02 1023
双向循环链表第二部分，实现查找数据、删除结点、销毁链表操作，销毁时对野指针了进行处理。
数据结构(Java)之链表(2)-链表的实现
粥粥的博客
06-20 162
先定义一个链表 public class LinkedList <E>{ private class Node{ public E e;//存储数据 public Node next;//指向下一个节点的位置 public Node(E e,Node next){ this.e = e; this.next = next; } public Node(E e){
数据结构与算法 | 链表-2：单链表的实现
RUC_Lee的博客
06-28 293
如何实现单链表？1 前言2 单链表可以进行哪些操作？3 如何实现上面这些操作？3.1 定义节点3.2 判断链表是否为空3.3 求链表长度3.4 遍历整个链表3.5 链表头部添加元素3.6 链表尾部添加元素3.7 指定位置添加元素3.8 删除节点3.9 查找节点是否存在4 完整封装成类参考 1 前言 目前大家已经了解了链表的相关概念，但仅停留在理论层面是远远不够的，下面我们就实际的用Python来实...
数据结构2链表
m0_60961911的博客
02-03 490
1、单链表的概念： 单链表由若干个节点构成； 单链表的节点只有一个指针域； 单链表节点结构： data next data存储数据 next存储下一个节点的指针 下面用一个学生管理系统来学习单链表 1.1学生结构体定义 typedef struct Student { char studentNO[NO_LENGTH]; char studentName[NAME_LENGTH]; }st; typedef介绍：为一种数据类型定义一个新名字。 上面的意思是
Python数据结构之链表实现
最新发布
02-27
1.使用Python语言实现链表数据结构 2.基于类封装思想 3.实现链表增删改查功能 4.有测试数据
数据结构动态数组实现链表
05-12
本文将深入探讨如何使用动态数组来实现链表，这是数据结构课程中常见的一个实践课题。动态数组和链表虽然都是数据结构，但它们各自具有不同的特性和用途，理解它们之间的交互可以增强我们对数据结构设计的理解。 ...
数据结构C语言链表的实现
04-18
数据结构C语言链表的实现
C语言数据结构旋转链表的实现
12-31
C语言数据结构旋转链表的实现 实例： 给出链表1->2->3->4->5->null和k=2 返回4->5->1->2->3->null 分析： 感觉很直观，直接把分割点找出来就行，记得k可能大于len,要取模 代码： /** * Definition for singly-...
C语言 数据结构之链表实现代码
01-20
最近在复习数据结构的相关知识，感觉在初学的时候还是有很多东西没有掌握，不过现在终于算是搞得比较有头绪了，所以就在写出来和大家一起分享！ 什么是链表 简单的说，链表就是由多个结点离散分配，彼此通过指针...
链表的归并 数据结构 C语言实现
06-21
链表的归并 数据结构 C语言实现
C语言中数据结构之链表归并排序实例代码
12-26
C语言中数据结构之链表归并排序实例代码 问题        设有两个无头结点的单链表，头指针分别为ha，hb，链中有数据域data，链域next，两链表的数据都按递增排序存放，现要求将hb表归到ha表中，且归并后ha仍递增序，归并中ha表中已有的数据若hb中也有，则hb中的数据不归并到ha中，hb的链表在算法中不允许破坏。 源程序 #include <stdio> #include<stdlib> #define N1 6 /*链表La的长度*/ #define N2 6 /*链表Lb的长度*/ struct listnode { int data; struct listno
数据结构 2-3-1 线性表的单链表实现
博客标题不能为空我也没办法
06-01 214
一、概念 线性表除了用顺序表（数组）实现，也可以选择用链表实现，链表由于其使用节点存储的特点，所以在增加删除上更方便一些，但是在具体代码编写的过程，由于会涉及到大量的指针，所以编写起来比数组实现要复杂不少。 二、定义 以C代码为例，链表由许多个结构体对象连接而成，每个具体的对象称为一个节点，其中至少包含两个数据项：存储的数据和指向下一个节点的指针。 struct LNode{ int num; struct LNode *next; } 除此之外，我们还需要一个头指针用于指向链表的开头，因为我们的链表
算法与数据结构【二】简单链表的实现
NKPDQZ的博客
02-18 418
链表是线性表的一种，是一种基础的数据结构，也是很多人学习的第一种数据结构，链表的种类不少，单向链表，双向链表，循环链表等，虽然形式众多，但大同小异，都是由一个个节点（NODE）链接起来的。在Java中，有位于utils包下封装好的LinkedList类可以使用，它的底层实现就是链表，而在c语言中就需要我们自己去实现链表，这对我们理解c语言里面的指针和内存分配都是有着不小的帮助。 链表除了首节点和
链表的归并（无头结点，c语言）
许佳佳的博客
11-19 3661
【实验内容】 设有两个无头结点的单链表，头指针分别为ha，hb，链中有数据域data，链域next，两链表的数据都按递增序存放，现要求将hb表归到ha表中，且归并后ha仍递增序，归并中ha表中已有的数据若hb中也有，则hb中的数据不归并到ha中，hb的链表在算法中不允许破坏。 【参考方法说明】 #include #include typedef struct LNode
链表合并
weixin_34186128的博客
01-22 261
设有两个无头结点的单链表，头指针分别为ha。hb，链中有数据域data。链域next。两链表的数据都按递增序存放，现要求将hb表归到ha表中，且归并后ha仍递增序，归并中ha表中已有的数据若hb中也有，则hb中的数据不归并到ha中，hb的链表在算法中不同意破坏。 #include&lt;stdio.h&gt; /// no have dead node ha and hb &g...
C语言两路归并排序链表,C语言中数据结构之链表归并排序实例代码
weixin_29098367的博客
05-21 264
搜索热词C语言中数据结构之链表归并排序实例代码问题设有两个无头结点的单链表，头指针分别为ha，hb，链中有数据域data，链域next，两链表的数据都按递增排序存放，现要求将hb表归到ha表中，且归并后ha仍递增序，归并中ha表中已有的数据若hb中也有，则hb中的数据不归并到ha中，hb的链表在算法中不允许破坏。源程序#include #include#define N1 6 /*链表La的长度*...
（2）单链表的操作 ① 输入一组整型元素序列，使用尾插法建立一个带有头结点的单链表。 ② 实现该线性表的遍历。 ③ 在该单链表的第i个元素前插入一个整数。 ④ 删除该单链表中的第i个元素，其值通过参数
CSDN_buyi的博客
09-29 7838
（2）单链表的操作 ① 输入一组整型元素序列，使用尾插法建立一个带有头结点的单链表。 ② 实现该线性表的遍历。 ③ 在该单链表的第i个元素前插入一个整数。 ④ 删除该单链表中的第i个元素，其值通过参数将其返回。 ⑤ 建立两个按值递增有序的单链表，将他们合并成一个按值递减有序的单链表。要求利用原来的存储空间 #include #include typedef struct LNode
单链表操作的实验课
L-75的专栏
09-20 658
单链表的操作 ① 输入一组整型元素序列，使用尾插法建立一个带有头结点的单链表。 ② 实现该线性表的遍历。 ③ 在该单链表的第i个元素前插入一个整数。 ④ 删除该单链表中的第i个元素，其值通过参数将其返回。 ⑤ 建立两个按值递增有序的单链表，将他们合并成一个按值递减有序的单链表。要求利用原来 //链表的建立，插入，删除 ，合并链表； #include #include typedef
第11章 动态数据结构-链表-21
08-03
"本资源主要介绍了如何在C语言中...总结来说，这个资源提供了C语言实现单向链表的基础知识，包括链表节点的定义、链表的创建方法以及如何通过函数来构建链表，对于学习数据结构和C语言编程的初学者来说是非常有价值的。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

RONIN_WZ

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

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

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

打赏作者

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

抵扣说明：

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

余额充值