本文目录一览：
- 1、双向循环链表的C语言实现
- 2、如何创建一个空的c语言双向循环链表
- 3、如何创建c语言的双向循环链表
- 4、C语言循环双链表解决 30个人 每次传到第三个人就退出 输出退出的顺序
- 5、c语言；不带头结点的循环双链表的实现和相关操作
- 6、c语言编程，合并两个循环链表
双向循环链表的C语言实现
在工作中的项目有用到双链表，尤其是跟着别人写双链表代码的思路，自己去看总觉得没那么顺，感觉以后也会经常用到，所以索性自己写一个出来，细节由自己去把握，终于是理解了这一块，以下是实现双链表的所有源码：
若是大家有其他想法或者有发现错误，欢迎指正哈~
如何创建一个空的c语言双向循环链表
至少需要一个元素，空的不能能建立数据结构。
1.循环链表
循环链表是与单链表一样，是一种链式的存储结构，所不同的是，循环链表的最后一个结点的指针是指向该循环链表的第一个结点或者表头结点，从而构成一个环形的链。循环链表的运算与单链表的运算基本一致。所不同的有以下几点：
1)在建立一个循环链表时，必须使其最后一个结点的指针指向表头结点，而不是象单链表那样置为NULL。此种情况还使用于在最后一个结点后插入一个新的结点。
2)在判断是否到表尾时，是判断该结点链域的值是否是表头结点，当链域值等于表头指针时，说明已到表尾。而非象单链表那样判断链域值是否为NULL。
2.双向链表
双向链表其实是单链表的改进。
当我们对单链表进行操作时，有时你要对某个结点的直接前驱进行操作时，又必须从表头开始查找。这是由单链表结点的结构所限制的。因为单链表每个结点只有一个存储直接后继结点地址的链域，那么能不能定义一个既有存储直接后继结点地址的链域，又有存储直接前驱结点地址的链域的这样一个双链域结点结构呢？这就是双向链表。
3.双向循环链表例程:
#include stdio.h
#include stdlib.h
typedef struct tagDbNode
{
int data;
struct tagDbNode * left;
struct tagDbNode * right;
} DbNode, * pdbNode;
//创建结点
pdbNode CreateNode(int data)
{
pdbNode pnode = (pdbNode)malloc(sizeof(DbNode));
pnode-data = data;
pnode-left = pnode-right = pnode; //创建新结点时，让其前驱和后继指针都指向自身
return pnode;
}
//创建链表
pdbNode CreateList(int head) //参数给出表头结点数据 （表头结点不作为存放有意义数据的结点）
{
pdbNode pnode = (pdbNode)malloc(sizeof(DbNode));
pnode-data = head;
pnode-left = pnode-right = pnode;
return pnode;
}
//插入新结点,总是在表尾插入; 返回表头结点
pdbNode InsertNode(pdbNode node, int data) // 参数1是链表的表头结点，参数2是要插入的结点（结
点数据为data）
{
pdbNode pnode = CreateNode(data);
// 从左到右恢复链接
node-left-right = pnode;
pnode-right = node;
// 从右到左恢复链接
pnode-left = node-left;
node-left = pnode;
return node;
}
//查找结点，成功则返回满足条件的结点指针，否则返回NULL
pdbNode FindNode(pdbNode node, int data) // 参数1是链表的表头结点，参数2是要查找的结点（其中
结点数据为data）
{
pdbNode pnode = node-right;
while (pnode != node pnode-data != data)
{
pnode = pnode-right;
}
if (pnode == node) return NULL;
return pnode;
}
//删除满足指定条件的结点, 返回表头结点, 删除失败返回NULL（失败的原因是不存在该结点）
pdbNode DeleteNode(pdbNode node, int data) // 参数1是链表的表头结点，参数2是要删除的结点（其
中结点数据为data）
{
pdbNode pnode = FindNode(node, data);
if (NULL == pnode) return NULL;
pnode-left-right=pnode-right;
pnode-right-left=pnode-left;
free(pnode);
return node;
}
//获取链表的长度
int GetLength(pdbNode node) // 参数为链表的表头结点
{
int nCount = 0;
pdbNode pnode = node-right;
while (pnode!= node)
{
pnode = pnode-right;
nCount++;
}
return nCount;
}
//顺序打印整个链表
void PrintList(pdbNode node) // 参数为链表的表头结点
{
pdbNode pnode;
if (NULL == node) return;
pnode= node-right;
while (pnode != node)
{
printf("%d ", pnode-data);
pnode = pnode -right;
}
printf("\n");
}
//将链表反序打印
void ReverPrint(pdbNode node) //参数为链表的表头结点
{
pdbNode pnode;
if (NULL == node) return;
pnode= node-left;
while (pnode != node)
{
printf("%d ", pnode-data);
pnode = pnode-left;
}
printf("\n");
}
//删除链表
void DeleteList(pdbNode node) //参数为链表表头结点
{
pdbNode pnode = node-right;
pdbNode ptmp;
if (NULL == node) return;
while (pnode != node)
{
ptmp = pnode-right;
free(pnode);
pnode = ptmp;
}
free(node);
}
//测试程序
#include stdio.h
#include stdlib.h
#include "dblist.h"
#define FALSE 0
#define TRUE 1
typedef unsigned int bool;
void main()
{
int nChoose;
int data;
bool bFlag = FALSE;
pdbNode pnode;
pdbNode list = CreateList(0);
while(bFlag == FALSE)
{
printf("Main Menu\n");
printf("1. Insert\n");
printf("2. Delete Node\n");
printf("3. Find\n");
printf("4. Length\n");
printf("5. Positive Print\n");
printf("6. Negative Print\n");
printf("7. Delete List\n");
printf("0. quit\n\n");
scanf("%d", nChoose);
switch(nChoose)
{
case 1:
printf("Input the data to insert:");
scanf("%d", data);
list = InsertNode(list, data);
PrintList(list);
printf("\n");
break;
case 2:
printf("Input the data to delete: ");
scanf("%d", data);
DeleteNode(list, data);
PrintList(list);
printf("\n");
break;
case 3:
printf("Input the data to find: ");
scanf("%d", data);
pnode = FindNode(list, data);
if (NULL != pnode)
{
printf("Find succeed!\n");
printf("\n");
}
else
{
printf("Find failed!\n");
printf("\n");
}
break;
case 4:
printf("The list's length is %d\n", GetLength(list));
printf("\n");
break;
case 5:
PrintList(list);
printf("\n");
break;
case 6:
ReverPrint(list);
printf("\n");
break;
case 7:
DeleteList(list);
printf("\n");
break;
case 0:
DeleteList(list);
bFlag = TRUE;
}
}
}
如何创建c语言的双向循环链表
#includestdio.h
#includestdlib.h
#includeiostream
using namespace std;
int n;
typedef struct node
{
int data;
struct node *prior;
struct node *next;
}node,*DoubleLinkList;
void Creat_List(DoubleLinkList L)
{
DoubleLinkList r,s;
cout"请输入n的值"endl;
cinn;
s = L;
s-prior = s;
s-data = n;
for(int i=0;in;i++)
{
r = (DoubleLinkList)malloc(sizeof(node));
L-next = r;
r-next = s-next;
r-prior = L;
s-next-prior = r;
r-data = i;
L = r;
}
}
void Desplay_List(DoubleLinkList L)
{
DoubleLinkList p;
p = L-next;
for(int i=0;in;i++)
{
cout"输出:"p-dataendl;
p = p-next;
}
}
void Destroy_List(DoubleLinkList L)
{
DoubleLinkList p;
p = L;
node *temp;
for(int k=0;kn;k++)
{
p = L-next;
temp = p-next;
temp-prior-next = temp-next;
temp-next-prior = temp-prior;
free(temp);
}
cout"空间释放成功"endl;
}
void main()
{
node a;
DoubleLinkList p;
p = a;
Creat_List(p);
Desplay_List(p);
Destroy_List(p);
}
由于我也不熟悉，我自己保存的创建例子，希望对你有帮助~
C语言循环双链表解决 30个人 每次传到第三个人就退出 输出退出的顺序
#include stdio.h
#include stdlib.h
typedef struct Node {
int data;
struct Node *next;
//struct Node *last;
}Node;
Node *list_creat(Node *phead,int len) {
Node *p = phead;
int i;
for(i = 1;i = len;i++) {
p-next = (Node *)malloc(sizeof(Node));
p-next-data = i;
p = p-next;
}
p-next = phead;
return phead;
}
/*
void list_remove(Node *phead) {
Node *p = phead;
Node *q=p-last;
Node *qq=p-next;
q-next=qq;
free(p);
}
*/
void list_print(Node *phead,int len,int ren) {
Node *p = phead-next;
while(p != phead) {
printf("%d ",p-data);
p = p-next;
}
printf("\n");
}
int main() {
int ren,zong_ren;
printf("一共多少人:");
scanf("%d",zong_ren);
printf("传第几次退出:");
scanf("%d",ren);
Node *phead = (Node *)malloc(sizeof(Node));
phead = list_creat(phead,zong_ren);
list_print(phead,zong_ren,ren);
return 0;
}
c语言；不带头结点的循环双链表的实现和相关操作
循环双向链表就是节点有2个指针，分别指向前后节点，最终形成O型。
头结点是用来找到链表的，既然你不要头节点，那我只能用尾节点（最后添加的节点）。
这里代码功能：通过添加节点生成链表，并通过最后添加的节点找到链表并循环打印整个链表。
#includestdio.h
#includemalloc.h
int idcont=1;
int listcont=0;//记录节点个数
typedef struct stList
{
int id;
char content[10];
struct stList *front;
struct stList *next;
}STL;
STL *InitList();
STL *addList(STL *stl);
void printfSTL(STL *lastSTL);
int main()
{
char as;
STL *stl=NULL,*lastSTL=NULL;
stl=InitList();
while(1)
{
lastSTL=addList(stl);
printf("是否继续添加节点：Y/N？ ");
getchar();
scanf("%c",as);
if(as=='N')
break;
}
printfSTL(lastSTL);
return 0;
}
void printfSTL(STL *lastSTL)
{
STL *stl=lastSTL;
printf("节点编号：%d，内容：%s\n",stl-id,stl-content);
stl=stl-next;
while(stl!=lastSTL)
{
printf("节点编号：%d，内容：%s\n",stl-id,stl-content);
stl=stl-next;
}
}
STL *InitList()
{
printf("初始化双向链表\n");
STL *stl1=(STL *)malloc(sizeof(STL));
stl1-front=NULL;
stl1-next=NULL;
stl1-id=idcont++;
return stl1;
}
STL *addList(STL *stl)
{
STL *stlnew=NULL;
printf("请输入要添加进链表的节点内容\n");
if(stl-front==NULL)//首节点
{
scanf("%s",stl-content);
stl-front=stl;
stl-next=stl;
}
else
{
stlnew=(STL *)malloc(sizeof(STL));
scanf("%s",stlnew-content);
stlnew-front=stl;
stlnew-next=stl-next;
stlnew-id=idcont++;
stl-next=stlnew;
}
listcont++;
return stlnew;
}
c语言编程，合并两个循环链表
首先要以head1为开始点，找到链表一中的最后一个节点；
然后以最后一个节点为开始点，指向head2；
最后将链表二中的最后一个节点指向链表一的开始节点；
这样就将两个循环链表合并成一个循环链表了。
