数据结构与算法之线性表单向循环链表
在上一篇《数据结构与算法之基础篇》中，了解了
算法和数据结构的一些概念问题，以及线性表顺序存储和单链表的创建、插入、删除等一些操作。这一篇来了解一下线性表单向循环链表的一些操作。
1. 单向循环链表概念
1.1 单向循环链表
是单链表的一个变形，链表中最后一个节点的next域不再为None，而是指向链表的头节点。
1.2 链表结构和顺序存储的优缺点：
存储分配方式
- 顺序存储结构用一段连续的存储单元依次存储线性表的数据元素;
- 单链表采用链式存储结构,⽤用⼀一组任意的存储单元存放线性表的元素
时间性能
- 查找
顺序存储 O(1)
单链表O(n)
- 插入和删除
存储结构需要平均移动一个表长一半的元素,时间O(n)
单链表查找某位置后的指针后,插⼊和删除为 O(1)
空间性能
- 顺序存储结构需要预先分配存储空间,分太⼤大,浪费空间;分⼩小了了,发⽣生上溢出;
- 单链表不不需要分配存储空间,只要有就可以分配, 元素个数也不不受限制;
2. 单向循环链表的操作
准备工作：定义相关变量
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define OK 1
#define MAXSIZE 20 /* 存储空间初始分配量 */
typedef int Status;/* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int ElemType;/* ElemType类型根据实际情况而定，这里假设为int */
//定义结点
typedef struct Node{
ElemType data;
struct Node *next;
}Node;
typedef struct Node * LinkList;
2.1. 单向循环链表的创建
单向循环链表的创建分为2种情况:
- 第一次开始创建;
- 已经创建,往里面新增数据
判断是否第一次创建链表
YES: 创建一个新结点，并使得新结点的next指向自身，(*L)->next = (*L);NO: 找链表尾结点，将尾结点的next = 新结点，新结点的next = (*L);
而链表找尾，可以有两种写法，一种为for循环，一种为定义一个变量记录。
创建代码示例：
// for循环找尾
Status CreateList(LinkList *L){
int item;
LinkList temp = NULL;
LinkList target = NULL;
printf("输入节点的值，输入0结束\n");
while(1)
{
scanf("%d",&item);
if(item==0) break;
//如果输入的链表是空。则创建一个新的节点，使其next指针指向自己 (*head)->next=*head;
if(*L==NULL)
{
*L = (LinkList)malloc(sizeof(Node));
if(!L)exit(0);
(*L)->data=item;
(*L)->next=*L;
}
else
{
//输入的链表不是空的，寻找链表的尾节点(for循环找尾)，使尾节点的next=新节点。新节点的next指向头节点
for (target = *L; target->next != *L; target = target->next);
temp=(LinkList)malloc(sizeof(Node));
if(!temp) return ERROR;
temp->data=item;
temp->next=*L; //新节点指向头节点
target->next=temp;//尾节点指向新节点
}
}
return OK;
}
// 定义变量 r, 记录尾
Status CreateList2(LinkList *L){
int item;
LinkList temp = NULL;
LinkList target = NULL;
LinkList r = NULL;
printf("请输入新的结点, 当输入0时结束!\n");
while (1) {
scanf("%d",&item);
if (item == 0) {
break;
}
//第一次创建
if(*L == NULL){
*L = (LinkList)malloc(sizeof(Node));
if(!*L) return ERROR;
(*L)->data = item;
(*L)->next = *L;
r = *L;
}else{
temp = (LinkList)malloc(sizeof(Node));
if(!temp) return ERROR;
temp->data = item;
temp->next = *L;
r->next = temp;
// 记录尾
r = temp;
}
}
return OK;
}
2.2. 单向循环链表的遍历
头节点就有值，可以用do...while
void traverseLinkList(LinkList p)
{
//如果链表是空
if(p == NULL){
printf("打印的链表为空!\n");
return;
}else{
LinkList temp;
temp = p;
do{
printf("%3d",temp->data);
temp = temp->next;
}while (temp != p);
printf("\n");
}
}
2.3. 单向循环链表的插入
单向循环列表的插入分为两种情况：
- 插入位置在首元节点（特殊处理）
- 创建
新节点temp，并判断是否创建成功，成功则赋值 - 找到链接最后的尾结点，即找尾。
- 将
新节点temp的next->头结点 尾结点的next指向新的头结点- 让头指针指向
temp(临时的新结点)
- 创建
2. 插入位置在其他位置
* 创建新节点temp，并判断是否创建成功，成功则赋值
* 找到插入的位置，如果超过链表长度,则自动插入队尾
* 通过target找到要插入位置的前一个结点(即插入结点的前驱), 让target->next = temp，
* 插入结点的前驱的next指向新结点,新结点的next 指向target原来的next位置
//4.3 循环链表插入数据
Status ListInsert(LinkList *L, int place, int num){
LinkList temp ,target;
int i;
if (place == 1) { //如果插入的位置为1, 特殊处理
//1. 创建新结点temp,并判断是否创建成功,成功则赋值,否则返回ERROR;
temp = (LinkList)malloc(sizeof(Node));
if (temp == NULL) {
return ERROR;
}
temp->data = num;
//2. 找到链表最后的结点_尾结点,
for (target = *L; target->next != *L; target = target->next);
//3. 让新结点的next 指向头结点.
temp->next = *L;
//4. 尾结点的next 指向新的头结点;
target->next = temp;
//5. 让头指针指向temp(临时的新结点)
*L = temp;
}else { //如果插入的位置在其他位置;
//1. 创建新结点temp,并判断是否创建成功,成功则赋值,否则返回ERROR;
temp = (LinkList)malloc(sizeof(Node));
if (temp == NULL) {
return ERROR;
}
temp->data = num;
//2. 先找到插入的位置,如果超过链表长度,则自动插入队尾;
for ( i = 1,target = *L; target->next != *L && i != place - 1; target = target->next,i++) ;
//3. 新结点的next 指向target原来的next位置;
temp->next = target->next;
//4. 通过target找到要插入位置的前一个结点, 让target->next = temp;
target->next = temp;
}
return OK;
}
2.4. 单向循环链表的删除
单向循环列表的插入分为两种情况：
-
删除第一个位置
-
删除到只剩下首元结点了,则直接将
*L链表置空 -
链表还有很多数据,但是删除的是首结点
-
找到
尾结点 target, 使得尾结点 next指向头结点的下一个结点，即target->next = (*L)->next; -
新结点做为头结点，释放原来的头结点
-
-
-
删除其他位置
- 找到删除结点前一个结点
target - 定义变量
temp，记录删除的节点，即：temp = target->next - 使得
target->next指向删除位置的下一个结点 - 释放需要删除的结点temp
- 找到删除结点前一个结点
Status LinkListDelete(LinkList *L,int place){
LinkList temp,target;
int i;
//temp 指向链表首元结点
temp = *L;
if(temp == NULL) return ERROR;
if (place == 1) {
//1>.如果删除到只剩下首元结点了,则直接将*L置空;
if((*L)->next == (*L)){
(*L) = NULL;
return OK;
}
//2>.链表还有很多数据,但是删除的是首结点;
//1. 找到尾结点, 使得尾结点 next 指向头结点的下一个结点 target->next = (*L)->next;
for (target = *L; target->next != *L; target = target->next);
// 记录头结点
temp = *L;
//2. 新结点做为头结点,则释放原来的头结点
*L = (*L)->next;
target->next = *L;
free(temp);
}else { //如果删除其他结点--其他结点
//1. 找到删除结点前一个结点target
for(i=1,target = *L;target->next != *L && i != place -1;target = target->next,i++) ;
// 记录要删除的节点
temp = target->next;
// 使得删除节点的前驱target->next 指向删除节点的后继
target->next = temp->next;
//3. 释放需要删除的结点temp
free(temp);
}
return OK;
}
2.5. 单向循环链表的简单查询
int findValue(LinkList L,int value){
int i = 1;
LinkList p;
p = L;
//寻找链表中的结点 data == value
while (p->data != value && p->next != L) {
i++;
p = p->next;
}
//当尾结点指向头结点就会直接跳出循环,所以要额外增加一次判断尾结点的data == value;
if (p->next == L && p->data != value) {
return -1;
}
return i;
}
