C语言实现单向循环链表

已于 2024-01-13 19:37:40 修改
阅读量554 收藏 7
点赞数 8
文章标签： c语言 链表 windows
于 2024-01-13 14:41:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_71299382/article/details/135570052
版权

1.C语言实现

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
// 定义一个节点类
typedef struct Node {
	int data;// 数据域
	struct Node* next;// 指针域
}Node;
// 定义初始化链表方法
Node* initList() {
	Node* list = (Node*)malloc(sizeof(Node));
	list->data = 0;// 虚拟头节点的数据域储存的是链表的长度
	list->next = list;// 虚拟头节点自己指向自己
	return list;
}
// 定义头插方法
void headInsert(int data, Node* list) {
	Node* newHead = (Node*)malloc(sizeof(Node));
	newHead->data = data;
	newHead->next = list->next;
	list->next = newHead;
	// 更新链表长度
	list->data++;
}
// 定义尾插方法
void tailInsert(int data, Node* list) {
	Node* node = (Node*)malloc(sizeof(Node));
	// 寻找链表的尾节点
	Node* tail = list;
	while (tail->next != list) {
		tail = tail->next;
	}
	node->data = data;
	node->next = list;
	tail->next = node;
	// 更新链表长度
	list->data++;
}
// 定义删除方法
bool delete(int data, Node* list) {
	Node* pre = list;
	Node* cur = list->next;
	while (cur != list) {
		if (cur->data == data) {
			pre->next = cur->next;
			free(cur);
			// 更新链表长度
			list->data--;
			// 通过返回值true标识找到了第一个符合条件的节点 标识删除成功
			return true;
		}
		pre = cur;
		cur = cur->next;
	}
	// 如果遍历了整个链表都没有找到指定值对应的节点的话 那么就说明删除失败
	return false;
}
// 定义打印方法
void printList(Node* list) {
	Node* cur = list->next;
	// 他有别于单向链表的打印方法 是因为如果你条件设置为当非空的时候停止循环的话 那么他永远都无法停止循环 而是陷入了死循环 所以你得设置为当下一个节点为虚拟头节点的时候停止循环才行
	while (cur != list) {
		printf("%d ", cur->data);
		cur = cur->next;
	}
	printf("\n");
}
// 定义一个主函数
int main() {
	Node* list = initList();
	headInsert(1, list);
	headInsert(2, list);
	headInsert(3, list);
	headInsert(4, list);
	tailInsert(5, list);
	printList(list);// 4 3 2 1 5
	if (delete(4, list) == true) {
		printf("删除成功\n");
	}
	else {
		printf("删除失败\n");
	}
	printList(list);// 3 2 1 5
	printf("%d\n", list->data);// 4
	return 0;
}

测试结果来看 这个链表是经得住考验的

2.mj版本的单向循环链表

我的设计理念是引入一个虚拟头节点来储存链表的长度 并且尾节点的下一节点指向的是实际的头节点 也就是虚拟头节点的下一个节点
其中有两种特殊情况
在添加操作中 当我们要对空链表进行添加的时候 需要考虑到待插入节点的下一节点并非前驱节点的后继节点 而是自己
在删除操作中 当我们执行完删除操作以后链表为空 需要考虑到待删除节点的前驱节点的下一节点并非待删除节点的后继节点 而是自己

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#define ELEMENT_NOT_FOUND -1
// 节点类
typedef struct Node {
	// 数据域
	int data;
	// 指针域
	struct Node* next;
}Node;
// 定义一个方法 用于初始化链表
Node* initList() {
	Node* list = (Node*)malloc(sizeof(Node));
	list->data = 0;
	list->next = list;
	return list;
}
// 定义索引越界方法
void outOfBounds(int index) {
	printf("索引为%d 索引越界了", index);
}
// 定义边界检查方法
void rangeCheck(int index, Node* list) {
	if (index < 0 || index >= list->data)
		outOfBounds(index);
}
// 定义针对添加方法边界检查方法
void rangeCheckForAdd(int index, Node* list) {
	if (index < 0 || index > list->data)
		outOfBounds(index);
}
// 定义根据指定索引查找节点的方法
Node* node(int index, Node* list) {
	rangeCheck(index, list);
	Node* cur = list->next;
	for (int i = 0; i < index; ++i) {
		cur = cur->next;
	}
	return cur;
}
// 定义添加方法
void add(int index, int data, Node* list) {
	// 对参数索引进行边界检查
	rangeCheckForAdd(index, list);
	Node* pre = index == 0 ? list : node(index - 1, list);
	Node* node = (Node*)malloc(sizeof(Node));
	node->data = data;
	if (list->data == 0) {
		node->next = node;
	}
	else {
		node->next = pre->next;
	}
	pre->next = node;
	list->data++;
}
// 定义删除方法
int delete(int index, Node* list) {
	// 对参数索引进行边界检查
	rangeCheck(index, list);
	Node* pre = index == 0 ? list : node(index - 1, list);
	Node* delete = pre->next;
	if (list->data == 1) {
		pre->next = pre;
	}
	else {
		pre->next = delete->next;
	}
	// 更新链表长度
	list->data--;
	// 返回待删除节点值
	return delete->data;
}
// 定义一个根据指定节点值获取位置的方法
int indexOf(int data, Node* list) {
	Node* cur = list->next;
	for (int i = 0; i < list->data; ++i) {
		if (cur->data == data)return i;
		cur = cur->next;
	}
	return ELEMENT_NOT_FOUND;
}
// 定义一个方法 用于根据指定索引获取指定的节点值
int get(int index, Node* list) {
	// 由于node方法中有对参数索引进行边界检查 所以无需额外的边界检查操作了
	return node(index, list)->data;
}
// 定义一个方法 用于重置指定位置处的节点值 并且返回指定位置处的旧值
int set(int index, int newData, Node* list) {
	// 由于node方法已经存在了对参数索引的边界检查 所以无需额外的进行边界检查操作了
	int data = node(index, list)->data;
	node(index, list)->data = newData;
	return data;
}
// 定义一个方法 用于清空链表
void clear(Node* list) {
	Node* cur = list->next;
	Node* next = cur->next;
	while (cur != list->next) {
		free(cur);
		cur = next;
		next = cur->next;
	}
	list->data = 0;
}
// 定义一个方法 用于判断链表中是否包含指定节点值
bool contains(int data, Node* list) {
	return indexOf(data, list) != ELEMENT_NOT_FOUND;
}
// 定义一个方法 用于判断链表是否为空
bool isEmpty(Node* list) {
	return list->data == 0;
}
// 定义一个方法 用于获取链表长度
int size(Node* list) {
	return list->data;
}
// 定义一个方法 用于打印链表
void printList(Node* list) {
	Node* cur = list->next;
	for (int i = 0; i < list->data; ++i) {
		printf("%d ", cur->data);
		cur = cur->next;
	}
	printf("\n");
}
// 定义一个主函数
int main() {
	Node* list = initList();
	add(0, 1, list);
	add(0, 2, list);
	add(0, 3, list);
	add(0, 4, list);
	add(size(list), 5, list);
	printList(list);// 4 3 2 1 5
	printf("%d\n", delete(4, list));// 5
	printList(list);// 4 3 2 1
	printf("%d\n", list->data);// 4
	clear(list);
	printf("%d\n", list->data);// 0
	return 0;
}

3.mj版本的单向循环链表(没有虚拟头节点)

值得注意的是：不允许存在同名的变量和函数 特别是其中size和size()
然后我们是将原来虚拟头节点中的链表长度和修改为全局变量 并且引入了全局变量来标识头节点

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#define ELEMENT_NOT_FOUND -1
// 定义一个节点类
typedef struct Node {
	// 数据域
	int data;
	// 指针域
	struct Node* next;
}Node;
// 定义一个变量 用于标识头节点
Node* head = NULL;
// 定义一个变量  用于表示链表的长度
int size = 0;
// 定义一个方法 用于初始化链表
Node* initList() {
	Node* list = NULL;
	return list;
}
// 定义一个方法 用于判断索引是否越界
void outOfBounds(int index) {
	printf("索引为:%d 索引越界了", index);
}
// 定义一个方法 用于进行边界检查
void rangeCheck(int index) {
	if (index < 0 || index >= size)
		outOfBounds(index);
}
// 定义一个方法 用于针对添加方法进行边界检查
void rangeCheckForAdd(int index) {
	if (index < 0 || index > size)
		outOfBounds(index);
}
// 定义一个方法 用于根据指定索引获取节点
Node* node(int index) {
	// 对参数索引进行边界检查
	rangeCheck(index);
	Node* cur = head;
	for (int i = 0; i < index; ++i) {
		cur = cur->next;
	}
	return cur;
}
// 定义一个添加方法
/*
	总体逻辑就是分成两种情况 一种是头部插入 一种是其他位置插入 
	对于头部插入的话 我们又可以分成两种情况 一种是对空链表进行插入 一种是普通的插入 由于两种情况的代码量是差不多的 所以推荐进行代码复用
*/
void add(int index, int data) {
	// 对参数索引进行边界检查
	rangeCheckForAdd(index);
	if (index == 0) {
		/*
			普通情况的逻辑就是保存新的头节点 然后将该头节点指向旧的头节点 然后让尾节点指向新的头节点
			但是特殊情况的逻辑就是
		*/
		Node* newHead = (Node*)malloc(sizeof(Node));
		newHead->next = head;
		newHead->data = data;
		// 获取尾节点 获取尾节点的时候 对于特殊情况 如果通过node(size - 1)的话 是无法获取到预期节点的 所以需要进行特殊处理
		Node* tail = size == 0 ? newHead : node(size - 1);
		tail->next = newHead;
		head = newHead;
	}
	else {
		// 获取待插入节点的前驱节点
		Node* pre = node(index - 1);
		// 让待插入节点指向前驱节点的后继节点
		Node* node = (Node*)malloc(sizeof(Node));
		node->data = data;
		node->next = pre->next;
		pre->next = node;
	}
	// 不管上述执行的是哪一种情况 都需要更新链表长度
	size++;
}
// 定义删除方法
int delete(int index) {
	// 对参数索引进行边界检查
	rangeCheck(index);
	// 定义一个变量 用于保存待删除节点
	Node* delete = head;
	// 接着分成两种情况进行讨论 一种是头删 一种是其他位置删除
	if (index == 0) {
		// 还需要分成两种情况进行讨论 一种是删除之后链表长度为空 一种是普通情况 由于两种情况的代码量悬殊很大 所以选择进行分类讨论 而不是进行代码复用
		if (size == 1) {
			head = NULL;
		}
		else {
			// 这种情况的总体逻辑就是要更新头节点的标识 而且还需要更新尾节点的下一节点
			head = head->next;
			Node* tail = node(size - 1);
			tail->next = head;
		}
	}
	else {
		// 获取待删除节点的前驱节点
		Node* pre = node(index - 1);
		delete = pre->next;
		pre->next = delete->next;
	}
	// 不管执行的是哪一种情况的话 那么就需要更新链表长度
	size--;
	// 返回待删除节点
	return delete->data;
}
// 定义一个方法 用于指定节点值获取指定位置
int indexOf(int data) {
	Node* cur = head;
	for (int i = 0; i < size; ++i) {
		if (cur->data == data) {
			return i;
		}
		cur = cur->next;
	}
	// 如果上述代码没有返回值的话 那么说明在链表中不存在指定节点值的节点
	return ELEMENT_NOT_FOUND;
}
// 定义一个方法 用于根据指定索引获取节点
int get(int index) {
	return node(index)->data;
}
// 定义一个方法 用于重置指定索引处的节点值
int set(int index, int newData) {
	int data = node(index)->data;
	node(index)->data = newData;
	return data;
}
// 定义一个方法 用于清空
void clear() {
	Node* cur = head;
	Node* next;
	for (int i = 0; i < size; ++i) {
		next = cur->next;
		free(cur);
		cur = next;
	}
	// 清空链表以后 链表长度为0
	size = 0;
}
// 定义一个方法 用于判断是否包含指定节点值
bool contains(int data) {
	return indexOf(data) != ELEMENT_NOT_FOUND;
}
// 定义一个方法 用于判断链表是否为空
bool isEmpty() {
	return size == 0;
}
// 定义一个方法 用于获取链表长度
int getSize() {
	return size;
}
// 定义一个方法 用于打印链表
void printList() {
	Node* cur = head;
	for (int i = 0; i < size; ++i) {
		printf("%d ", cur->data);
		cur = cur->next;
	}
	printf("\n");
}
int main() {
	Node* list = initList();
	add(0, 1);
	add(0, 2);
	add(0, 3);
	add(0, 4);
	add(getSize(), 5);
	printList();// 4 3 2 1 5
	printf("%d\n", get(0));// 4
	printf("%d\n", set(0, 6));// 4
	printf("%d\n", delete(0));// 6
	printList();// 3 2 1 5
	clear();
	printf("%d\n", getSize());// 0
	return 0;
}
axihaihai
关注
  • 8
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
链表的实现
如月之恒，如日之升
07-26 395
第一次画图画累了
【数据结构-C语言】单向链表，循环单向链表
最新发布
sakura0908的博客
03-02 2353
顺序表：顺序存储的线性表 链式表：链式存储的线性表，简称链表 由于顺序表的缺点（数据连续存储），顺序存储的数据因为挤在一起而导致需要成片移动，那很容易想到的解决方案是将数据离散地存储在不同内存块中，然后再用指针将他们串起来，这种朴素的思路所形成的链式线性表，就是所谓的链表。顺序表和链表存在的基本样态如下图所示
数据结构之循环单链表（C语言附完整代码）
m0_62795460的博客
11-09 6693
循环单链表是单链表的另一种形式，其结构特点链表中最后一个结点的指针域不再是结束标记，而是指向整个链表的第一个结点，从而使链表形成一个环。示意图：声明循环单链表typedef struct LNode //定义单链表结点类型 {注意：本文章讨论的循环单链表是带头结点的循环单链表。增加头结点的优点如下：1.循环单链表中首结点的插入和删除操作与其他结点一致，无需进行特殊处理。2.无论循环单链表是否为空都有一个头结点，因此统一了空表和非空表的处理过程。
C语言：数据结构-单向循环链表
JCapezy的博客
02-24 274
C语言：数据结构-循环单链表
C语言数据结构篇——单循环链表的创建，插入，节点删除，打印等操作
Demo不是emo的博客
02-08 1万+
初识循环链表
c语言实现单向循环链表
09-01
c语言实现单向循环链表
C语言单循环链表的表示与实现实例详解
01-20
用单向链表构建的循环链表 循环链表中第一个节点之前就是最后一个节点，反之亦然。循环链表的无边界使得在这样的链表上设计算法会比普通链表更加容易。对于新加入的节点应该是在第一个节点之前还是最后一个节点之后...
C语言单向链表的表示与实现实例详解
09-04
"C语言单向链表的表示与实现实例详解" C语言单向链表是一种链表结构，它的特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始。链表中最简单的一种是单向链表，它包含两个域，一个信息域和一个...
用单向循环链表模拟约瑟夫环
04-16
用C语言编写的约瑟夫环问题解决程序，利用单向循环链表存储结构模拟此过程
C封装单向循环链表对象1
08-04
在C语言中实现单向循环链表，通常会包含以下几个核心部分： 1. **节点定义**：链表中的每个元素称为节点，它包含一个数据域（存储数据）和一个指针域（指向下一个节点）。 2. **链表结构体**：定义一个结构体来...
循环单链表的简单实现（C语言）
文溪山人的博客
03-21 3824
循环单链表的简单实现（C语言）
（C语言版）链表（二）——实现单向循环链表创建、插入、删除、释放内存等简单操作
热门推荐
菜鸟学C/C++
02-23 2万+
昨天写了单向链表的代码，今天上午把单向循环链表的程序给敲完了。链表的相关操作一样的，包含链表的创建、判断链表是否为空、计算链表长度、向链表中插入节点、从链表中删除节点、删除整个链表释放内存。如果单向链表理解了，那单向循环链表也就不难了。 单向循环链表如下图所示： 看图可以知道，单向循环链表和单向链表差不多，只不过是最后的尾节点指向的不是空，而是指向头节点。理解这一点很重要，因为这是我们
C语言实现单向（循环）链表的创建和遍历
lightingfuture的博客
08-24 8315
本代码在QT控制台环境下测试通过，如果在其他IDE下，注意修改包含的打印头文件即可。 include include include /* *2018-08-24 13:23:03 * 单向链表测试 * 包括循环链表的实现 */ using namespace std; typedef struct Node{ struct Node *next; ...
单向循环链表C语言实现
weixin_33908217的博客
06-27 672
我们都知道，单向链表最后指向为NULL，也就是为空，那单向循环链表就是不指向为NULL了，指向头节点，所以下面这个程序运行结果就是，你将会看到遍历链表的时候就是一个死循环，因为它不指向为NULL，也是周而复始的执行。串成了一个环型。 #include <stdio.h> #include <stdlib.h> typ...
运用C语言建立循环单链表？
LOVE_Me__的博客
09-20 2911
#include&lt;stdio.h&gt; #include&lt;malloc.h&gt; typedef char ElemType; typedef struct LNode { ElemType data; struct LNode *next; }DLinkList; //首先对基本函数进行声明，以及后面方面在主函数中进行调用 void InitList(DLinkL...
循环链表c语言csdn,c语言实现单向循环链表
weixin_32821263的博客
05-20 97
//单循环链表, 在单链表的基础上, 每创建一个节点,让其后继默认指向head//最终保证最后一个节点的后继指向Head则构成单循环链表//不带头节点判空: head == NULL//带头节点判空: head->next == head; 为空//与单链表代码的区别: 每次循环的跳出条件改变,尾插发生改变//只要程序中插入节点是头节点, 则必须更新尾节点的指向//删除头节点, 更新尾节点...
循环单链表的实现c语言
better_xiong的博客
06-21 1732
1.循环单链表和单链表的区别在于链表中最后一个结点的指针不是指向NULL，而是指向头结点，这样链表结点就形成了一个环。循环单链表是一个环，所以在链表中任意位置插入或者删除结点时都是等价的，不需要根据所操作结点是否是尾结点分类讨论，因此简化了代码。 2.下面是循环单链表的具体操作详细代码，由c语言实现。 #include<stdio.h> #include<malloc.h> #define ElemType int typedef struct LinkNode{ ElemTy
0x00数据结构——C语言实现（单向循环链表）
czw
04-23 388
0x00数据结构——C语言实现（单向循环链表） /*filename:circular_list.h*/ /* 循环链表(circular list)是另一种形式的表示线性表的链表，与单链表不同的是， 表尾结点的link域中不是NULL而是存放指向链表开始结点的指针。 Functions: 创建一个空线性表 计算表长度 返回附加头结点的地址 搜索函数：...
C语言编写一个单向循环链表
03-01
我可以给您一些建议去编写一个单向循环链表：1. 定义一个结构体，其中包含一个指向下一个节点的指针以及相关的数据；2. 创建一个指向首节点的指针；3. 创建一个新的节点，为其分配内存；4. 为新节点赋值；5. 将当前...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

axihaihai

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

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

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

打赏作者

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

抵扣说明：

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

余额充值