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值. ...
随机推荐
- Tk1上搭建turtlebot环境
sudo apt-get install ros-indigo-turtlebot ros-indigo-turtlebot-apps ros-indigo-turtlebot-interaction ...
- WPF RichTextBox 当前光标后一个字符是文档的第几个字符
WPF RichTextBox 当前光标后一个字符是文档的第几个字符 运行环境:Win10 x64, NetFrameWork 4.8, 作者:乌龙哈里,日期:2019-05-05 参考: TextP ...
- leetcood学习笔记-104-二叉树的最大深度
题目描述: 第一次提交: class Solution(object): def maxDepth(self, root): """ :type root: TreeNo ...
- sublime中Snippe的使用
Sublime Text号称最性感的编辑器, 并且越来越多人使用, 美观, 高效 关于如何使用Sublime text可以参考我的另一篇文章, 相信你会喜欢上的..Sublime Text 2使用心得 ...
- 高危预警| SQL数据库成主要攻击对象，或引发新一轮大规模勒索
近日,阿里云安全团队发现,目前互联网上的服务器,SQL数据库仍然有不少处于直接暴露在公网的状态,且数量有上升趋势.黑客可以利用数据库存在的漏洞或弱口令直接获取数据,并植入勒索和挖矿病毒寻求牟利.阿里云 ...
- NX二次开发-UF_MODL_ask_distance_tolerance获取建模的长度公差
NX9+VS2012 #include <uf.h> #include <uf_modl.h> #include <uf_ui.h> UF_initialize() ...
- JAVA泛型知识（一）
Java泛型知识(二)<? extends T>和<? super T> Java1.5泛型指南中文版(Java1.5 Generic Tutorial) 目 录 ...
- 《转》python 9 字典，numpy
http://www.cnblogs.com/BeginMan/p/3156960.html 一.映射类型 我理解中的映射类型是:键值对的关系,键(key)映射值(value),且它们是一对多的关系. ...
- vba取局域网电脑共享文件夹下的Excel文件
Private Sub CommandButton1_Click() Dim xlapp1 As Excel.Application Dim xlbook1 As Excel.Workbo ...
- Task ProgressBar模拟现实完成后显示TextBox
private async void Form1_Load(object sender, EventArgs e) { progressBar1.Maximum = ; progressBar2.Ma ...