数据结构：循环链表、双向链表实现及使用

于 2020-03-01 22:50:31 发布
阅读量833 收藏 12
点赞数 1
分类专栏： 数据结构 文章标签： 循环链表 双向链表 链表 数据结构 单链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42441693/article/details/104555800
版权

文章目录

一、循环链表

1.1循环链表基本概念

循环链表： 循环链表是另一种形式的链式存储结构，将单链表中终端结点的指针端由空指针改为指向头结点，就使整个单链表形成一个环，这种头尾相接的单链表称为单循环链表，简称循环链表。从表中任一结点出发均可找到表中其他结点。
       为了使空链表与非空链表处理一致，我们通常设一个头结点。并不一定所有循环链表都要头结点。
循环链表带有头结点的空链表，如图：
在这里插入图片描述
循环链表带有头结点的非空链表，如图：
在这里插入图片描述

1.2循环链表与单链表的主要差异

循环链表与单链表的主要差异：在于循环的判断条件上，单链表是判断p->next是否为空；循环链表则是判断p->next不等于头结点，则循环未结束。
       单链表中有头结点时，我们可以用O(1)的时间访问第一个结点，但对于访问最后一个结点时，却需要O(n)时间，因此我们需要将单链表全部编译一遍太麻烦了。
       我们改造一下这个循环链表，不用头指针，而用指向终端结点的尾指针来表示循环链表，此时查找开始结点和终端结点就十分方便了。
在这里插入图片描述
       上图中，终端结点用尾指针rear指示，则查找终端结点是O(1)，而开始结点，就是rear->next->next，时间复杂度也为O(1)。

1.3循环链表实现及使用

循环链表实现：
头文件：

//使用企业链表创建循环链表好处，不需要自己管理内存
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#pragma once


//链表小结点
typedef struct CIRCLELINKNODE
{
	struct CIRCLELINKNODE* next;
}CircleLinkNode;

//链表结构体
typedef struct CIRCLELINKLIST
{
	CircleLinkNode head;
	int size;
}CircleLinkList;

#define CIRCLELINKLIST_TRUE 1
#define CIRCLELINKLIST_FALSE 0

//比较回调
typedef int(*COMPARENODE)(CircleLinkNode*,CircleLinkNode*);

//打印回调
typedef void(*PRINTNODE)(CircleLinkNode*);

//初始化
CircleLinkList* Init_CircleLinkList();

//插入
void Insert_CircleLinkList(CircleLinkList* clist, int pos, CircleLinkNode* data);

//获得第一个元素
CircleLinkNode* Front_CircleLinkList(CircleLinkList* clist);

//根据位置删除
void RemoveByPos_CircleLinkList(CircleLinkList* clist, int pos);

//根据值删除
void RemoveByValue_CircleLinkList(CircleLinkList* clist, CircleLinkNode* data, COMPARENODE compare);

//获得链表长度
int Siez_CircleLinkList(CircleLinkList* clist);

//判断链表是否为空
int IsEmpty_CircleLinkList(CircleLinkList* clist);

//查找
int Find_CircleLinkList(CircleLinkList* clist, CircleLinkNode* data, COMPARENODE compare);

//打印结点
void Print_CircleLinkList(CircleLinkList* clist, PRINTNODE print);

//释放内存
void Free_CircleLinkList(CircleLinkList* clist);

函数功能实现：

//初始化
CircleLinkList* Init_CircleLinkList()
{
	CircleLinkList* clist = (CircleLinkList*)malloc(sizeof(CircleLinkList));
	clist->head.next = &(clist->head);//指向自己
	clist->size = 0;

	return clist;
}

//插入
void Insert_CircleLinkList(CircleLinkList* clist, int pos, CircleLinkNode* data)
{
	if (clist == NULL || data == NULL) return;
	if (pos < 0 || pos > clist->size)
	{
		pos = clist->size;
	}
	
	//根据位置查找结点,需要辅助指针变量
	CircleLinkNode* pCurrent = &(clist->head);
	for (int i=0; i<pos; i++)
	{
		pCurrent = pCurrent->next;
	}

	//新数据入链表
	data->next = pCurrent->next;
	pCurrent->next = data;

	clist->size++;
}

//获得第一个元素
CircleLinkNode* Front_CircleLinkList(CircleLinkList* clist)
{
	return clist->head.next;
}

//根据位置删除
void RemoveByPos_CircleLinkList(CircleLinkList* clist, int pos)
{
	if (clist == NULL) return;
	if (pos < 0 || pos>= clist->size) return;

	//根据pos找删除结点的前一个结点，需要辅助指针变量
	CircleLinkNode* pCurrent = &(clist->head);
	for (int i=0; i<pos; i++)
	{
		pCurrent = pCurrent->next;
	}

	//删除
	CircleLinkNode* pNext = pCurrent->next;
	pCurrent->next = pNext->next;

	clist->size--;
}

//根据值删除
void RemoveByValue_CircleLinkList(CircleLinkList* clist, CircleLinkNode* data, COMPARENODE compare)
{
	if (clist == NULL || data == NULL) return;
	
	//循环链表的根据值删除
	CircleLinkNode* pPrev = &(clist->head);//被删除结点前一个结点
	CircleLinkNode* pCurrent = pPrev->next;
	int i = 0;
	for (int i=0; i<clist->size; i++)
	{
		if (compare(pCurrent,data) == CIRCLELINKLIST_TRUE)
		{
			pPrev->next = pCurrent->next;
			break;
		}
		pPrev = pCurrent;
		pCurrent = pPrev->next;
	}	
}

//获得链表长度
int Siez_CircleLinkList(CircleLinkList* clist)
{
	return clist->size;
}

//判断链表是否为空
int IsEmpty_CircleLinkList(CircleLinkList* clist)
{
	if (clist->size == 0)
	{
		return CIRCLELINKLIST_TRUE;
	}
	return CIRCLELINKLIST_FALSE;
}

//查找
int Find_CircleLinkList(CircleLinkList* clist, CircleLinkNode* data, COMPARENODE compare)
{
	if (clist == NULL || data == NULL) return -1;

	//查找
	CircleLinkNode* pCurrent = clist->head.next;
	int flag = -1;
	for (int i=0; i<clist->size; i++)
	{
		if (compare(pCurrent,data) == CIRCLELINKLIST_TRUE)
		{
			flag = i;
			break;
		}
		pCurrent = pCurrent->next;
	}
	return flag;
}

//打印结点
void Print_CircleLinkList(CircleLinkList* clist, PRINTNODE print)
{
	if (clist == NULL) return;

	//辅助指针变量
	CircleLinkNode* pCurrent = clist->head.next;
	for (int i=0; i<clist->size; i++)
	{
		print(pCurrent);
		pCurrent = pCurrent->next;
	}
}

//释放内存
void Free_CircleLinkList(CircleLinkList* clist)
{
	if (clist == NULL) return;
	free(clist);
}

测试：
1.插入数据
在这里插入图片描述
2.删除ddd
在这里插入图片描述
 

二、双向链表

2.1双向链表基本概念

双向链表： 双向链表就是在单链表的每个结点中，在设置一个指向其前驱结点的指针域。 所以在双向链表的每个结点都有两个指针域，一个指向直接后继，另一个指向直接前驱。结构如下：

/*线性表的双向链表存储结构*/
typedef struct DulNode
{
	ElemType data;
	struct DuLNode *prior;/*直接前驱指针*/
	struct DuLNode *next;/*直接后继指针*/
}DulNode,*DuLinkList;
2.2双向链表基本操作

1.单链表有循环链表，双向链表也可以有循环链表。
双向链表的循环带头结点的空链表如图：
在这里插入图片描述
非空的循环的带头结点的双向链表如图：
在这里插入图片描述
       由于这是双向链表，对于链表中下一个结点p，它的后继的前驱还是它自己；它的前驱的后继也是它自己。即：

p->next->prior = p = p->prior->next;

2.双向链表的基本操作：
       双向链表是单链表中扩展出来的结构，所以它的很多操作是和单链表相同的，比如求长度，查找元素，获得元素位置等。
双向链表的插入：需要更改两个指针变量。 假设存储元素e的结点为s，要实现将s插入到结点p和p->next之间需要以下几步(顺序不能反)：
在这里插入图片描述
双向链表的删除：需要更改两个指针变量。 假设要删除结点p，如图所示：
在这里插入图片描述

2.3双向链表实现及使用

双向链表实现：
以前写的：双向链表实现
这里简单看看主要功能实现就好了。
头文件：

#pragma once
//双向链表，带头结点，头的前驱为NULL，尾的后继为NULL

typedef struct DNode
{
	int data;
	struct DNode *next;//后继指针
	struct DNode *prio;//前驱指针
}DNode,*DList;

void InitList(DList plist);

bool Insert_head(DList plist,int val);//头插法

bool Insert_tail(DList plist,int val);//尾插法

DNode *Search(DList plist,int key);//查找

bool Delete(DList plist,int key);//删除

bool IsEmpty(DList plist);//判空

int GetLength(DList plist);//获取长度,数据个数

void Show(DList plist);//打印

DNode *Getprio(DList plist,int key);//获得key的前驱

DNode *GetNext(DList plist,int key);//获得key的后继

void Clear(DList plist);//清空

void Destory(DList plist);//销毁

主要功能实现：

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

void InitList(DList plist)
{
	assert(plist != NULL);
	if (plist == NULL)
	{
		return ;
	}
	plist->next = NULL;
	plist->prio = NULL;
}

bool Insert_head(DList plist,int val)//头插法
{
	DNode *p = (DNode *)malloc(sizeof(DNode));
	p->data = val;

	p->next = plist->next;
	plist->next = p;
	p->prio = plist;

	if (p->next != NULL)
	{
		p->next->prio = p;
	}
	return true;
}

bool Insert_tail(DList plist,int val)//尾插法
{
	DNode *p = (DNode *)malloc(sizeof(DNode));
	p->data = val;

	DNode *q;
	for (q=plist; q->next != NULL;q=q->next);
	
	p->next = q->next;
	p->prio = q;
	q->next = p;
	
	return true;
}

DNode *Search(DList plist,int key)//查找
{
	for (DNode *p=plist->next; p!=NULL; p=p->next)
	{
		if (p->data == key)
		{
			return p;
		}
	}
	return NULL;
}

bool Delete(DList plist,int key)//删除
{
	DNode *p = Search(plist,key);
	if (p == NULL)
	{
		return false;
	}
	
	//将p从链表中剔除
	p->prio->next = p->next;
	if (p->next != NULL)
	{
		p->next->prio = p->prio;
	}
	free(p);
	return true;
}

bool IsEmpty(DList plist)//判空
{
	return plist->next == NULL;
}

int GetLength(DList plist)//获取长度,数据个数
{
	int count = 0;
	for (DNode *p=plist->next; p!=NULL; p=p->next)
	{
		count++;
	}
	return count;
}

void Show(DList plist)//打印
{
	for (DNode *p=plist->next; p!=NULL; p=p->next)
	{
		printf("%d \n",p->data);
	}
}

DNode *Getprio(DList plist,int key)//获得key的前驱
{
	assert(plist!=NULL);
	for (DNode *p=plist; p->next!=NULL; p=p->next)
	{
		if(p->next->data == key)
		{
			return p;
		}
	}
	return NULL;
}

DNode *GetNext(DList plist,int key)//获得key的后继
{
	DNode *p = Search(plist,key);

	if (p == NULL)
	{
		return NULL;
	}
	return p->next;
}

void Clear(DList plist)//清空
{
	Destory(plist);
}

void Destory(DList plist)//销毁
{
	DNode *p;
	while (plist->next != NULL)
	{
		p = plist->next;
		plist->next = p->next;
		free(p);
	}
}
硕～
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值