一、单向循环链表结构特点。
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、运行效果截图