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值. ...
随机推荐
- Linux 下工作用户及环境
交叉工具的安装 工具链的编译过程请参考第三部分. 1. 下载交叉工具 2.95.3 下载地址:ftp://ftp.arm.linux.org.uk/pub/armlinux/toolchain/cro ...
- linux下alsa架构音频驱动播放wav格式文件
#include<stdio.h> #include<stdlib.h> #include <string.h> #include <alsa/asoundl ...
- WXSS学习
<view class='container'> <button type='default'>测试</button> <button type='defau ...
- Mysql 查询表中某字段的重复值，删除重复值保留id最小的数据
1 查询重复值 ); 2 删除重复值 -- 创建临时表 ) ); -- 把重复数据放进临时表 INSERT Hb_Student_a SELECT id,studentNumber FROM Hb_S ...
- Linux --赋予普通用户root 权限
Linux的普通用户在安装一些东西的时候或者执行命令的时候,终端始终会提示权限不够,我们会将这个普通用户赋予root权限,但是,和root还是有区别的,因为只能执行root规定好的一些操作命令. 1. ...
- CF755G PolandBall and Many Other Balls/soj 57送饮料
题意:长度为n的序列,相邻两个或单独一个可以划分到一个组,每个元素最多处于一个组. 问恰好分割成k(1<=k<=m)段有多少种方案? 标程: #include<bits/stdc++ ...
- leetcood学习笔记-67-二进制求和
题目描述: 第一次提交: class Solution: def addBinary(self, a: str, b: str) -> str: list_a,list_b=[],[] for ...
- .net API跨域
在webconfig中的节点 <system.webServer> </system.webServer> 下添加 <httpProtocol><custom ...
- Annotation详解
转自:http://www.doc88.com/p-995532241886.html 首先我们定义一个简单的注解 package com.qjy.annotation; import java.la ...
- python从入门到大神---Python的jieba模块简介
python从入门到大神---Python的jieba模块简介 一.总结 一句话总结: jieba包是分词技术,也就是将一句话分成多个词,有多种分词模型可选 1.分词模块包一般有哪些分词模式(比如py ...