C/C++实现单向循环链表(尾指针，带头尾节点)
C语言实现单向循环链表，主要功能为空链表创建，链表初始化（头插法，尾插法），链表元素读取，按位置插入，（有序链表）按值插入，按位置删除，按值删除，清空链表，销毁链表。
单向循环链表和单向链表的区别：（1）单向链表为头指针，循环链表为尾指针，头指针指向头结点，尾指针指向终端结点；（2）为统一方便操作，单向链表设置头结点，单向循环链表设置头结点和尾结点；（3）设置尾结点后，尾指针指向尾结点，插入，删除等操作不用移动尾指针。
关键思路：创建头结点和尾结点。
#include <stdio.h>
#include <stdlib.h> typedef struct Node{
int data;
struct Node *next;
}Node; //空循环链表创建
//创建头结点和尾结点
//链表尾指针指向尾结点，尾结点指向头结点，头结点指向尾结点
void iniCList(Node **CListTail){
*CListTail = (Node *)malloc(sizeof(Node));
Node *CListHead = (Node *)malloc(sizeof(Node));
if (NULL == *CListTail || NULL == CListHead){
exit();
} (*CListTail)->next = CListHead;
CListHead->next = *CListTail;
} //循环链表初始化(头插法)
void iniCListHead(Node **CListTail, int n){
//创建头尾结点
*CListTail = (Node *)malloc(sizeof(Node));
Node *CListHead = (Node *)malloc(sizeof(Node));
if (NULL == *CListTail || NULL == CListHead){
exit();
} (*CListTail)->next = CListHead;
CListHead->next = *CListTail; int i = ;
while (i < n){ Node *tmpNode = (Node *)malloc(sizeof(Node));
if (NULL == tmpNode){
exit();
}
tmpNode->data = i;
tmpNode->next = CListHead->next;
CListHead->next = tmpNode;
++i;
}
} //循环链表初始化(尾插法)
void iniCListTail(Node **CListTail, int n){
//创建头尾结点
*CListTail = (Node *)malloc(sizeof(Node));
Node *CListHead = (Node *)malloc(sizeof(Node));
if (NULL == *CListTail || NULL == CListHead){
exit();
} (*CListTail)->next = CListHead;
CListHead->next = *CListTail; Node *pCurrent = CListHead; int i = ;
while (i < n){
Node *tmpNode = (Node *)malloc(sizeof(Node));
if (NULL == tmpNode){
exit();
}
tmpNode->data = i;
tmpNode->next = *CListTail;
pCurrent->next = tmpNode;
pCurrent = tmpNode; ++i;
}
} //循环链表按位置插入
void insertCListPos(Node *CList, int pos, int val){ Node *pCurrent = CList->next; //指向头结点
int i = ;
while (pCurrent != CList && i < pos){
pCurrent = pCurrent->next;
++i;
} Node *tmpNode = (Node *)malloc(sizeof(Node));
if (NULL == tmpNode){
exit();
}
tmpNode->data = val;
tmpNode->next = pCurrent->next;
pCurrent->next = tmpNode; } //有序循环链表，按值插入
void insertCListValue(Node *CList, int val){
Node *pCur = CList->next->next;
Node *pPer = CList->next; while (pCur != CList && pCur->data < val){
pPer = pCur;
pCur = pCur->next;
} Node *tmpNode = (Node *)malloc(sizeof(Node));
if (NULL == tmpNode){
exit();
}
tmpNode->data = val;
tmpNode->next = pPer->next;
pPer->next = tmpNode;
} //循环链表，按位置删除
void deleteCListPos(Node *CList, int pos){
Node *pCur = CList->next; int i = ;
while (pCur != CList && i < pos){
pCur = pCur->next;
++i;
} Node *tmpNode = pCur->next;
pCur->next = tmpNode->next;
free(tmpNode);
} //循环链表，按值删除
//删除空链表为出问题
void deleteCListValue(Node *CList, int val){
Node *pCur = CList->next->next;
Node *pPer = CList->next; while (pCur != CList && pCur->data != val){
pPer = pCur;
pCur = pCur->next;
}
if (pCur == CList)
return;
else{
pPer->next = pCur->next;
free(pCur);
}
} //循环链表，清空链表
void claerCList(Node *CList){
Node *p = CList->next->next;
Node *q = NULL; while (p != CList){ //到达表尾
q = p->next;
free(p);
p = q;
} CList->next = CList; //将头结点指向尾结点
} //循环链表，销毁链表
void destoryCList(Node **CList){
Node *p = (*CList)->next;
Node *q = NULL; while (p != (*CList)->next){ //到达表头
q = p->next;
free(p);
p = q;
} *CList = NULL;
} //获取元素
void getCList(Node *CList, int pos, int *val){
Node *pCur = CList->next->next;
int i = ;
while (pCur != CList && i < pos){
pCur = pCur->next;
++i;
} *val = pCur->data;
}
//遍历输出元素
void printCList(Node *CList){
Node * tmpNode = CList->next->next;
while (tmpNode != CList){ //到达表尾
printf("%d\n", tmpNode->data);
tmpNode = tmpNode->next;
}
} int main(){
Node *CList = NULL;
//iniCListHead(&CList, 8);
//iniCList(&CList);
iniCListTail(&CList, ); //insertCListPos(CList, 1, 2);
//insertCListPos(CList, 2, 4);
//insertCListPos(CList, 3, 6);
//
//insertCListValue(CList, 1);
//
//deleteCListPos(CList, 3);
//
//deleteCListValue(CList, 6); //claerCList(CList); int a = ;
getCList(CList, , &a);
printf("%d\n", a); printCList(CList); printf("%d\n", CList);
destoryCList(&CList);
printf("%d\n", CList); system("pause");
return ;
}
C语言完整代码
通过C++实现C语言的链表，主要区别：（1）struct可以不通过typedef，直接使用Node；（2）将malloc和free更换为new和delete
#include <stdio.h>
#include <stdlib.h> struct Node{
int data;
struct Node *next;
}; //空循环链表创建
//创建头结点和尾结点
//链表尾指针指向尾结点，尾结点指向头结点，头结点指向尾结点
void iniCList(Node **CListTail){
*CListTail = new Node;
Node *CListHead = new Node; (*CListTail)->next = CListHead;
CListHead->next = *CListTail;
} //循环链表初始化(头插法)
void iniCListHead(Node **CListTail, int n){
//创建头尾结点
*CListTail = new Node;
Node *CListHead = new Node; (*CListTail)->next = CListHead;
CListHead->next = *CListTail; int i = ;
while (i < n){
Node *tmpNode = new Node; tmpNode->data = i;
tmpNode->next = CListHead->next;
CListHead->next = tmpNode;
++i;
}
} //循环链表初始化(尾插法)
void iniCListTail(Node **CListTail, int n){
//创建头尾结点
*CListTail = new Node;
Node *CListHead = new Node; (*CListTail)->next = CListHead;
CListHead->next = *CListTail; Node *pCurrent = CListHead; int i = ;
while (i < n){
Node *tmpNode = new Node; tmpNode->data = i;
tmpNode->next = *CListTail;
pCurrent->next = tmpNode;
pCurrent = tmpNode; ++i;
}
} //循环链表按位置插入
void insertCListPos(Node *CList, int pos, int val){ Node *pCurrent = CList->next; //指向头结点
int i = ;
while (pCurrent != CList && i < pos){
pCurrent = pCurrent->next;
++i;
} Node *tmpNode = new Node; tmpNode->data = val;
tmpNode->next = pCurrent->next;
pCurrent->next = tmpNode; } //有序循环链表，按值插入
void insertCListValue(Node *CList, int val){
Node *pCur = CList->next->next;
Node *pPer = CList->next; while (pCur != CList && pCur->data < val){
pPer = pCur;
pCur = pCur->next;
} Node *tmpNode = new Node; tmpNode->data = val;
tmpNode->next = pPer->next;
pPer->next = tmpNode;
} //循环链表，按位置删除
void deleteCListPos(Node *CList, int pos){
Node *pCur = CList->next; int i = ;
while (pCur != CList && i < pos){
pCur = pCur->next;
++i;
} Node *tmpNode = pCur->next;
pCur->next = tmpNode->next;
delete tmpNode;
} //循环链表，按值删除
//删除空链表为出问题
void deleteCListValue(Node *CList, int val){
Node *pCur = CList->next->next;
Node *pPer = CList->next; while (pCur != CList && pCur->data != val){
pPer = pCur;
pCur = pCur->next;
}
if (pCur == CList)
return;
else{
pPer->next = pCur->next;
delete pCur;
}
} //循环链表，清空链表
void claerCList(Node *CList){
Node *p = CList->next->next;
Node *q = NULL; while (p != CList){ //到达表尾
q = p->next;
delete p;
p = q;
} CList->next = CList; //将头结点指向尾结点
} //循环链表，销毁链表
void destoryCList(Node **CList){
Node *p = (*CList)->next;
Node *q = NULL; while (p != (*CList)->next){ //到达表头
q = p->next;
delete p;
p = q;
} *CList = NULL;
} //获取元素
void getCList(Node *CList, int pos, int *val){
Node *pCur = CList->next->next;
int i = ;
while (pCur != CList && i < pos){
pCur = pCur->next;
++i;
} *val = pCur->data;
}
//遍历输出元素
void printCList(Node *CList){
Node * tmpNode = CList->next->next;
while (tmpNode != CList){ //到达表尾
printf("%d\n", tmpNode->data);
tmpNode = tmpNode->next;
}
} int main(){
Node *CList = NULL;
//iniCListHead(&CList, 8);
//iniCList(&CList);
iniCListTail(&CList, ); //insertCListPos(CList, 1, 2);
//insertCListPos(CList, 2, 4);
//insertCListPos(CList, 3, 6);
//
//insertCListValue(CList, 1);
//
//deleteCListPos(CList, 3);
//
//deleteCListValue(CList, 6); //claerCList(CList); int a = ;
getCList(CList, , &a);
printf("%d\n", a); printCList(CList); printf("%d\n", CList);
destoryCList(&CList);
printf("%d\n", CList); system("pause");
return ;
}
C++完整代码
单向循环链表
注意：（1）单向循环链表销毁时，需要将头结点和尾结点删除；（2）单向循环链表插入，删除，遍历，清空链表时，条件从头结点或第一节点始，判断指针是否达到尾结点；（3）清空链表时，最后将头结点指向尾结点；（4）销毁链表时，条件从头结点始，判断条件为指针是否到达头结点，最后将指针置空。
-------------------------------------------------------------------------------------------------------------
如果上面的资料对你有启发，麻烦点个推荐，让更多人的人看到哦。
关注公众号【两猿社】，懂点互联网，懂点IC的程序猿，带你丰富项目经验哦。
C/C++实现单向循环链表(尾指针，带头尾节点)的更多相关文章
- python中的单向循环链表实现
引子 所谓单向循环链表,不过是在单向链表的基础上,如响尾蛇般将其首尾相连,也因此有诸多类似之处与务必留心之点.尤其是可能涉及到头尾节点的操作,不可疏忽. 对于诸多操所必须的遍历,这时的条件是什么?又应 ...
- c语言实现--单向循环链表操作
1,什么叫单向循环链表.单向循环链表是指在单链表的基础上,表的最后一个元素指向链表头结点,不再是为空. 2,由图可知,单向循环链表的判断条件不再是表为空了,而变成了是否到表头. 3,链表的结点表示 1 ...
- ※数据结构※→☆线性表结构（list）☆============单向循环链表结构（list circular single）（四）
循环链表是另一种形式的链式存贮结构.它的特点是表中最后一个结点的指针域指向头结点,整个链表形成一个环. 单循环链表——在单链表中,将终端结点的指针域NULL改为指向表头结点或开始结点即可. 循环链表的 ...
- Python 单向循环链表
操作 is_empty() 判断链表是否为空 length() 返回链表的长度 travel() 遍历 add(item) 在头部添加一个节点 append(item) 在尾部添加一个节点 inser ...
- 单向循环链表C语言实现
我们都知道,单向链表最后指向为NULL,也就是为空,那单向循环链表就是不指向为NULL了,指向头节点,所以下面这个程序运行结果就是,你将会看到遍历链表的时候就是一个死循环,因为它不指向为NULL,也是 ...
- python实现单向循环链表
单向循环链表 单链表的一个变形是单向循环链表,链表中最后一个节点的next域不再为None,而是指向链表的头节点. 实现 class Node(object): """节 ...
- JAVA单链表的实现-不带头结点且没有尾指针
本程序采用JAVA语言实现了线性表的链式实现.首先定义了线性表的接口ListInterface,然后LList类实现了ListInterface完成了链表的实现. 本实现中,链表是不带表头结点的,且有 ...
- 复习下C 链表操作（单向循环链表、查找循环节点）
循环链表 稍复杂点. 肯能会有0 或 6 字型的单向循环链表. 接下来创建 单向循环链表 并 查找单向循环链表中的循环节点. 这里已6字型单向循环链表为例. //创建 循环链表 Student * ...
- (java实现)单向循环链表
什么是单向循环链表 单向循环链表基本与单向链表相同,唯一的区别就是单向循环链表的尾节点指向的不是null,而是头节点(注意:不是头指针). 因此,单向循环链表的任何节点的下一部分都不存在NULL值. ...
随机推荐
- java oop第15章_Socket网络编程
一. TCP/IP协议(Transmission Control Protocol/Internet Protocol)传输控制协议/Internet协议,是通信领域的基础.核心协议, 其他的协议 ...
- react-router踩坑
1.当用BrowserRouter时,<Link/>组件必须放在BrowserRouter里,如果是存在于某个组件里的Link,则该组件也必须放在Router里,不然会出现url改变页面为 ...
- BBS论坛 后台管理
七.后台管理 后台管理页面: <!DOCTYPE html> <html lang="en"> <head> <meta charset= ...
- Unity3d -- Collider(碰撞器与触发器)
(2d与3d的Collider可以相互存在,但是无法相互协作,如2d是无法检测3d的,反之,一样) 在目前掌握的情况分析,在Unity中参与碰撞的物体分2大块:1.发起碰撞的物体.2.接收碰撞的物体. ...
- docker Dockerfile学习---构建mongodb环境
1.创建项目目录并上传包 mkdir centos_mongodb cd centos_mongodb .tgz 2.编辑配置文件 vi mongodb.conf dbpath = /data/usr ...
- 杭电多校第一场-B-Operation
题目描述 There is an integer sequence a of length n and there are two kinds of operations:0 l r: select ...
- SpringBoot中使用Scheduling执行定时任务
SpringBoot自带的 Schedule,可以将它看成一个轻量级的Quartz,而且使用起来比Quartz简单许多 以下任务都是在单线程下执行的 第一步 创建SpringBoot项目 第二步 外汇 ...
- Ruby 数据类型
Ruby 数据类型 本章节我们将为大家介绍 Ruby 的基本数据类型. Ruby支持的数据类型包括基本的Number.String.Ranges.Symbols,以及true.false和nil这几个 ...
- Spring-Security (补充)
一.配置静态资源过滤 直接在xml中配置即可 <!-- 配置静态资源过滤 --> <security:http security="none" pattern=& ...
- git tag操作
git tag //查看tag git tag v1.0.0 c809ddbf83939a89659e51dc2a5fe183af384233 //在某个commit 上打tag git push o ...