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值. ...
随机推荐
- Dubbo多注册中心和Zookeeper服务的迁移
一.Dubbo多注册中心 1. 应用场景 例如阿里有些服务来不及在青岛部署,只在杭州部署,而青岛的其它应用需要引用此服务,就可以将服务同时注册到两个注册中心. consumer.xml <?xm ...
- Berry 异常处理 1: 语法和字节码设计
语法 最近在实现 Berry 的异常处理特性,进过初步的调查后决定使用类似 Python 的 try-except 异常处理模式,为此要引入三个新的关键字: try:表示异常捕获块的开始,位于异常捕获 ...
- native 之bitmap 保存坑
之前开发项目的时候遇到几次一键保存二维码,或凭证的需求,但是使用h5 a标签 保存网络图片有些并不支持,于是想到了 使用navite 的bitmap可能会好一些 bitmap js封装后的原生图片对象 ...
- 泛型（Generic）方法（函数，算法）
例子: static void Main(string[] args) { int[] a1 = { 1, 2, 3, 4, 5 }; int[] a2 = { 1, 2, 3, 4, 5 }; do ...
- sed 一 文本处理工具
简介 sed 采用的是流编辑模式: 最明显的特点是,在 sed 处理数据之前,需要预先提供一组规则,sed 会按照此规则来编辑数据. sed 会根据脚本命令来处理文本文件中的数据,这些命令要么从命令行 ...
- Android Activity XML配置
<activity android:name="xxxActivity" android:configChanges="keyboard|keyboardHidde ...
- Java——面向对象的特征二：继承性
2.1面向对象的特征二:继承性 ①引入类继承最基本的作用是:代码重用. ②语法 [修饰符列表] class 子类名 extends 父类名{ 类体; } ③子类继承父类以后,父类中声明的属性.方法,子 ...
- [C#]记录一次异常排查，关于using语法、sqlserver数据库session、DBHelper类
最近在做一个基于asp.net和sqlserver的网站项目,发现网站运行一段时间之后,会报异常: 超时时间已到,但是尚未从池中获取连接.出现这种情况可能是因为所有池连接均在使用,并且达到了最大池大小 ...
- RN书签
Bookmarks 书签栏 门户 配置reactNative(RN)过程中 出现react-native:command not... - 简书 * React-NativeChannel - sma ...
- Maven详解（）-- 常用命令
Maven常用命令: Maven库: http://repo2.maven.org/maven2/ Maven依赖查询: http://mvnrepository.com/ 一,Maven常用命令: ...