第四周项目4——建设双链表算法库

来源:互联网 发布:手机淘宝扫码 编辑:程序博客网 时间:2024/06/06 16:25

问题:

  1. /*  
  2. * Copyright (c)2016,烟台大学计算机与控制工程学院  
  3. * All rights reserved.  
  4. * 文件名称:wu.cpp  
  5. * 作    者:武昊  
  6. * 完成日期:2016年9月22日  
  7. * 版 本 号:v1.0   
  8. *问题描述:算法库包括两个文件:  
  9.   头文件:dlinklist.h,包含定义顺序表数据结构的代码、宏定义、要实现算法的函数的声明;  
  10.   源文件:dlinklist.cpp,包含实现各种算法的函数的定义  
  11.   请采用程序的多文件组织形式,建立如上的两个文件,另外再建立一个源文件(如main.cpp),编制main函数,完成相关的测试工作。 
  12. *输入描述:无    
  13. *程序输出:链表。   
  14. */     
dlinklist.h
  1. #include <stdio.h>    
  2. #include <malloc.h>    
  3.     
  4. //循环双链表基本运算函数    
  5. typedef int ElemType;    
  6. typedef struct DNode        //定义双链表结点类型    
  7. {    
  8.     ElemType data;    
  9.     struct DNode *prior;    //指向前驱结点    
  10.     struct DNode *next;     //指向后继结点    
  11. } CDLinkList;    
  12.     
  13. void CreateListF(CDLinkList *&L,ElemType a[],int n); //头插法建立循环双链表    
  14. void CreateListR(CDLinkList *&L,ElemType a[],int n); //尾插法建立循环双链表    
  15. void InitList(CDLinkList *&L); //初始化循环双链表    
  16. void DestroyList(CDLinkList *&L);  //销毁    
  17. bool ListEmpty(CDLinkList *L); //判断是否为空    
  18. int ListLength(CDLinkList *L); //求链表长度    
  19. void DispList(CDLinkList *L);  //输出链表    
  20. bool GetElem(CDLinkList *L,int i,ElemType &e);  //取链表元素    
  21. int LocateElem(CDLinkList *L,ElemType e);  //查找元素    
  22. bool ListInsert(CDLinkList *&L,int i,ElemType e);  //插入节点    
  23. bool ListDelete(CDLinkList *&L,int i,ElemType &e);  //删除节点   
dlinklist.cpp
  1. //循环双链表基本运算函数    
  2. #include "dlinklist.h"    
  3. void CreateListF(CDLinkList *&L,ElemType a[],int n) //头插法建立循环双链表    
  4. {    
  5.     CDLinkList *s;    
  6.     int i;    
  7.     L=(CDLinkList *)malloc(sizeof(CDLinkList));     //创建头结点    
  8.     L->next=NULL;    
  9.     for (i=0; i<n; i++)    
  10.     {    
  11.         s=(CDLinkList *)malloc(sizeof(CDLinkList));//创建新结点    
  12.         s->data=a[i];    
  13.         s->next=L->next;            //将*s插在原开始结点之前,头结点之后    
  14.         if (L->next!=NULL) L->next->prior=s;    
  15.         L->next=s;    
  16.         s->prior=L;    
  17.     }    
  18.     s=L->next;    
  19.     while (s->next!=NULL)           //查找尾结点,由s指向它    
  20.         s=s->next;    
  21.     s->next=L;                      //尾结点next域指向头结点    
  22.     L->prior=s;                     //头结点的prior域指向尾结点    
  23.     
  24.     
  25. }    
  26. void CreateListR(CDLinkList *&L,ElemType a[],int n) //尾插法建立循环双链表    
  27. {    
  28.     CDLinkList *s,*r;    
  29.     int i;    
  30.     L=(CDLinkList *)malloc(sizeof(CDLinkList));  //创建头结点    
  31.     L->next=NULL;    
  32.     r=L;                    //r始终指向尾结点,开始时指向头结点    
  33.     for (i=0; i<n; i++)    
  34.     {    
  35.         s=(CDLinkList *)malloc(sizeof(CDLinkList));//创建新结点    
  36.         s->data=a[i];    
  37.         r->next=s;    
  38.         s->prior=r; //将*s插入*r之后    
  39.         r=s;    
  40.     }    
  41.     r->next=L;              //尾结点next域指向头结点    
  42.     L->prior=r;             //头结点的prior域指向尾结点    
  43. }    
  44. void InitList(CDLinkList *&L) //初始化循环双链表    
  45. {    
  46.     L=(CDLinkList *)malloc(sizeof(CDLinkList));     //创建头结点    
  47.     L->prior=L->next=L;    
  48. }    
  49. void DestroyList(CDLinkList *&L)  //销毁    
  50. {    
  51.     CDLinkList *p=L,*q=p->next;    
  52.     while (q!=L)    
  53.     {    
  54.         free(p);    
  55.         p=q;    
  56.         q=p->next;    
  57.     }    
  58.     free(p);    
  59. }    
  60. bool ListEmpty(CDLinkList *L) //判断是否为空    
  61. {    
  62.     return(L->next==L);    
  63. }    
  64. int ListLength(CDLinkList *L) //求链表长度    
  65. {    
  66.     CDLinkList *p=L;    
  67.     int i=0;    
  68.     while (p->next!=L)    
  69.     {    
  70.         i++;    
  71.         p=p->next;    
  72.     }    
  73.     return(i);    
  74. }    
  75. void DispList(CDLinkList *L)  //输出链表    
  76. {    
  77.     CDLinkList *p=L->next;    
  78.     while (p!=L)    
  79.     {    
  80.         printf("%d ",p->data);    
  81.         p=p->next;    
  82.     }    
  83.     printf("\n");    
  84. }    
  85. bool GetElem(CDLinkList *L,int i,ElemType &e)  //取链表元素    
  86. {    
  87.     int j=0;    
  88.     CDLinkList *p;    
  89.     if (L->next!=L)     //双链表不为空表时    
  90.     {    
  91.         if (i==1)    
  92.         {    
  93.             e=L->next->data;    
  94.             return true;    
  95.         }    
  96.         else            //i不为1时    
  97.         {    
  98.             p=L->next;    
  99.             while (j<i-1 && p!=L)    
  100.             {    
  101.                 j++;    
  102.                 p=p->next;    
  103.             }    
  104.             if (p==L)    
  105.                 return false;    
  106.             else    
  107.             {    
  108.                 e=p->data;    
  109.                 return true;    
  110.             }    
  111.         }    
  112.     }    
  113.     else                //双链表为空表时    
  114.         return 0;    
  115. }    
  116. int LocateElem(CDLinkList *L,ElemType e)  //查找元素    
  117. {    
  118.     int n=1;    
  119.     CDLinkList *p=L->next;    
  120.     while (p!=NULL && p->data!=e)    
  121.     {    
  122.         n++;    
  123.         p=p->next;    
  124.     }    
  125.     if (p==NULL)    
  126.         return(0);    
  127.     else    
  128.         return(n);    
  129. }    
  130. bool ListInsert(CDLinkList *&L,int i,ElemType e)  //插入节点    
  131. {    
  132.     int j=0;    
  133.     CDLinkList *p=L,*s;    
  134.     if (p->next==L)                 //原双链表为空表时    
  135.     {    
  136.         s=(CDLinkList *)malloc(sizeof(CDLinkList)); //创建新结点*s    
  137.         s->data=e;    
  138.         p->next=s;    
  139.         s->next=p;    
  140.         p->prior=s;    
  141.         s->prior=p;    
  142.         return true;    
  143.     }    
  144.     else if (i==1)                  //原双链表不为空表但i=1时    
  145.     {    
  146.         s=(CDLinkList *)malloc(sizeof(CDLinkList)); //创建新结点*s    
  147.         s->data=e;    
  148.         s->next=p->next;    
  149.         p->next=s;  //将*s插入到*p之后    
  150.         s->next->prior=s;    
  151.         s->prior=p;    
  152.         return true;    
  153.     }    
  154.     else    
  155.     {    
  156.         p=L->next;    
  157.         while (j<i-2 && p!=L)    
  158.         {    
  159.             j++;    
  160.             p=p->next;    
  161.         }    
  162.         if (p==L)               //未找到第i-1个结点    
  163.             return false;    
  164.         else                    //找到第i-1个结点*p    
  165.         {    
  166.             s=(CDLinkList *)malloc(sizeof(CDLinkList)); //创建新结点*s    
  167.             s->data=e;    
  168.             s->next=p->next;    //将*s插入到*p之后    
  169.             if (p->next!=NULL) p->next->prior=s;    
  170.             s->prior=p;    
  171.             p->next=s;    
  172.             return true;    
  173.         }    
  174.     }    
  175. }    
  176. bool ListDelete(CDLinkList *&L,int i,ElemType &e)  //删除节点    
  177. {    
  178.     int j=0;    
  179.     CDLinkList *p=L,*q;    
  180.     if (p->next!=L)                 //原双链表不为空表时    
  181.     {    
  182.         if (i==1)                   //i==1时    
  183.         {    
  184.             q=L->next;              //删除第1个结点    
  185.             e=q->data;    
  186.             L->next=q->next;    
  187.             q->next->prior=L;    
  188.             free(q);    
  189.             return true;    
  190.         }    
  191.         else                        //i不为1时    
  192.         {    
  193.             p=L->next;    
  194.             while (j<i-2 && p!=NULL)    
  195.             {    
  196.                 j++;    
  197.                 p=p->next;    
  198.             }    
  199.             if (p==NULL)                //未找到第i-1个结点    
  200.                 return false;    
  201.             else                        //找到第i-1个结点*p    
  202.             {    
  203.                 q=p->next;              //q指向要删除的结点    
  204.                 if (q==NULL) return 0;  //不存在第i个结点    
  205.                 e=q->data;    
  206.                 p->next=q->next;        //从单链表中删除*q结点    
  207.                 if (p->next!=NULL) p->next->prior=p;    
  208.                 free(q);                //释放*q结点    
  209.                 return true;    
  210.             }    
  211.         }    
  212.     }    
  213.     else    
  214.         return false;   //原双链表为空表时    
  215. }    
main.cpp
                     #include <stdio.h>  
    1. #include "dlinklist.h"  
    2.   
    3. int main()  
    4. {  
    5.     DLinkList *A;  
    6.     ElemType a[]= {1, 3, 2, 9, 0, 4, 5 ,6, 7, 8};//头插法  
    7.     InitList(A);  
    8.     CreateListF(A, a, 10);  
    9.     DispList(A);  
    10.     printf("length: %d\n", ListLength(A));  
    11.     ListInsert(A, 4, 12);  
    12.     printf("After Insert: ");  
    13.     DispList(A);  
    14.      printf("length: %d\n", ListLength(A));  
    15.   
    16.     DestroyList(A);  
    17.     return 0;  
    18. }  
运行结果:


0 0
原创粉丝点击