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值. ...
随机推荐
- Neo4j 小调研
一. 概况: 在图计算中,基本的数据结构表达式是:G= ( V,E ),V=vertex( 节点 ),E=edge(边) .图数据库中数据模型主要以节点和关系(边)来体现,也可以处理键值对.数据具有如 ...
- yum处理损坏的包依赖关系
有时在安装多个软件包时,某个包的软件依赖关系可能会被另外一个包的安装覆盖掉.这叫做损坏的包依赖关系(broken dependency). 如果系统出现问题,可以先尝试: yum clean all ...
- 随笔记录 yum -y clean all出错解决方案
出现以下问题的解决方案: 使用解决方案之前,要先确定一下几种情况: 1.检查光盘是否挂载 2.ISO映像文件是否使用正确 解决方案1: rm -rf /var/cache/yum/* yum repo ...
- 【学术篇】CF935E Fafa and Ancient Mathematics 树形dp
前言 这是一道cf的比赛题.. 比赛的时候C题因为自己加了一个很显然不对的特判WA了7次但找不出原因就弃疗了... 然后就想划水, 但是只做了AB又不太好... 估计rating会掉惨 (然而事实证明 ...
- react 使用react-router-dom 在Route对象上component 参数接收的是一个方法而非一个对象
其实对于jsx语法 一直觉的它有点清晰都不是很好,js和html混在一起有点不伦不类的样子,以下是我在使用react中遇到的一个很奇葩的事情 假定你定义了一个component Mine import ...
- 单调栈(最大子矩形强化版)——牛客多校第八场A
求01矩阵里有多少个不同的1矩阵 首先预处理出pre[i][j]表示i上面连续的1个数,对每行的高度进行单调栈处理 栈里的元素维护两个值:pre[i][j]和向前延伸最多能维护的位置pos 然后算贡献 ...
- sqoop简介和原理分析
Sqoop简介 Sqoop是一款开源的工具,主要用于在Hadoop(Hive)与传统的数据库(mysql.postgresql...)间进行数据的传递,可以将一个关系型数据库(例如 : MySQL , ...
- python中os模块获取路径的几种方式
一.代码 import os BASE_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), "..")) p ...
- NX二次开发-UFUN创建球UF_MODL_create_sphere1
NX11+VS2013 #include <uf.h> #include <uf_modl.h> UF_initialize(); //创建球 UF_FEATURE_SIGN ...
- c++11新特性学习2
noexcept 替代 throw.优点是更安全, 如果noexcept 修饰的函数抛出了异常,编辑器可以直接选择终止程序. C++ 11中析构函数默认为noexcept(true),从而阻止异常的扩 ...