数据结构学习——双向循环链表

实现双向循环链表的初始化，插入元素，计算链表长度，得到某位置的元素，正序输出，逆序输出，销毁链表

 #include<string.h>
 #include<ctype.h>
 #include<malloc.h> 
 #include<stdio.h> /* EOF(=^Z或F6),NULL */
 #include<math.h> /* floor(),ceil(),abs() */
 #include<process.h> /* exit() */
#define OK 1
#define ERROR 0
typedef int ElemType;

  
  //定义循环链表结构 
  typedef struct DuLNode
 {
   ElemType data;
   struct DuLNode *prior,*next;
 }DuLNode,*DuLinkList;
 
 /* 产生空的双向循环链表L */
  int InitList(DuLinkList *L)
 { 
   *L=(DuLinkList)malloc(sizeof(DuLNode));
   if(*L)                     
   {
     (*L)->next=(*L)->prior=*L;
     return OK;
   }
   else
     return OVERFLOW;
 }
 
 /*计算链表长度*/ 
  int ListLength(DuLinkList L)
 {
   int i=0;
   DuLinkList p=L->next; /* p指向第一个结点 */
   while(p!=L)           /* p没到表头 */
   {
     i++;
     p=p->next;
   }
   return i;
 }
 
 /* 在双向链表L中返回第i个元素的位置指针(算法2.18、2.19要调用的函数) */
 DuLinkList GetElemP(DuLinkList L,int i) 
 { 
   int j;
   DuLinkList p=L;
   for(j=1;j<=i;j++)
     p=p->next;
   return p;
 }
 
  int ListInsert(DuLinkList L,int i,ElemType e) /* 改进算法2.18 */
 { /* 在带头结点的双链循环线性表L中第i个位置之前插入元素e，i的合法值为1≤i≤表长+1 */

   DuLinkList p,s;
   if(i<1||i>ListLength(L)+1) /* i值不合法 */
     return ERROR;
   p=GetElemP(L,i-1); /* 在L中确定第i-1个元素的位置指针p */
   if(!p) /* p=NULL,即第i-1个元素不存在 */
     return ERROR;
   s=(DuLinkList)malloc(sizeof(DuLNode));
   if(!s)
     return OVERFLOW;
   s->data=e; /* 在第i-1个元素之后插入 */
   s->prior=p;
   s->next=p->next;
   p->next->prior=s;
   p->next=s;
   return OK;
 }
 
 //表正序输出 
  void ListTraverse(DuLinkList L)
 { 
   DuLinkList p=L->next; /* p指向头结点 */
   printf("正序表中的元素为：");
   while(p!=L)
   {
   	printf("%d",p->data);
     p=p->next;
   }
   printf("\n");
 }

//表逆序输出 
  void ListTraverseBack(DuLinkList L)
 { 
   DuLinkList p=L->prior; /* p指向尾结点 */
   	printf("逆序表中的元素为：");
   while(p!=L)
   {
   	printf("%d",p->data);
   	p=p->prior;
   }
   printf("\n");
 }
 
 //删除第i个节点 
  int ListDelete(DuLinkList L,int i,ElemType *e) 
 { /* 删除带头结点的双链循环线性表L的第i个元素,i的合法值为1≤i≤表长+1 */
   DuLinkList p;
   if(i<1||i>ListLength(L)) /* i值不合法 */
     return ERROR;
   p=GetElemP(L,i);  /* 在L中确定第i个元素的位置指针p */
   if(!p) /* p=NULL,即第i个元素不存在 */
     return ERROR;
   *e=p->data;
   p->prior->next=p->next;
   p->next->prior=p->prior;
   free(p);
   return OK;
 }
 
 //获取第i个元素 
  int GetElem(DuLinkList L,int i,ElemType *e)
 {
   DuLinkList p;
   p=GetElemP(L,i-1); 
   *e=p->data; /* 取第i个元素 */
   return OK;
 }
 
  int DestroyList(DuLinkList *L)
 { /* 操作结果：销毁双向循环链表L */
   DuLinkList q,p=(*L)->next; /* p指向第一个结点 */
   while(p!=*L) /* p没到表头 */
   {
     q=p->next;
     free(p);
     p=q;
   }
   free(*L);
   *L=NULL;
   return OK;
 }
 
 int main()
 {
   DuLinkList L;
   int i,n;
   int j;
   ElemType e;
   InitList(&L);
   for(i=1;i<=5;i++)
     ListInsert(L,i,i); /* 在第i个结点之前插入i */
   ListTraverse(L);      //正序输出 
   ListTraverseBack(L);  //逆序输出 
   ListDelete(L,2,&e); /* 删除并释放第2个结点 */
   printf("删除第%d个结点，值为%d，其余结点为：",2,e);
   ListTraverse(L);    /* 正序输出 */
   GetElem(L,3,&e);
   printf("第三个元素为%d\n",e);
   DestroyList(&L);       //销毁链表 
   printf("销毁链表后"); 
   ListTraverse(L);    /* 正序输出 */
   return 1; 
     }