【数据结构-线性表】双向（循环）链表ADT（严蔚敏《数据结构》）

最新推荐文章于 2024-07-15 17:15:24 发布
最新推荐文章于 2024-07-15 17:15:24 发布
阅读量401 收藏 3
点赞数 2
分类专栏： 数据结构+算法 文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50295745/article/details/120746235
版权

书里不全，而且有的写的不好。

我全敲出来，测试过，并且底层函数之间没有互相调用（其实完全可以的，但是我就是不，诶，就是玩儿）

并且把里面一些安排的不好的函数优化了一下.

//双向链表ADT

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#define OK 1
#define ERROR 0
typedef int ElemType;
typedef int Status;
typedef struct Node {
	ElemType data;
	struct Node* prior;
	struct Node* next;
}node, * List;
//小技巧：头结点储存链表长度，还能统一空表和非空表的操作

//函数原型
void Out(ElemType e);//格式化输出
void Print(List L);//正序输出
void PrintDown(List L);//倒序输出

Status InitList(List& L);/*创建空表*/
//Status DestroyList(node* L);//销毁整表
//Status ClearList(node* L);//将L置为空表
bool ListEmpty(List L);//判断是否为空
int ListLength(List L);//返回长度,0和空表都是0

Status GetElem(List L, int i, ElemType& e);//用e返回第i位元素
node* LocateElem(List L, ElemType e, Status(*cmp)(ElemType e,ElemType temp) );//定位到和e满足条件的元素，返回地址，注意编写cmp函数的时候，左边是e，右边是遍历项
node* PriorElem(List L, ElemType cur);//返回cur的前驱，第一个的话就返回L
node* NextElem(List L, ElemType cur);//返回cur的后继，最后一个就返回NULL

Status ListInsert(List L, int i, ElemType e);//把e插入到i位
Status ListDelete(List L, int i, ElemType& e);//删除i位，返回e

Status ListTraverse(List L, Status(*visit)(ElemType& e));//遍历L，执行visit

//函数定义
void Out(ElemType e)
{
	printf("%d\t", e);
}
void Print(List L)
{
	//本算法考虑了空表情况
	node* p = L;
	while (p->next)
	{
		p = p->next;
		Out(p->data);
	}
}
void PrintDown(List L)
{
	//找到尾结点
	node* p = L;
	while (p->next)
		p = p->next;
	//倒序输出
	while (p != L)
	{
		Out(p->data);
		p = p->prior;
	}
}

Status InitList(List &L)
{
	//创建头结点赋值并链接
	node* head = (node*)malloc(sizeof(node));
	if (!head) return ERROR;
	head->data = 0; //长度为0

	L = head;
	head->prior = NULL;
	head->next = NULL;

	return OK;
}
bool ListEmpty(List L)
{
	if (L->data == 0)
		return true;
	else
		return false;
}
int ListLength(List L)
{
	if (L)
		return L->data;
	else
		return ERROR;
}


Status GetElem(List L, int i, ElemType& e)
{
	//本函数采用先查后判断异常的方式
	//令p和index同步采取while循环，因为后面要用index，所以for不如while
	node* p = L;
	int index = 0;
	while (p && index < i)
	{
		p = p->next;
		index++;
	}
	//到这里，成功则index==i，否则就是i小于1或者大于ListLength
	if (!p || i < 1)
		return ERROR;
	else
	{
		e = p->data;
		return OK;
	}
}
node* LocateElem(List L, ElemType e, Status(*cmp)(ElemType e,ElemType temp))
{
	//参数中有一个Status(ElemType,ElemType)型的函数指针
	node* p = L;
	while (p->next)
	{
		p = p->next;
		if (cmp(e, p->data))//直接调用，等价模式
			return p;
	}
	return NULL;
}
node* PriorElem(List L, ElemType cur)
{
	//一般来说是用两个指针pre和p，但是其实双向链表更好实现
	node* p = L;
	while (p->next)
	{
		p = p->next;
		if (cur == p->data)
			return p->prior;
	}
	return NULL;
}
node* NextElem(List L, ElemType cur)
{
	node* p = L;
	while (p->next)
	{
		p = p->next;
		if (p->data == cur)
				return p->next; //不需要判断尾结点，如果是尾结点，就会返回NULL
	}
	return NULL;
}

Status ListInsert(List L, int i, ElemType e)
{
	//本算法为书中优化算法，可以插到i+1位（尾部）
	//查找i-1位，所以存在index为0的情况（插到第一个节点）
	node* p = L;
	int index = 0;
	while (p && index < i - 1)
	{
		p = p->next;
		index++;
	}
	//判断情况
	if (!p || i < 1)
		return ERROR;
	else
	{
		node* newnode = (node*)malloc(sizeof(node));
		if (!newnode) return ERROR;
		newnode->data = e;

		if (p->next)//判断非表尾 
			p->next->prior = newnode;
		newnode->next = p->next;
		p->next = newnode;
		newnode->prior = p;
		L->data++;

		return OK;
	}
}
Status ListDelete(List L, int i, ElemType& e)
{
	//查找i位
	node* p = L;
	node* pre_p = p;
	int index = 0;
	while (p && index < i)
	{
		pre_p = p;
		p = p->next;
		index++;
	}
	//判断情况
	if (!p || i < 1) 
		return ERROR;
	else
	{
		e = p->data;

		if (p->next)//判断非尾部
			p->next->prior = pre_p;
		pre_p->next = p->next;
		free(p);
		L->data--;

		return OK;
	}
}

Status ListTraverse(List L, Status(*visit)(ElemType& e))
{
	node* p = L;
	while (p->next)
	{
		p = p->next;
		if (!visit(p->data))
			return ERROR;
	}
}

Status visit(ElemType&e)
{
	e = e * 10 - 1;
	return OK;
}
int main(void)
{
	node* L = NULL;
	ElemType e = -1;
	node* p = NULL;

	InitList(L);
	for (int i = 1; i <= 5; i++)
		ListInsert(L, i, i);
	Print(L);
	PrintDown(L);
	putchar('\n');
	//下面随便测试
      
	return 0;
}

要解双向约瑟夫环问题了，所以又在原有基础上改成了双向环表

//双向循环链表ADT

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#define OK 1
#define ERROR 0
typedef int ElemType;
typedef int Status;
typedef struct Node {
	ElemType data;
	struct Node* prior;
	struct Node* next;
}node, * List;
//小技巧：头结点储存链表长度，还能统一空表和非空表的操作

//函数原型
void Out(ElemType e);//格式化输出
void PrintLoop(List L);//正序输出
void PrintLoopDown(List L);//倒序输出

Status InitList(List& L);/*创建空表*/
//Status DestroyList(node* L);//销毁整表
//Status ClearList(node* L);//将L置为空表
bool ListEmpty(List L);//判断是否为空
int ListLength(List L);//返回长度,0和空表都是0

Status GetElem(List L, int i, ElemType& e);//用e返回第i位元素
node* LocateElem(List L, ElemType e, Status(*cmp)(ElemType e,ElemType temp) );//定位到和e满足条件的元素，返回地址，注意编写cmp函数的时候，左边是e，右边是遍历项
//前驱后继可能得根据需求修改了，看你怎么定义前驱后继
node* PriorElem(List L, ElemType cur);//返回cur的前驱，第一个的话就返回L
node* NextElem(List L, ElemType cur);//返回cur的后继，最后一个就返回NULL

Status ListInsert(List L, int i, ElemType e);//把e插入到i位
Status ListDelete(List L, int i, ElemType& e);//删除i位，返回e

Status ListTraverse(List L, Status(*visit)(ElemType& e));//遍历L，执行visit

//函数定义
void Out(ElemType e)
{
	printf("%d\t", e);
}
void PrintLoop(List L)
{
	node* p = L;
	while (p->next != L)//兼容空表
	{
		p = p->next;
		Out(p->data);
	}
	p = p->next;
	while (p->next != L)//兼容空表
	{
		p = p->next;
		Out(p->data);
	}
}
void PrintLoopDown(List L)
{
	//找到尾结点
	node* p = L->prior;
	//倒序输出，兼容空表
	while (p != L)
	{
		Out(p->data);
		p = p->prior;
	}
	p = p->prior;
	while (p != L)
	{
		Out(p->data);
		p = p->prior;
	}
	
}

Status InitList(List &L)
{
	//创建头结点赋值并链接
	node* head = (node*)malloc(sizeof(node));
	if (!head) return ERROR;
	head->data = 0; //长度为0

	L = head;
	head->prior = head;
	head->next = head;

	return OK;
}
bool ListEmpty(List L)
{
	if (L->data == 0)
		return true;
	else
		return false;
}
int ListLength(List L)
{
	if (L)
		return L->data;
	else
		return ERROR;
}

Status GetElem(List L, int i, ElemType& e)
{
	//本函数采用先查后判断异常的方式
	//令p和index同步采取while循环，因为后面要用index，所以for不如while
	node* p = L->next;
	int index = 1;
	while (p != L && index < i)
	{
		p = p->next;
		index++;
	}
	//到这里，成功则index==i，否则就是i小于1或者大于ListLength
	if (p == L || i < 1)
		return ERROR;
	else
	{
		e = p->data;
		return OK;
	}
}
node* LocateElem(List L, ElemType e, Status(*cmp)(ElemType e,ElemType temp))
{
	//参数中有一个Status(ElemType,ElemType)型的函数指针
	node* p = L;
	while (p->next != L)
	{
		p = p->next;
		if (cmp(e, p->data))//直接调用，等价模式
			return p;
	}
	return NULL;
}
node* PriorElem(List L, ElemType cur)
{
	//一般来说是用两个指针pre和p，但是其实双向链表更好实现
	node* p = L;
	while (p->next != L)
	{
		p = p->next;
		if (cur == p->data)
			return p->prior;
	}
	return NULL;
}
node* NextElem(List L, ElemType cur)
{
	node* p = L;
	while (p->next != L)
	{
		p = p->next;
		if (p->data == cur)
			return p->next;
	}
	return NULL;
}

Status ListInsert(List L, int i, ElemType e)
{
	//本算法为书中优化算法，可以插到i+1位（尾部）
	if (i == 1) //第一位特殊处理一下
	{
		node* p = (node*)malloc(sizeof(node));
		if (!p) return ERROR;

		p->data = e;
		p->next = L->next;
		L->next->prior = p;
		L->next = p;
		p->prior = L;
		L->data++;

		return OK;
	}
	else
	{
		//查找i-1位，不存在index为0的情况（插到第一个节点）
		node* p = L->next;
		int index = 1;
		while (p != L && index < i - 1)
		{
			p = p->next;
			index++;
		}
		//判断情况
		if (p == L || i < 1)
			return ERROR;
		else
		{
			node* newnode = (node*)malloc(sizeof(node));
			if (!newnode) return ERROR;
			newnode->data = e;

			p->next->prior = newnode;
			newnode->next = p->next;
			p->next = newnode;
			newnode->prior = p;
			L->data++;

			return OK;
		}
	}
}
Status ListDelete(List L, int i, ElemType& e)
{
	//查找i位，从1开始
	node* p = L->next;
	node* pre_p = L;
	int index = 1;
	while (p != L && index < i)
	{
		pre_p = p;
		p = p->next;
		index++;
	}
	//判断情况
	if (p == L || i < 1)
		return ERROR;
	else
	{
		e = p->data;

		p->next->prior = pre_p;
		pre_p->next = p->next;
		free(p);
		L->data--;

		return OK;
	}
}

Status ListTraverse(List L, Status(*visit)(ElemType& e))
{
	node* p = L;
	while (p->next != L)
	{
		p = p->next;
		if (!visit(p->data))
			return ERROR;
	}
}


//主函数
int main(void)
{
	node* L = NULL;
	node* p = NULL;
	ElemType e = -1;
	node* left = NULL;
	node* right = NULL;

	InitList(L);

	for (int i = 1; i <= 5; i++)
		ListInsert(L, i, i);
	PrintLoop(L);
	PrintLoopDown(L);
	putchar('\n');
	//后面随便测试

	return 0;
}

亦梦亦醒乐逍遥
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构-----双向链表
bobopeng
10-22 651
#include #include #include // 双向链表的的结点定义 typedef struct Node { int elem ; struct Node * next ; struct Node * prior ; } Node ; // 双向链表定义 typedef struct DoubleLinkList { Node * head ; } DoubleL
C_线性表(ADT)-双向循环链表的表示和实现
Cynical丶Gary_博客
08-05 992
双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。(解释来自百度百科) 下面是网上的一张双向循环链表的结构图片： 双向链表定义： typedef struct DuLNode { ElemType data;
链表ADT的创建（c语言）
qq_73743836的博客
02-21 285
链表的创建
《数据结构》严蔚敏第二版 2.53 循环链表，双向链表
qq_47218406的博客
09-23 341
来啦，兄弟们中午好啊! 废话不多缩,come with me ,baby. ps:我现在是大二上，这个学期修数据结构，知识点是我上课，下课在书上，网上各种地方找到理解 ** 循环链表： ** 昨天的单向链表不知道有没有兄弟姐妹（顺序不分先后）注意到，链表的最后一个指针指向的是NULL呢? 正是通过单向链表的最后一个指针指向的是NULL,我们才得以完成链表的遍历，完成链表的遍历是增删查改的重中之重。今天呢，我们来康康循环链表，同学们不用担心，循环链表肥肠的简单。 单向链表的最后一个指针指向NULL，循环链
数据结构（二） 线性链表ADT List基本操作函数
m0_61598337的博客
08-18 1168
创建数组时，我们会直接分配出所有我们需要的内存。但是对于链表，我们每次只分配出一个节点（node） 的内存。链表使用指针将各个节点组合到一起，这样就形成了一个连一个的链式的结构，这就是链表（Linked List）这个名称的由来。 链表的每个节点都有两个部分：数据区和指针区。前者用来存储数据，后者用来存储指向下一个节点的指针。我们使用 malloc() 函数来为每个节点分配内存。节点的头部只含有指向第一个节点的指针。...
链表的ADT
weixin_34194359的博客
03-24 785
Status InitList(LinkedList L) { if(!L) return OVERFLOW; L = (LinkedList) malloc (sizeof(LNode)); L->next = NULL; return SUCCESS; } /** * @name : void DestroyList(LinkedList *L) * @de...
线性表的链式实现（数据结构-严蔚敏）
02-03
线性表的链式实现（数据结构-严蔚敏）线性表的链式实现（数据结构-严蔚敏）线性表的链式实现（数据结构-严蔚敏）线性表的链式实现（数据结构-严蔚敏）线性表的链式实现（数据结构-严蔚敏）线性表的链式实现（数据...
严蔚敏数据结构ppt
09-27
《严蔚敏数据结构》是计算机科学领域中经典的数据结构教程，主要涵盖了数据结构的基本概念、类型、操作以及它们在算法设计中的应用。这门课程通常包括数组、链表、栈、队列、树、图、散列、排序和查找等核心主题。...
数据结构（C语言）第二版课后习题答案（严蔚敏 李冬梅 吴伟民）.doc
03-16
数据结构是计算机科学中至关重要的基础课程，它探讨如何有效地组织和管理数据，以便于高效地执行各种操作。本文将详细解析《数据结构（C语言）第二版》课后习题答案中的主要知识点，涵盖从绪论到排序的全部章节。 1...
2021数据结构上机实验题目 v21
08-08
- **严蔚敏数据结构题集**：提及的习题集可能包含更多关于数据结构的练习，如习题1.19、1.20和2.19，这些都是对数据结构深入理解和应用的补充。 通过这些实验，学生可以巩固数据结构的基础知识，提高对线性结构、...
单链表双向链表ADT_C语言项目
04-04
Singly Linked List： 1. DestroyList 2. InsertList 3. DeleteList 4. TraverseList 5. SearchList 6. ReverseList 7. IsLoopList 8. ReverseEvenList 9. FindMidNode Double Linked List： 1. DestroyList_DuL 2. InsertBeforeList_DuL 3. InsertAfterList_DuL 4. DeleteList_DuL 5. TraverseList_DuL
第1章-绪论-清华严蔚敏数据结构
03-11
清华大学严蔚敏教授的数据结构教程是这方面的一个经典资源。本章主要介绍数据结构的基本概念，包括数据结构的定义、基本术语、抽象数据类型、算法和算法分析。 1.1 什么是数据结构 数据结构是指在计算机中存储、...
单链表的一些ADT实现代码
CircaOVO的博客
06-15 463
#include<iostream> using namespace std; typedef struct LinkNode { int data; LinkNode* next; }LNODE, * PNODE; typedef struct LinkList { PNODE head; int length; }Llist ; //初始化 Llist* Initlist() { Llist* mylist = new Llist; //申请.
数据结构：链式表ADT的实现
Viadimir的博客
09-23 1429
链表适用于插入或删除操作频繁，存储空间需求不定的情形。链表分很多种，有单链表、双链表、循环链表等，这里我以单链表为例，实现单链表的ADT。 单链表是一种最简单的链表表示，也叫作线性链表。用它来表示线性表时，用指针表示节点间的逻辑关系。因此单链表的一个存储节点包含两部分： ...
单链表ADT和双链表ADT
西瓜的博客
04-02 994
数据结构中的链表，有单链表和双链表，这一篇里实现了单链表ADT和双链表ADT。
数据结构-双端链表和双向链表
cc098818的博客
09-09 1304
1、双端链表 链表中保存着对最后一个节点的引用，这就是双端链表 package chap05; import chap04.Node; //双端链表 public class FirstLastLinkList { private Node first;//头结点 private Node last;//尾结点 FirstLastLinkList() { first=null...
数据结构--双向链表
一念之间、
12-27 269
单链表的单向性：只能从头结点开始高效访问链表中的数据元素。 单链表还存在另一个缺陷：逆序访问时候的效率极低。 如下： LinkList list; for(int i = 0; i < 5; i++) { list.insert(0,i); } for(int i = list.length() - 1; i >= 0;
严蔚敏版《数据结构 （C语言版）》和《数据结构题集》（四）——循环链表、双向链表、一元多项式...
weixin_30826095的博客
08-14 195
单循环链表的实现 1 typedef int Elemtype; 2 typedef struct node{ 3 Elemtype data; 4 struct node *next; 5 }node,*linklist; 6 7 void createList_L(linklist &l){ 8 l=(linklist )malloc(...
数据结构--二叉树遍历
最新发布
binhyun的博客
07-15 445
（1）前序遍历 （2）定义结构体 （3）前序遍历实现 （4）中序遍历实现 （5）二叉树的节点个数 （6）二叉树树叶节点个数 （7）二叉树的高度 （8）二叉树节点的开辟 （9）建立一个测试二叉树 （10）测试二叉树相关函数的功能 （11）第k层的数据个数 （12）二叉树里面查找节点

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

亦梦亦醒乐逍遥

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

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

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

打赏作者

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

抵扣说明：

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

余额充值