【2.4】单向循环链表

最新推荐文章于 2022-03-27 21:05:35 发布

yeler082

最新推荐文章于 2022-03-27 21:05:35 发布

阅读量1.6k

点赞数 1

分类专栏：数据结构算法

本文链接：https://blog.csdn.net/yeler082/article/details/79975294

版权

数据结构算法专栏收录该内容

14 篇文章 0 订阅

订阅专栏

一、单向循环链表结构特点。

1、所有元素依次衔接，尾部元素链接到首元素。

2、适用于环形结构处理的场合。

3、便于特定步长循环遍历链表元素。

二、单向循环链表的基本结构图。

上图分别表示不带头结点和带头结点的单向循环链表。

3、文件组织方式

4、代码实现

文件一：circular_list.h单向循环链表的函数定义

#ifndef _YE_LELE_01  
#define _YE_LELE_01 

typedef int ElemType;
typedef int Status;

typedef struct LNode
{
	ElemType data;
	struct LNode *next;
}LNode,*LinkList;

void InitList(LinkList &L);//循环链表的初始化

void DestoryList(LinkList &L);//销毁循环链表

void ClearList(LinkList &L);//清空循环链表

Status ListEmpty(LinkList L);//判断循环链表元素是否为空

int ListLength(LinkList L);//获得循环链表的长度

Status GetElem(LinkList L, int loc, ElemType &e);//得到循环链表loc位置的元素并赋值给e

int LocateElem(LinkList L, ElemType a);//定位元素a在循环链表的位置

Status PriorElem(LinkList L, ElemType a, ElemType &e);//获取链表元素a的前一个节点并赋值给e，返回一个状态

Status NextElem(LinkList L, ElemType a, ElemType &e);//获取链表元素a的后一个节点并赋值给e，返回一个状态

Status ListAppend(LinkList &L, ElemType a);//将元素a插入到链表尾部

Status ListInsert(LinkList &L, ElemType a,int loc);//将元素a插入到链表loc的位置

Status ListDelete(LinkList &L, ElemType &e,int loc);//删除循环链表loc位置的元素,并将删除的值赋值给e

void ListTraverse(LinkList L);//遍历整个循环链表

#endif

文件2：circular_list.cpp单向循环链表的函数实现

#include "circular_list.h"
#include <stdlib.h>
#include <stdio.h>
//定义状态码
#define ERROE -2
#define OVERFLOW -3
#define OK 1
#define YES 1
#define NO 0
//循环链表的初始化,带有头结点的循环单链表
void InitList(LinkList &L)
{
	//申请一个节点作为循环链表的头结点
	L = (LinkList )malloc(sizeof(LNode));
	//如果申请失败，内存溢出退出程序
	if (!L)
	{
		exit(OVERFLOW);
	}
	L->next = L;//初始化的循环链表的头结点指向本身
	L->data = 0;
}

//将元素a插入到链表尾部（尾插法）
Status ListAppend(LinkList &L, ElemType a)
{
	//LinkList 作为一个链表的节点指针类型
	LinkList p = L;//p指向链表的头结点  
	LinkList s;//新定义一个表节点  
	while (true)
	{
		//如果循环到达最后一个节点，终止循环
		if (p->next == L)
		{
			break;
		}
		p = p->next;
	}
	s = (LinkList)malloc(sizeof(LNode));
	p->next = s;
	s->next = L;
	s->data = a;
	return OK;
}

//遍历整个循环链表
void ListTraverse(LinkList L)
{
	LinkList p = L;//p指向链表的头结点  
	while (p)
	{
		if (p->next == L)
		{
			break;
		}
		p = p->next;
		printf("%d\t", p->data);
	}
	printf("\n");
}

//销毁循环链表
void DestoryList(LinkList &L)
{
	//如果链表本身为空，错误退出
	if (!L)
	{
		exit(ERROE);
	}
	//释放循环链表指针，释放内存
	free(L);
}

//清空循环链表
void ClearList(LinkList &L)
{
	//如果链表本身为空，错误退出
	if (!L)
	{
		exit(ERROE);
	}
	L->next = L;
	printf("循环链表成功清除！\n");
}

//判断循环链表元素是否为空
Status ListEmpty(LinkList L)
{
	//如果链表本身为空，错误退出
	if (!L)
	{
		exit(ERROE);
	}
	//定义一个指针指向首节点
	LinkList p = L;
	if (p->next == L)
	{
		return YES;
	}
	return NO;
}

//获得循环链表的长度
int ListLength(LinkList L)
{
	//如果链表本身为空，错误退出
	if (!L)
	{
		exit(ERROE);
	}
	LinkList p = L;
	int count = 0;
	while (true)
	{
		if (p->next == L)
		{
			break;
		}
		p = p->next;
		count++;
	}
	return count;
}

//得到循环链表loc位置的元素并赋值给e
Status GetElem(LinkList L, int loc, ElemType &e)
{
	//如果链表不存在（没有初始化），返回错误
	if (!L)
	{
		return ERROE;
	}
	LinkList p = L;
	//获取链表的长度
	int Length = ListLength(L);
	//判断获取元素的位置是否正确
	if (loc<1||loc>Length)
	{
		printf("获取元素位置%d不存在！\n",loc);
		return ERROE;
	}
	while (loc)
	{
		p = p->next;
		loc--;
	}
	e = p->data;
	return OK;
}

//定位元素a在循环链表的位置（从前往后查找，返回第一次出现的位置），如果找到返回位置。未找到返回状态码NO
int LocateElem(LinkList L, ElemType a)
{
	//定义一个标记，用于指示状态
	int flag,loc=0;
	//如果循环链表未初始化，返回错误码
	if (!L)
	{
		return ERROE;
	}
	//定义一个节点指向循环链表的首节点
	LinkList p = L;
	while (true)
	{
		//如果在n-1个节点内找到该元素
		if (p->next != L)
		{
			if (p->data == a)
			{
				flag = 1;
				return loc;
			}
			p = p->next;
			loc++;
		}
		//如果表尾元素等于需要判断的元素
		else if (p->next == L&&p->data == a)
		{
			return loc;
		}
		//如果没有找到该元素
		else
		{
			flag = -1;
			break;
		}
	}
	if (flag == -1)
	{
		return NO;
	}
}

//获取链表元素a的前一个节点并赋值给e，返回一个状态
Status PriorElem(LinkList L, ElemType a, ElemType &e)
{
	if (!L)
	{
		exit(ERROE);
	}
	LinkList p = L,p1 = L;
	//获取元素a在循环链表的位置
	int position = LocateElem(L, a);
	//获取链表的长度
	int Length = ListLength(L);
	if (position<1)
	{
		printf("循环链表不存在该元素,无节点值返回\n");
		return NO;
	}
	//如果元素a是循环链表的第一个节点，其前驱为最后一个节点
	if (position == 1)
	{
		while (p1->next != L)
		{
			p1 = p1->next;
		}
		e = p1->data;
	}
	//当找到循环链表存在该元素时
	else
	{
		position -= 1;
		while (position)
		{
			p = p->next;
			position--;
		}
		e = p->data;
	}
	return OK;
}

//获取链表元素a的后一个节点并赋值给e，返回一个状态
Status NextElem(LinkList L, ElemType a, ElemType &e)
{
	if (!L)
	{
		exit(ERROE);
	}
	LinkList p = L->next;//?这里有个小问题，没清楚为什么要先指向后一个节点（debug出来的）
	//获取元素a在循环链表的位置
	int position = LocateElem(L, a);
	//获取链表的长度
	int Length = ListLength(L);
	//如果该元素不存在
	if (position<1)
	{
		printf("循环链表不存在该元素,无节点值返回\n");
		return NO;
	}
	//如果该元素为最后一个节点,将首节点的值赋值给e,返回找到状态码
	if (position>=Length)
	{
		e = p->data;
	}//如果该元素为中间节点
	else
	{
		while (position)
		{
			p = p->next;
			position--;
		}
		e = p->data;
	}
	return OK;
}

//将元素a插入到链表loc的位置*****
Status ListInsert(LinkList &L, ElemType a, int loc)
{
	if (!L)
	{
		exit(ERROE);
	}
	LinkList p = L,p1 = L,s;
	//获取链表的长度
	int Length = ListLength(L);
	if (loc<1||loc>Length)
	{
		printf("元素%d插入的位置不存在\n",a);
		return ERROE;
	}
	//申请一个节点的空间
	s = (LinkList)malloc(sizeof(LNode));
	s->data = a;
	//获取当前位置的前一个节点
	//如果元素a是循环链表的第一个节点，那么插入元素作为第一个节点
	if (loc == 1)//头插法
	{
		s->next = L->next;
		L->next = s;
	}
	//a插入位置是循环链表的非第一个节点
	else if (loc == Length)//最后一个位置插入
	{
		while (true)
		{
			//如果循环到达最后一个节点，终止循环
			if (p->next->next == L)
			{
				break;
			}
			p = p->next;
		}
		s->next = p->next;
		p->next = s;	
	}
	else
	{
		loc--;
		while (loc)
		{
			p1 = p1->next;
			loc--;
		}
		s->next = p1->next;
		p1->next = s;
	}
}

//删除循环链表loc位置的元素,并将删除的值赋值给e
Status ListDelete(LinkList &L, ElemType &e, int loc)
{
	if (!L)
	{
		exit(ERROE);
	}
	LinkList  p = L;
	//获取链表的长度
	int Length = ListLength(L);
	if (loc<1 || loc>Length)
	{
		printf("删除元素的位置不存在\n");
		return ERROE;
	}
	//为了找到上游位置，loc值提前减去1
	loc--;
	while (loc)
	{
		p = p->next;
		loc--;
	}
	e = p->next->data;
	p->next = p->next->next;
	return OK;
}

文件3：main.cpp测试主函数

#include<stdio.h>
#include"circular_list.h"

int e;
void print_star()
{
	printf("**********************\n");
}

void test_ListAppend(LinkList &L, ElemType a)
{
	ListAppend(L, a);
	ListAppend(L, 2);
	ListAppend(L, 4);
	ListAppend(L, 8);
	ListAppend(L, 5);
}

void test_ListTraverse(LinkList L)
{
	ListTraverse(L);
}

void test_ClearList(LinkList &L)
{
	ClearList(L);
}

void test_ListEmpty(LinkList L)
{
	int statusCode = ListEmpty(L);
	if (statusCode == 1)
	{
		printf("链表为空\n");
	}
	else
	{
		printf("链表非空\n");
	}
}

void test_ListLength(LinkList L)
{
	int count = ListLength(L);
	printf("链表中含有%d个元素\n", count);
}

void test_GetElem(LinkList L, int loc, ElemType &e)
{
	int statusCode =  GetElem(L, loc, e);
	if (statusCode!=-2)
	{
		printf("获取位置%d得到的值为%d\n", loc, e);
	}
}
void test_LocateElem(LinkList L, ElemType a)
{
	int result = LocateElem(L, a);
	if (result)
	{
		printf("元素%d的位置为%d\n", a, result);
	}
	else
	{
		printf("元素%d在循环链表中不存在！\n", a);
	}
}

void test_PriorElem(LinkList L, ElemType a, ElemType &e)
{
	int result = PriorElem(L, a, e);
	if (result)
	{
		printf("元素%d位置之前的元素值为%d\n", a, e);
	}
}

void test_NextElem(LinkList L, ElemType a, ElemType &e)
{
	int statusCode = NextElem(L, a, e);
	if (statusCode)
	{
		printf("元素%d位置之后的元素值为%d\n", a, e);
	}
}

void test_ListInsert(LinkList &L, ElemType a, int loc)
{
	ListInsert(L, a, loc);
}

void test_ListDelete(LinkList &L, ElemType &e, int loc)
{
	ListDelete(L, e, loc);
}

void main()
{
	//1、初始化循环链表
	print_star();
	LinkList L = NULL;
	InitList(L);
	//2、测试插入元素
	print_star();
	test_ListAppend(L, 3);
	//3、测试打印遍历循环链表的结果
	print_star();
	test_ListTraverse(L);
	//4、测试清空循环链表
	print_star();
	test_ClearList(L);
	test_ListTraverse(L);
	//5、测试链表是否为空
	print_star();
	test_ListEmpty(L);
	test_ListAppend(L, 3);
	test_ListEmpty(L);
	//6、测试链表长度函数
	print_star();
	test_ListLength(L);
	//7、测试获取位置2元素值，并赋值给e
	print_star();
	test_GetElem(L, 3, e);
	//8、测试返回固定元素的位置
	print_star();
	test_LocateElem(L, 8);
	//9、测试返回链表元素a的前一个节点并赋值给e
	print_star();
	test_PriorElem(L, 3, e);
	test_PriorElem(L, 2, e);
	test_PriorElem(L, 4, e);
	test_PriorElem(L, 8, e);
	test_PriorElem(L, 5, e);
	test_NextElem(L, 6, e);
	//10、测试返回链表元素a的后一个节点并赋值给e
	print_star();
	test_NextElem(L, 3, e);
	test_NextElem(L, 2, e);
	test_NextElem(L, 4, e);
	test_NextElem(L, 8, e);
	test_NextElem(L, 5, e);
	test_NextElem(L, 6, e);
	//11、测试按照位置插入元素
	print_star();
	test_ListInsert(L, -3, 1);
	test_ListInsert(L, -2, 1);
	test_ListInsert(L, -1, 1);
	test_ListInsert(L, 10, 5);
	test_ListInsert(L, -10, 6);
	test_ListInsert(L, 11, 3);
	test_ListInsert(L, 19, 19);
	test_ListTraverse(L);
	//12、测试按照位置删除元素
	print_star();
	ListDelete(L, e, 1);
	ListDelete(L, e, 2);
	ListDelete(L, e, 5);
	ListDelete(L, e, 8);
	test_ListTraverse(L);
}

5、运行效果截图

yeler082

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
【2.4】单向循环链表

一、单向循环链表结构特点。1、所有元素依次衔接，尾部元素链接到首元素。2、适用于环形结构处理的场合。3、便于特定步长循环遍历链表元素。二、单向循环链表的基本结构图。上图分别表示不带头结点和带头结点的单向循环链表。3、文件组织方式4、代码实现文件一：circular_list.h单向循环链表的函数定义#ifndef _YE_LELE_01 #define _YE_LELE_01 typede...
复制链接

扫一扫