[C/C++]数据结构 链表(单向链表,双向链表)

企业开发 2023-12-18 07:05:18 阅读次数: 0

前言:

        上一文中我们介绍了顺序表的特点及实现,但是顺序表由于每次扩容都是呈二倍增长(扩容大小是自己定义的),可能会造成空间的大量浪费,但是链表却可以解决这个问题.

概念及结构:

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

注意:

  1. 链式结构在逻辑上是连续的,但是在物理上不一定连续
  2. 结点一般都是从堆上申请出来的
  3. 从堆上申请的空间是按照一定的策略来分配的,两次申请的空间可能连续也可能不连续

    分类:

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

    虽然链表有这么多种结构,但是在实际中最常用的还是两种结构:

  • 无头单向非循环链表:

          结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈       希桶、图的邻接表等等。       

  •  带头双向循环链表:

       结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单

无头单向非循环链表

接口:

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

// 动态申请一个节点
SListNode* BuySListNode(SLTDateType x);
// 单链表打印
void SListPrint(SListNode* plist);
// 单链表尾插
void SListPushBack(SListNode** pplist, SLTDateType x);
// 单链表的头插
void SListPushFront(SListNode** pplist, SLTDateType x);
// 单链表的尾删
void SListPopBack(SListNode** pplist);
// 单链表头删
void SListPopFront(SListNode** pplist);
// 单链表查找
SListNode* SListFind(SListNode* plist, SLTDateType x);
// 单链表在pos位置之后插入x
void SListInsertAfter(SListNode** pphead,SListNode* pos, SLTDateType x);
// 单链表删除pos位置之后的值
void SListEraseAfter(SListNode** pphead,SListNode* pos);
// 在pos的前面插入
SListNode* SListInsertFront(SListNode** pphead, SListNode* pos, SLTDateType x);
// 删除pos位置
void SLTErase(SListNode** pphead, SListNode* pos);
//单链表摧毁
void SLTDestroy(SLNode** pphead);

1.动态申请结点

SListNode* BuySListNode(SLTDateType x)
{
	SListNode* newnode = (SListNode*)malloc(sizeof(SListNode));
	if (newnode == NULL)
	{
		perror("malloc");
		return;
	}
	newnode->data = x;
	newnode->next = NULL;
}

2.单链表打印

void SListPrint(SListNode* plist)
{
	SListNode* cur = plist;

	 while (cur != NULL)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}

3.单链表尾插

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

4.单链表头插

void SListPushFront(SListNode** pplist, SLTDateType x)
{
	SListNode* newnode = BuySListNode(x);
	newnode->next = *pplist;
	*pplist = newnode;
}

5.单链表尾删

void SListPopBack(SListNode** pplist)
{
	assert(*pplist);


	SListNode* pre = NULL;
	SListNode* tail = *pplist;


	if ((*pplist)->next == NULL)
	{
		*pplist = NULL;
	}
	else
	{
	   /* while (tail->next)
	   {
		 pre = tail; 
		 tail = tail->next;
	   }
	     free(tail);
	     tail = NULL;
	     pre->next = NULL;*/
		SListNode* tail = *pplist;
		while (tail->next->next)
		{
			tail = tail->next;
		}
		free(tail->next);
		tail->next = NULL;
	} 
}

6.单链表头删

void SListPopFront(SListNode** pplist)
{
	assert(pplist);


	if ((*pplist)->next == NULL)
	{
		*pplist = NULL;
	}
	else
	{
		SListNode* ret = ((*pplist)->next);
		free(*pplist);
		*pplist = ret;
	}
}

7.单链表查找

SListNode* SListFind(SListNode* plist, SLTDateType x)
{
	assert(plist);


	SListNode* ret = plist;
	while (ret->data != x&&ret->next)
	{
		ret=ret->next;
	}
	if (ret->next == NULL && ret->data != x)
		return NULL;
	else
		return ret; 
}

8.摧毁单链表

void SLTDestroy(SListNode** pphead)
{
	SListNode* cur = *pphead;
	SListNode* ret = NULL;


	while (cur)
	{
		ret = cur->next;
		free(cur);
		cur = ret;
	}
	*pphead = NULL;
}

9.在pos位置之后插入x

// 单链表在pos位置之后插入x
void SListInsertAfter(SListNode** pphead,SListNode* pos, SLTDateType x)
{
	assert(pphead);
	//检测插入位置是否存在
	assert(pos); 
	assert(*pphead);

	SListNode* newnode=BuySListNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

10.删除pos位置之后的值

// 单链表删除pos位置之后的值
void SListEraseAfter(SListNode** pphead,SListNode* pos)
{
	assert(pphead);
	assert(pos);
	assert(pos->next);
	assert(*pphead);

	SListNode* tmp = pos->next;
	pos->next = pos->next->next;
	free(tmp);
	tmp = NULL;
}

11.在pos位置之前插入x

SListNode* SListInsertFront(SListNode** pphead, SListNode* pos, SLTDateType x)
{
	assert(pphead);
	assert(pos);
	assert(*pphead);

	SListNode* newnode = BuySListNode(x);
	SListNode* pre = *pphead;

	if (*pphead == pos)
	{
		SListPushFront(pphead,x);
	}
	else
	{
		while (pre->next != pos)
		{
			pre = pre->next;
		}
		newnode->next = pos;
		pre->next = newnode;
	}
	

}

12.删除pos位置

void SLTErase(SListNode** pphead, SListNode* pos)
{
	assert(pphead);
	assert(pos);
	assert(*pphead);
	if (*pphead == pos)
	{
		SListPopFront(pphead);
	}
	else
	{
		SListNode* pre = *pphead;
		while (pre->next != pos)
		{
			pre = pre->next;
		}
		pre->next = pos->next;
		free(pos);
		pos = NULL;
	}

}

带头双向循环链表

接口:

// 带头+双向+循环链表增删查改实现
typedef int LTDataType;
typedef struct ListNode
{
	LTDataType _data;
	struct ListNode* _next;
	struct ListNode* _prev;
}ListNode;

// 创建返回链表的头结点.
ListNode* ListCreate();
// 双向链表销毁
void ListDestory(ListNode* pHead);
// 双向链表打印
void ListPrint(ListNode* pHead);
// 双向链表尾插
void ListPushBack(ListNode* pHead, LTDataType x);
// 双向链表尾删
void ListPopBack(ListNode* pHead);
// 双向链表头插
void ListPushFront(ListNode* pHead, LTDataType x);
// 双向链表头删
void ListPopFront(ListNode* pHead);
// 双向链表查找
ListNode* ListFind(ListNode* pHead, LTDataType x);
// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x);
// 双向链表删除pos位置的节点
void ListErase(ListNode* pos);

1.创建返回链表的头节点

ListNode* ListCreate(LTDataType x)
{
	ListNode* node = (ListNode*)malloc(sizeof(ListNode));
	if (node == NULL)
	{
		perror("malloc");
		exit(-1);
	}
	node->_data = x;
	node->_next = NULL;
	node->_prev = NULL;
	return node;
}

2.双向链表销毁

void ListDestory(ListNode* pHead)
{
	assert(pHead);


	ListNode* cur = pHead->_next;
	while (cur != pHead)
	{
		ListNode* next = cur->_next;
		free(cur);
		cur = next;
	}
	free(pHead);
}

3.双向链表打印

void ListPrint(ListNode* pHead)
{
	assert(pHead);
	ListNode* cur = pHead->_next;
	while (cur != pHead)
	{
		printf("%d <-> ", cur->_data);
		cur = cur->_next;
	}
}

4.双向链表尾插

void ListPushBack(ListNode* pHead, LTDataType x)
{
	ListNode* newnode = ListCreate(x);
	ListNode* tail = pHead->_prev;     //尾指针


	tail->_next = newnode;
	newnode->_next = pHead;
	newnode->_prev = tail;
	pHead->_prev = newnode;
}

5.双向链表尾删

void ListPopBack(ListNode* pHead)
{
	assert(pHead);
	assert(pHead->_next!=pHead);


	ListNode* tail = pHead->_prev;


	pHead->_prev = tail->_prev;
	tail->_prev->_next = pHead;
	free(tail);
	tail = NULL;
}

6.双向链表头插

void ListPushFront(ListNode* pHead, LTDataType x)
{
	assert(pHead);


	ListNode* newnode = ListCreate(x);


	newnode->_next = pHead->_next;
	pHead->_next->_prev = newnode;
	pHead->_next = newnode;
	newnode->_prev = pHead;
}

7.双向链表头删

void ListPopFront(ListNode* pHead)
{
	ListNode* pHeadNext = pHead->_next;


	pHeadNext->_next->_prev = pHead;
	pHead->_next = pHeadNext->_next;


	free(pHeadNext);
	pHeadNext = NULL;
}

8.双向链表查找


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


		cur = cur->_next;
	}
	return NULL;
}

9.双向链表在pos的前面进行插入

void ListInsert(ListNode* pos, LTDataType x)
{
	assert(pos);


	ListNode* posprev = pos->_prev;
	ListNode* newnode = ListCreate(x);
	newnode->_next = pos;
	pos->_prev = newnode;
	posprev->_next = newnode;
	newnode->_prev = pos->_prev;
}

10.双向链表删除pos位置的节点

void ListErase(ListNode* pos)
{
	assert(pos);
	
	ListNode* posprev = pos->_prev;
	ListNode* posnext = pos->_next;


	posprev->_next = posnext;
	posnext->_prev = posprev;
	free(pos);
}

猜你喜欢

转载自blog.csdn.net/m0_74910646/article/details/134474797
今日推荐
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
周排行
让自己的头脑极度开放
CentOS 6.5(x64) 和Redhat6.5操作系误删libc
高可用注册中心
【日记】12.28/【题解】AtCoder AGC041
XML（5）_XML 约束_DTD
Java集合Map（四）
树梅派安装桌面环境教程
pipenv 的 使用和安装
小程序白屏问题和内存研究
C语言简单选择排序
每日归档
更多
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022