1,什么叫单向循环链表。单向循环链表是指在单链表的基础上,表的最后一个元素指向链表头结点,不再是为空。

2,由图可知,单向循环链表的判断条件不再是表为空了,而变成了是否到表头。

3,链表的结点表示

1 struct LNode
2 {
3 int data;
4 struct LNode * next;
5 };
6 typedef struct LNode * linklist

4,单向循环链表的操作集合,仍是defs.h里的操作集合,这里就不给出了。

5,单循环链表的初始化操作。示意图

实现:

1 #include"defs.h"
2
3 void InitList(linklist *L) //改变尾指针
4 {
5 *L = (linklist)malloc(sizeof(struct LNode)); //分配头结点
6 if (*L == NULL) //分配失败
7 exit(0);
8 (*L)->next = *L; //指针域指向它本身
9 }

6,清空操作最終图和初始化的结果是一样的。

 1 #include"defs.h"
2
3 void ClearList(linklist *L) //改变尾指针
4 {
5 linklist p, q;
6 *L = (*L)->next; //先令尾指针指向头结点,不然释放最后一个结点时尾指针,无法指向头结点
7 p = (*L)->next; //p指向第一个结点
8
9 while (p != *L) //p未到表头时
10 {
11 q = p->next;
12 free(p);
13 p = q;
14 }
15 *L->next = *L; //头结点指针域指向其本身
16 }

7,DestroyList操作。撤销操作是在清空操作基础上,释放了头结点。

1 #include"defs.h"
2
3 void DestroyList(linklist *L)
4 {
5 ClearList(&L);
6 free(*L); //释放头结点
7 *L = NULL;
8 }

DestroyList.c

8,ListEmpty操作。

1 #include"defs.h"
2
3 int ListEmpty(linklist L)
4 {
5 if (L->next == L) //指针域指向它本身,肯定就是空了,该结点即为头结点
6 return 0;
7 else
8 return 1; //非空为1
9 }

ListEmpty.c

9,ListLength操作

 1 #include"defs.h"
2
3 int ListLength(linklist L)
4 {
5 linklist p = L->next->next; //p指向第一个结点
6 int j = 0;
7
8 while (p != L->next) //p未到表头时
9 {
10 ++j;
11 p = p->next;
12 }
13 return j;
14 }

ListLength.c

10,GetElem操作

 1 #include"defs.h"
2
3 void GetElem(linklist L, int i, int *e)
4 {
5 linklist p = L->next ; //p指向头结点
6 int j = 0;
7 if (i<1 || i>ListLength(L)) //位置不合理
8 exit(0);
9
10 while (j < i) //位置合理,找到第i个结点
11 {
12 ++j;
13 p = p->next;
14 }
15 *e = p->data;
16 }

GetElem.c

11,LocateElem操作

 1 #include"defs.h"
2
3 int LocateElem(linklist L, int e)
4 {
5 linklist p = L->next->next; //p指向链表第一个元素
6 int j = 0;
7
8 while (p != L->next) //p未到表头时
9 {
10 ++j;
11 if (p->data == e)
12 return j;
13 p = p->next;
14 }
15 return -1; //未找到,返回-1
16 }

LocateElem.c

12,PriorElem操作实现

 1 #include"defs.h"
2
3 int PriorElem(linklist L, int cur_e, int *pri_e)
4 {
5 linklist p = L->next->next; //p指向链表第一个元素
6 linklist q;
7
8 while (p != L->next)
9 {
10 q = p->next; //q指向p的后继
11 if (q != L->next && q->data == cur_e)
12 {
13 *pri_e = p->data;
14 return 0;
15 }
16 p = q;
17 }
18 return 0;
19 }

PriorElem.c

13,NextElem操作实现

 1 #include"defs.h"
2
3 int NextElem(linklist L, int cur_e, int *Nex_e) //最后一个元素无后继
4 {
5 linklist p = L->next->next; //p指向第一个结点
6 linklist q;
7
8 while (p != L->next)
9 {
10 q = p->next;
11 if (q != L->next && p->data == cur_e)
12 {
13 *Nex_e = q->data;
14 return 0;
15 }
16 p = q;
17 }
18 return 0;
19 }

NextElem.c

14,ListInsert操作实现

 1 #include"defs.h"
2
3 int ListInsert(Linklist *L, int i, int e) //在表尾插入改变尾指针
4 {
5 linklist p = (*L)->next; //p指向表头
6 linklist q, s;
7 int j = 0;
8
9 if (i<1 || i>ListLength(L)+1) //插入位置不合理
10 exit(0);
11
12 while (j < i-1) //位置合理,找到第i-1个结点
13 {
14 ++j;
15 p = p->next;
16 }
17 q = p->next; //q指向第i个结点
18 s = (linklist)malloc(sizeof(struct LNode));
19 s->data = e;
20 s->next = q;
21 q->next = s;
22 if (p == *L)
23 *L = s;
24 }

15,ListDelete操作实现

 1 #include"defs.h"
2
3 int ListDelete(linklist *L, int i, int *e)
4 {
5 linklist p = (*L)->next;
6 linklist q;
7 int j = 0;
8 if (i<1 || i>ListLength(L))
9 exit(0);
10
11 while (j<i-1) //找到第i-1个结点
12 {
13 ++j;
14 p = p->next;
15 }
16 q = p->next; //q指向第i个结点
17 *e = q->data;
18 p->next = q->next;
19 if (q == *L) //删除的是表尾元素,表尾指针发生改变
20 *L = p;
21 free(q);
22 return 0;
23 }

16,TravelList操作实现

 1 #include"defs.h"
2
3 void TravelList(linklist L)
4 {
5 linklist p = L->next->next; //p指向第一个结点
6 int j = 0;
7
8 while (p != L->next) //p未到表头
9 {
10 ++j;
11 printf("第%d个元素为:%d\n", j, p->data);
12 p = p->next;
13 }
14 }

TravelList.c

c语言实现--单向循环链表操作的更多相关文章

  1. C语言通用双向循环链表操作函数集

    说明 相比Linux内核链表宿主结构可有多个链表结构的优点,本函数集侧重封装性和易用性,而灵活性和效率有所降低.     可基于该函数集方便地构造栈或队列集.     本函数集暂未考虑并发保护. 一  ...

  2. c语言实现--双向循环链表操作

    1,双向链表相当于两个单向循环链表. 2,双向链表的结点定义. 1 struct DULNode 2 { 3 int data; 4 struct DULNode * prior; 5 struct ...

  3. C/C++实现单向循环链表(尾指针,带头尾节点)

    C语言实现单向循环链表,主要功能为空链表创建,链表初始化(头插法,尾插法),链表元素读取,按位置插入,(有序链表)按值插入,按位置删除,按值删除,清空链表,销毁链表. 单向循环链表和单向链表的区别:( ...

  4. 单向循环链表C语言实现

    我们都知道,单向链表最后指向为NULL,也就是为空,那单向循环链表就是不指向为NULL了,指向头节点,所以下面这个程序运行结果就是,你将会看到遍历链表的时候就是一个死循环,因为它不指向为NULL,也是 ...

  5. 复习下C 链表操作(单向循环链表、查找循环节点)

    循环链表 稍复杂点. 肯能会有0 或 6 字型的单向循环链表.  接下来创建 单向循环链表 并 查找单向循环链表中的循环节点. 这里已6字型单向循环链表为例. //创建 循环链表 Student * ...

  6. 基于visual Studio2013解决算法导论之021单向循环链表

     题目 单向循环链表的操作 解决代码及点评 #include <stdio.h> #include <stdlib.h> #include <time.h> ...

  7. Python 单向循环链表

    操作 is_empty() 判断链表是否为空 length() 返回链表的长度 travel() 遍历 add(item) 在头部添加一个节点 append(item) 在尾部添加一个节点 inser ...

  8. python中的单向循环链表实现

    引子 所谓单向循环链表,不过是在单向链表的基础上,如响尾蛇般将其首尾相连,也因此有诸多类似之处与务必留心之点.尤其是可能涉及到头尾节点的操作,不可疏忽. 对于诸多操所必须的遍历,这时的条件是什么?又应 ...

  9. 数据结构与算法-python描述-单向循环链表

    # coding:utf-8 # 单向循环链表的相关操作: # is_empty() 判断链表是否为空 # length() 返回链表的长度 # travel() 遍历 # add(item) 在头部 ...

随机推荐

  1. Token验证的流程及如何准确的判断一个数据的类型

    Token验证的流程: 1,客户端使用用户名跟密码请求登录:2,服务端收到请求,去验证用户名与密码:3,验证成功后,服务端会签发一个 Token,再把这个 Token 发送给客户端:4,客户端收到 T ...

  2. LeetCode374 猜数字大小

    我们正在玩一个猜数字游戏. 游戏规则如下:我从 1 到 n 选择一个数字. 你需要猜我选择了哪个数字.每次你猜错了,我会告诉你这个数字是大了还是小了.你调用一个预先定义好的接口 guess(int n ...

  3. LeetCode 二分查找模板 I

    模板 #1: int binarySearch(vector<int>& nums, int target){ if(nums.size() == 0) return -1; in ...

  4. oracle坚决不挂2(SQLPLUS基础命令)

    继续复习!!SQLplus基础命令,其实这个应该是第一个要复习的.因为基础,你懂得..要想学会跑,你先得知道该怎么走吧. win+R 输入cmd ,我们开始启动SQLplus sqlplus user ...

  5. 简单解析一下 Mybatis 常用的几个配置

    目录 核心配置文件 环境配置(environments) 属性(properties) 类型别名(typeAliases) 映射器(mappers) Mybatis 参考:https://mybati ...

  6. Oracle 索引原理分析

    索引是一种允许直接访问数据表中某一数据行的树型结构,为了提高查询效率而引入,是一个独立于表的对象,可以存放在与表不同的表空间中.索引记录中存有索引关键字和指向表中数据的指针(地址).对索引进行的I/O ...

  7. pandas 写csv 操作

    pandas 写csv 操作 def show_history(self): df = pd.DataFrame() df['Time'] = pd.Series(self.time_hist) df ...

  8. ctfhub技能树—web前置技能—http协议—基础认证

    打开靶机环境 下载附件后发现是常用密码字典,于是考虑本题可能是考察密码爆破 打开环境 发现需要认证,于是考虑使用暴力破解 使用burpsuite抓包,查看 发现最下面一行有加密后的密文 使用base6 ...

  9. 提示框,对话框,路由跳转页面,跑马灯,幻灯片及list组件的应用

    目录: 主页面的js业务逻辑层 主页面视图层 主页面css属性设置 跳转页面一的js业务逻辑层 跳转页面一的视图层 跳转页面二的视图层 跳转页面三的js业务逻辑层 跳转页面三的视图层 跳转页面三的cs ...

  10. vscode远程开发安装

    https://www.cnblogs.com/xiaoqi/p/vs-code-remote.html ============================= https://blog.csdn ...