如何创建一个空的c语言双向循环链表

至少需要一个元素，空的不能能建立数据结构。

1循环链表

　循环链表是与单链表一样，是一种链式的存储结构，所不同的是，循环链表的最后一个结点的指针是指向该循环链表的第一个结点或者表头结点，从而构成一个环形的链。循环链表的运算与单链表的运算基本一致。所不同的有以下几点：

  1)在建立一个循环链表时，必须使其最后一个结点的指针指向表头结点，而不是象单链表那样置为NULL。此种情况还使用于在最后一个结点后插入一个新的结点。

  2)在判断是否到表尾时，是判断该结点链域的值是否是表头结点，当链域值等于表头指针时，说明已到表尾。而非象单链表那样判断链域值是否为NULL。

2双向链表

  双向链表其实是单链表的改进。

  当我们对单链表进行 *** 作时，有时你要对某个结点的直接前驱进行 *** 作时，又必须从表头开始查找。这是由单链表结点的结构所限制的。因为单链表每个结点只有一个存储直接后继结点地址的链域，那么能不能定义一个既有存储直接后继结点地址的链域，又有存储直接前驱结点地址的链域的这样一个双链域结点结构呢？这就是双向链表。

3双向循环链表例程:

#include <stdlibh>

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 <stdioh>

#include <stdlibh>

#include "dblisth"

#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;

  }

 }

}

#include<stdioh>

#include<stdlibh>

#include<malloch>

typedef struct node

{

int a;//data,懒得改了

struct node prior,next;

}Lnode,Linklist;

Linklist creat(int node_number)

{

if(node_number<1)

return NULL;

Linklist L=NULL;//Head of Linklist

Linklist s,r=NULL;

int x;

printf("请输入链表数据：\n");

scanf("%d",&x);

s=malloc(sizeof(Lnode));

L=s;

s->a=x;

s->prior=NULL;

s->next=NULL;

while(--node_number)

{

scanf("%d",&x);

r=malloc(sizeof(Lnode));

r->a=x;

r->prior=s;

r->next = NULL;

s->next = r;

s = r;

}

return L;

}

Linklist insert(Linklist L,int n)

{

Lnode s,q;

int x;

printf("请输入要插入的数据:\n");

scanf("%d",&x);

if(n==0)

{

s=malloc(sizeof(Lnode));

s->a=x;

s->next=L;

s->prior = NULL;

L=s;

return L;

}

else

{

q=L;

while( (q->next!=NULL) && n>1)

{

q=q->next;

n--;

}

if(n==1)

{

s=malloc(sizeof(Lnode));

s->a=x;

s->next=q->next;

(q->next)->prior = s;

s->prior = q;

q->next=s;

}

else printf("链表插入错误！\n");

return L;

}

}

Linklist delete(Linklist L)//使用关键字

{

Lnode s,q;

int x;

printf("请输入要删除的数据:\n");

scanf("%d",&x);

q = L;

while(q)

{

if(q->a == x)

break;

q=q->next;

}

if(q==NULL)

{

printf("链表中未有该数据\n");

}

else{

s=q->prior;

if(s)

s->next=q->next;

if(q->next)

(q->next)->prior = s;

free(q);

}

return L;

}

void Linklist_print(Linklist p)

{

printf("链表数据输出：\n");

while(p!=NULL)

{

printf(" %6d",p->a);

p=p->next;

}

printf("\n");

}

int main()

{

Linklist L;

L=creat(10);//10个元素

Linklist_print(L);

int n;

printf("\n输入插入节点的位置:\n");

scanf("%d",&n);

L=insert(L,n);

Linklist_print(L);

delete(L);

Linklist_print(L);

return 0;

}

单向链表：每个链表节点都有一个next指针，通过名字知道，next存放的是下一个节点的位置，从而串起来的数据结构。

双向链表：每个链表节点除了next指针外还有prev指针。哪个节点next指针指向我，我的prev就指向那个节点。

typedef int ElementType;

typedef struct _NODE

{

struct NODE next;

struct NODE prev;

ElementType e;

} NODE;

typedef struct _LIST

{

NODE head;/记录链表头/

unsigned int count;/记录链表元素个数/

} LIST;

#define __prev /用于提示在前面 *** 作/

双向链表在确定节点前面插入是不用遍历链表的。

我写一个函数，在一个指定节点前插入一个节点的，其他的就类似了：

NODE InsertToList( __ prev NODE node, ElemType elem)

{

if (! list || ! node)

return NULL;

NODE p = (NODE )malloc(sizeof(NODE));

if (! p)

return NULL;

p ->e = elem;

p ->prev = node ->prev;/让两个指针指向同一个地方/

node ->prev ->next = p;/断开连接/

node ->prev = p;/断开连接/

p ->next = node;/完成连接/

return p;

}

以上就是关于如何创建一个空的c语言双向循环链表全部的内容，包括:如何创建一个空的c语言双向循环链表、求一用C++写的线性表链式存储（双向链表）插入、删除运算的程序！！！急！！！谢谢！！！、如何实现双向链表等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！