图书管理系统

                                    

   1.需求分析

问题描述：

该程序能实现对一本书进行采编入库、清除库存、借阅图书、归还图书且记录借书的用户信息，还有查找书、显示图书目录的功能，并且以该书的书号为关键字建立一个B_树。

输入形式：

书名和作者名分别采用一个长度为15的字符型数组来储存，如：Title: Data Structuers ;  Writer: CAC

书的现存量和总存量为整型，取值范围为0~32767 ，CurrentAmount:10  ;  TotalAmount: 12

书的简介采用一个长度为30的字符型数组来储存，如：Using C and C++

读者的借书证号采用一个长度为20的字符型数组来储存, 如：2001374402

借书和还书日期还有今天的日期的年，月，日为整型，如：Year: 2002 ; Month: 5 ; Day: 12

    输出形式：

显示书的信息：

Title: Data Structuers 

Writer: CAC

CurrentAmount:10 

TotalAmount: 12

Briefinstruction: Using C and C++

显示读者借书信息：

You borrow this book is in 2002-5-16

You should pay it back in 2002-6-16

Today is 2003-2-13

So you have go out the payback day，You have to pay  24.4 Yuan.

     测试数据：

     入库书号： 35，16，18，70，5，22，60，13，17，12，45，25，42，15，90

     清除：45，90，50，22，42

2． 概要设计

struct data       /*记录借书和还书日期的结构体类型*/

{ int year;       /*记录年*/

  int month;     /*记录月*/

  int day;       /*记录日*/

};

struct ReaderNode     /*记录读者信息的结构体类型*/

{

  char num[20];          /*记录读者的借书证号*/

  struct data  bro;        /*记录读者的借书日期*/

  struct data  back;       /*记录读者的还书日期*/

};

struct  BookNode     /*记录书的信息的结构体类型*/

{

  char title[15];        /*记录书名*/

  char writer[15];      /*记录作者*/

  int currentnum;      /*书现存量*/

  int totalnum;        /*书总存量*/

  char brief[30];       /*书的简介*/

  struct ReaderNode reader[20]; /*借阅该书的读者记录*/

};

struct TreeNode        /*B树的结构体类型*/

{

   int n;     /* 记录结点中的关键字个数 */

   struct TreeNode *prt;        /* 指向父结点的指针域 */

   int key[2*m];                /* key[0...n-1],2m个关键字域 (注：关键字即书号) */

   struct BookNode *rec[2*m];    /* rec[0...n-1],2m个指向书的信息结点的指针域 */

   struct TreeNode *link[2*m+1]; /* link[0...n],2m+1个指向子结点的指针域 */

};

3. 详细设计

/*函数返回包含关键字x的结点的储存地址，指针变量k指向的变量的是存放关键字x在存储结点*/

/*中的位置，指针变量flag指向的变量值为0时，表示查找失败，1时，表示查找成功*/

struct TreeNode *mbsearch(struct TreeNode *bth,int x,int *k,int *flag)

{

  struct TreeNode *p,*q;

  p=bth; *flag=0; q=p;     /* 由头结点开始查找 */

  while( (p!=NULL) && (*flag==0) )   /* 当结点不为空，并且还没找到该关键字时不断向下查找 */

  {

    *k=1;q=p;   

    while( (*k < q->n) && ( q->key[*k-1] < x) ) *k=*k+1;  /*比该结点关键字数少并且比x小时，找该结点下一个关键字*/

    if( q->key[*k-1]==x) *flag=1;  /* 查找成功 */

    else if( ( *k==q->n ) && ( q->key[*k-1] < x) ) {p=q->link[*k];p->prt=q;} /* 延最后一个指针域 */

    else { p=q->link[*k-1]; p->prt=q;*k=*k-1;} /* 延第k个指针域找下一个个结点 */

  }

  return(q);

}

/* 以递归调用的方式先序遍历该树 */

void mball(struct TreeNode *bth,int t)

{

  struct TreeNode *p;

  int i,j,k;

  p=bth;      /* 当前指向要输出的结点的指针 */

  if(p->n!=0)  /* 结点非空 */

  {

    for(i=0;i<p->n;i++)

     {k=t;

      mball(p->link[i],t+5);  /* 顺序递归访问该结点的各个子结点 */

      printf("/t%-3d",p->key[i]);   /* 顺序输出该结点的关键字 */

      for(j=0;j<=t;j++) printf("/367");printf("/n"); /*打印记录的长度*/

      t=k;

     }

      mball(p->link[p->n],t+5);

  }

}

/* 函数返回插入后B树的头指针 */

struct TreeNode *mbinsert(struct TreeNode *bth)

{

  int flag,j,k,t;

  int y,x,z;

  struct TreeNode *p,*q,*u,*s;

  struct BookNode *r,*l;

  clrscr();

  printf("/n/tPlease input the book you want to insert: ");

  scanf("%d",&x);       /* 需要插入的关键字 */

  q=mbsearch(bth,x,&k,&flag);  /*查找关键字该插入的地方*/

  if(flag==1)   /*若找到有相同的关键字*/

    {

      printf("/n/tHas %d this kind of book,do you want to add another?(y/n)/n",(q->rec[k-1])->totalnum);

      z=getch();

      if(z=='y'||z=='Y')        /*是否加多一本同类的书入库*/

      {

(q->rec[k-1])->totalnum++; (q->rec[k-1])->currentnum++;  /*现存量和总存量各加一*/

printf("/n/tNow total has %d this kind of book,",(q->rec[k-1])->totalnum);

printf("/n/tand current has %d in the library.",(q->rec[k-1])->currentnum);

      }

      return(bth);  /*返回头指针*/

    }

  r=InputNode(bth);  /*调用InputNode函数输入书的信息，接收返回新开辟的结点的地址*/

  if(bth==NULL) /*若B树为空*/

    {

      bth=p=(struct TreeNode *)malloc(sizeof(struct TreeNode));/*为根结点开辟一个TreeNode类型的空间*/

      p->n=1; p->key[0]=x; p->rec[0]=r;p->prt=NULL;/*插入关键字*/

      for(j=1;j<=2*m+1;j++) p->link[j-1]=NULL; /*所有指针域置空*/

      return(p);  /* 返回头指针 */

    }

  p=NULL; t=0;  /*t为分裂标志*/

  while(t==0)  /*当分裂标志为仍0时循环*/

  {

    if(k==q->n) {y=x;l=r;u=p;} /*要插入到该结点的最后，记录x和子结点指针*/

    else               /*插入到该结点中间的某个位置*/

    {

      y=q->key[q->n-1]; l=q->rec[q->n-1];u=q->link[q->n]; /*把最后一个关键字，书信息指针，子结点指针记录，以插入后不会因后移而被覆盖*/

      for(j=(q->n)-1; j>=k+1; j--) /*插入位置后的元素全部后移*/

      {

q->key[j]=q->key[j-1];q->rec[j]=q->rec[j-1];q->link[j+1]=q->link[j];

      }

      q->key[k]=x;q->rec[k]=r;q->link[k+1]=p; /*插入x，书信息指针，子结点指针*/

      if(p!=NULL) p->prt=q; /*改变子结点的父结点的指针的指向*/

    }

    if(q->n<2*m)    /*该结点的关键字数不超过最大关键字数，满足插入条件*/

    {

      q->n=(q->n)+1; /*关键字数加1*/

      t=1;            /*分裂标志置1，插入完成*/

      q->key[(q->n)-1]=y;  q->rec[(q->n)-1]=l; q->link[q->n]=u;    /*把记录放到最后一个关键字域，书信息指针域，子结点指针域*/

      if(u!=NULL) u->prt=q;   /*改变子结点的指向父结点的指针的指向*/

    }

    else  /*若该结点的关键字数大于最大关键字数，则需要分裂*/

    {

      p=(struct TreeNode *)malloc(sizeof(struct TreeNode)); /*开辟一个TreeNode类型的空间供分裂后存关键字*/

      p->n=m; q->n=m; p->prt=q->prt;   /*设原结点和新结点关键字数各为m，并指明新结点的父结点和原结点相同*/

      x=q->key[m];r=q->rec[m];   /*把中间的关键字记录，作下一次循环时在父结点插入用*/

      for(j=1;j<=m-1;j++)

      {

p->key[j-1]=q->key[m+j];p->rec[j-1]=q->rec[m+j];p->link[j-1]=q->link[m+j];   /*将原结点后半关键字，及相应的指针移到新结点中*/

if(q->link[m+j]!=NULL) (q->link[m+j])->prt=p;   /*改变子结点的指向父结点的指针的指向*/

      }

      p->link[m-1]=q->link[2*m];    /*原结点最后一个指向子结点的指针赋给新结点第m-1个指向子结点的指针*/

      p->link[m]=u;   /*把记录下来的赋给新结点*/

      p->key[m-1]=y;

      p->rec[m-1]=l;

      if(u!=NULL) u->prt=p;    /*改变子结点的指向父结点的指针的指向*/

      for(j=m+2;j<=2*m+1;j++)

      {

q->link[j-1]=NULL;p->link[j-1]=NULL;    /*新旧结点插入关键字后相应子结点指针置空*/

      }

      if(q->prt==NULL)           /*若已经分裂到根结点*/

      {

s=(struct TreeNode *)malloc(sizeof(struct TreeNode));   /*开辟一个TreeNode类型的空间供头结点分裂用*/

s->key[0]=x; s->rec[0]=r;

s->link[0]=q; s->link[1]=p;

s->n=1; s->prt=NULL; q->prt=s; p->prt=s;  /*插入相应的值和指针*/

for(j=3;j<=2*m+1;j++) s->link[j-1]=NULL;

bth=s; t=1;   /*插入完成，置分裂标志1*/

      }

      else       /*未分裂到根结点，则寻找父结点的插入位置*/

      {

q=q->prt; k=1;

while((k<=q->n)&&(q->key[k-1]<x)) k=k+1;

k=k-1;

      }

    }

  }

  return(bth);   /*返回头结点的指针*/

}

/*删除B树中元素的函数，并返回B树头指针*/

struct TreeNode *mbdel(struct TreeNode *bth)

{

  int flag,j,k,t;

  int x,y;

  struct TreeNode *u,*s,*p,*q;

  struct BookNode *r,*l;

  clrscr();

  printf("/n/tPlease input the book you want to delete: ");

  scanf("%d",&x);

  q=mbsearch(bth,x,&k,&flag);       /*寻找删除关键字的位置*/

  if(flag==0) { printf("/n/tThe book is not exist!/n"); return(bth);} /*无该关键字，出错返回*/

  p=q->link[k];         /*找要删除关键字的右边的子结点*/

  if(p!=NULL)           /*若要删除的关键字不在叶子结点上*/

  {

    while(p->link[0]!=NULL) p=p->link[0];  /*则找该关键字的右子结点的最左子结点*/

    q->key[k-1]=p->key[0]; /*找到后与把对应记录赋给该被删除的关键字*/

    q->rec[k-1]=p->rec[0];

    k=1;q=p;

  }

  for(j=k;j<=q->n-1;j++)    /*删除位置后的关键字逐个向前移一位*/

  {

  q->key[j-1]=q->key[j];

  q->rec[j-1]=q->rec[j];

  }

  q->n=q->n-1;

  while ((q!=bth)&&(q->n<m))  /*若删除该关键字后该结点的关键字数少于最少关键字数，并且该结点不是头结点*/

  {

    p=q->prt;j=1;

    while(p->link[j-1]!=q) j=j+1;   /*寻找该结点在父结点中的指针位置*/

    if((j<=p->n)&&((p->link[j])->n>m))    /* 若右兄弟结点关键字数大于最少关键字数，则从右兄弟结点中借关键字*/

    {

      s=p->link[j];    /*借右兄弟结点的最左边的关键字*/

      y=s->key[0];

      l=s->rec[0];

      u=s->link[0];

      for(k=1;k<=s->n-1;k++)   /*其余关键字与相应的指针各左移一位*/

{

 s->key[k-1]=s->key[k];

 s->rec[k-1]=s->rec[k];

 s->link[k-1]=s->link[k];

}

      s->link[s->n-1]=s->link[s->n]; /*不要忘最后的指针也要移*/

      s->link[s->n]=NULL;

      s->n=s->n-1; q->n=q->n+1;    /*改变两个结点中的关键字个数*/

      q->key[q->n-1]=p->key[j-1];  /*父结点中的紧靠上移关键字的关键字下移到被删除结点的最后*/      q->rec[q->n-1]=p->rec[j-1];

      q->link[q->n]=u;

      p->key[j-1]=y;            /*借的关键字到父结点*/

      p->rec[j-1]=l;

      if(u!=NULL) u->prt=q;     /*改变被借关键字下一层结点中指向父结点的指针*/

    }

   else if((j>1)&&((p->link[j-2])->n>m))  /*若左兄弟结点关键字数大于最少关键字数，则从左兄弟结点中借关键字*/

   {

     s=p->link[j-2];

     q->n=q->n+1;

     q->link[q->n]=q->link[q->n-1];

     for(k=q->n-1;k>=1;k--)      /*空出被删除结点中第一个位置*/

       {

q->key[k]=q->key[k-1];

q->rec[k]=q->rec[k-1];

q->link[k]=q->link[k-1];

       }

     q->key[0]=p->key[j-2];      /*父结点中的紧靠上移关键字的关键字下移到被删除的结点的第一*/

     q->rec[0]=p->rec[j-2];

     u=s->link[s->n];

     q->link[0]=u;

     if(u!=NULL) u->prt=q;    /*改变被借关键字下一层结点中指向父结点的指针*/

     p->key[j-2]=s->key[s->n-1];    /*借的关键字到父结点*/

     p->rec[j-2]=s->rec[s->n-1];

     s->link[s->n]=NULL;

     s->n=s->n-1;

   }

   else    /*左和右兄弟结点关键字数都不大于最少关键字数，则需要合拼*/

   {

     if(j==p->n+1)   /*若该结点是其父结点的最右孩子*/

       { q=p->link[j-2]; s=p->link[j-1]; j=j-1;}  /*赋一指针给左兄弟*/

     else s=p->link[j];   /*否则指针赋给右孩子*/

     q->key[q->n]=p->key[j-1];    /*把父结点关键字赋给子结点*/

     q->rec[q->n]=p->rec[j-1];

     t=q->n+1;

     for(k=1;k<=s->n;k++)         /*两个结点合拼*/

       { q->key[t+k-1]=s->key[k-1];

 q->rec[t+k-1]=s->rec[k-1];

 u=s->link[k-1];

 q->link[t+k-1]=u;

 if(u!=NULL) u->prt=q;  /*改变指向父结点的指针*/

       }

     u=s->link[s->n]; q->link[t+s->n]=u;

     if(u!=NULL) u->prt=q;

     q->n=2*m;

     free(s);  /*合拼完毕释放结点*/

     for(k=j;k<=p->n-1;k++)  /*其后的关键字和指针逐个前移*/

       {

p->key[k-1]=p->key[k];

p->rec[k-1]=p->rec[k];

p->link[k]=p->link[k+1];

       }

     p->n=p->n-1; s=q; q=p;

     }

   }

   if((q==bth)&&(q->n==0))   /*若删除的是头结点而且删除后关键字数为0*/

     { free(bth); bth=s; bth->prt=NULL; /*删除头结点，并把s的结点作头结点*/

       if(s->n==0) {bth=NULL; free(s); } /*空树*/

     }

   printf("/n/tThe book has been delete !");

   return(bth);

}

/*输入相应于该关键字的书信息的函数，返回BookNode类型的书信息结点的指针*/

struct BookNode *InputNode()

{

  struct BookNode *p;

  int i;

  p=(struct BookNode *)malloc(sizeof(struct BookNode));   /*为相应的关键字开辟一个BookNode类型的指针*/

  clrscr();

  fflush(stdin);  /*把scanf自动形成的输入流清除，否则流指针不会返回头处*/

  printf("/n/tInput the title: ");     /*相应值的输入*/

  gets(p->title);

  printf("/n/tInput the writer: ");

  gets(p->writer);

  printf("/n/tInput the book current amount: ");

  scanf("%d",&p->currentnum);

  printf("/n/tInput the book total amount: ");

  scanf("%d",&p->totalnum);

  fflush(stdin);

  printf("/n/tInput the book brief instruction: ");

  gets(p->brief);

  for(i=0;i<20;i++)

  (p->reader[i]).num[0]='/0';   /*用'/0'来初始化借该书的读者证号，表示一开始时没人借书*/

  return(p);  /*返回该结点指针*/

}

/*查找并输出书的信息的函数，无返回值*/

void OutputNode(struct TreeNode *bth)

{

  struct TreeNode *q;

  struct BookNode *p;

  int k;

  int x;

  int flag;

  clrscr();

  printf("/n/tPlease input the book you want to search: ");

  scanf("%d",&x);

  q=mbsearch(bth,x,&k,&flag);    /*寻找需要查找的书的位置*/

  if(flag==1)

  {

  p=q->rec[k-1];

  printf("/n/tTitle:             %s",p->title);    /*输出相关内容*/

  printf("/n/tWriter:            %s",p->writer);

  printf("/n/tCurrentAmount:     %d",p->currentnum);

  printf("/n/tTotalAmount:       %d",p->totalnum);

  printf("/n/tBriefIntroduction: %s/n",p->brief);

  }

  else printf("/n/tThis book is not exist!");

}

/*借书函数，无返回值*/

void borrow(struct TreeNode *bth)

{

  struct TreeNode *q;

  struct BookNode *p;

  struct ReaderNode *r;

  int i,k, x, flag,t;

  clrscr();

  printf("/n/tPlease input the book you want to borrow: ");

  scanf("%d",&x);

  q=mbsearch(bth,x,&k,&flag);  /*寻找需要查找的书的位置*/

  if(flag==1)  /*找到并显示该书的信息*/

  {

  p=q->rec[k-1];

  printf("/n/tDo you want this book ?(y/n)");

  printf("/n/tTitle:             %s",p->title);

  printf("/n/tWriter:            %s",p->writer);

  printf("/n/tCurrentAmount:     %d",p->currentnum);

  printf("/n/tTotalAmount:       %d",p->totalnum);

  printf("/n/tBriefIntroduction: %s",p->brief);

  t=getch();

  if(t=='y'||t=='Y')

  {

    if( (p->currentnum)==0) printf("/n/tSorry,this book has all borrow out...");

    else

    {

      clrscr();

      for(i=0;i<20;i++) if( (p->reader[i]).num[0]=='/0') break;

      printf("/n/tPlease input your certificate number: ");  /*输入借书证号*/

      scanf("%s",(p->reader[i]).num);

      printf("/n/tPlease input the borrow data: "); /*输入借书日期*/

      printf("/n/tYear:  ");

      scanf("%d",&((p->reader[i]).bro.year));

      printf("/tMonth: ");

      scanf("%d",&((p->reader[i]).bro.month));

      printf("/tDay:   ");

      scanf("%d",&((p->reader[i]).bro.day));

      printf("/n/tPlease input the payback data: "); /*输入还书日期*/

      printf("/n/tYear:  ");

      scanf("%d",&((p->reader[i]).back.year));

      printf("/tMonth: ");

      scanf("%d",&((p->reader[i]).back.month));

      printf("/tDay:   ");

      scanf("%d",&((p->reader[i]).back.day));

      p->currentnum--;        /*现存书量减1*/

      printf("/n/tYou have borrow the book.");}

    }

  }

  else printf("/n/tThis book is not exist!"); /*没找到*/

}

/*还书函数，无返回值*/

void payback(struct TreeNode *bth)

{

  struct TreeNode *q;

  struct BookNode *p;

  int i,k, x, flag,t,j;

  int year,month,day,d;

  float pay;

  char temp[20];

  clrscr();

  printf("/n/tPlease input the book you want to payback: ");

  scanf("%d",&x);

  q=mbsearch(bth,x,&k,&flag);    /*寻找需要还的书的位置*/

  if(flag==1)

  {

  p=q->rec[k-1];

  printf("/n/tDo you want to payback this book ?(y/n)");

  printf("/n/tTitle:             %s",p->title);

  printf("/n/tWriter:            %s",p->writer);

  printf("/n/tCurrentAmount:     %d",p->currentnum);

  printf("/n/tTotalAmount:       %d",p->totalnum);

  printf("/n/tBriefIntroduction: %s",p->brief);

  t=getch();

  if(t=='y'||t=='Y')

  {

    if( (p->currentnum) >=(p->totalnum) )

    printf("/n/tYou want to offer a more book ??/n");

    else

    {

      clrscr();

      printf("/n/tPlease input your certificate number: ");

      scanf("%s",temp);

      j=0;

      for(i=0;i<20;i++)

      {

if(! (strcmp(temp,(p->reader[i]).num))) {j=1;break;} /*查找是否有该人借书*/

      }

      if(j==0) {printf("/n/tYou haven't borrow this book.");return;}  /*该借书证号的人没借书*/

      printf("/n/tToday is:");   /*输入当天日期*/

      printf("/n/tYear:  ");

      scanf("%d",&year);

      printf("/tMonth: ");

      scanf("%d",&month);

      printf("/tDay:   ");

      scanf("%d",&day);

      d=0;

      if(year<(p->reader[i]).back.year) d=1; /*判断是否已过了还书日期*/

      if(year<=(p->reader[i]).back.year && month<(p->reader[i]).back.month) d=1;

      if(year<=(p->reader[i]).back.year && month<=(p->reader[i]).back.month && day<(p->reader[i]).back.day) d=1;

      if(d==0)

      {

clrscr();

pay=(year-(p->reader[i]).back.year)*365+(month-(p->reader[i]).back.month)*30+(day-(p->reader[i]).back.day);

        printf("/n/tYou borrow this book is in %d-%d-%d",(p->reader[i]).bro.year,(p->reader[i]).bro.month,(p->reader[i]).bro.day);  /*打印借书和还书日期*/

printf("/n/tYou should pay it back in   %d-%d-%d",(p->reader[i]).back.year,(p->reader[i]).back.month,(p->reader[i]).back.day);

printf("/n/tToday is                   %d-%d-%d",year,month,day);

printf("/n/n/tSo you have go out the payback day");

printf("/n/tYou have to pay %2.1f Yuan.",0.1*pay); /*过期一天还1角钱*/

      }

      (p->reader[i]).num[0]='/0'; /*已还，清除该读者借书记录*/

      p->currentnum++;  /*现存书量加1*/

      printf("/n/tYou have payback the book.");

    }

  }

  }

  else printf("/n/tYou want to payback an inexistence book ???");  /*没可能还一本没库存的书*/

}

/*显示菜单函数，返回接收的字符*/

char menu(void)

{

  clrscr();

  printf("/n/t     ****************************************************");

  printf("/n/t     ***********   Liberary management menu   ***********");

  printf("/n/t     ****************************************************");

  SS

  printf("1.Add a book");

  SS

  printf("2.Clearup a book");

  SS

  printf("3.Display the tree");

  SS

  printf("4.Search a book");

  SS

  printf("5.Borrow a book");

  SS

  printf("6.Payback a book");

  SS

  printf("7.exit");

  SS

  printf("please select: ");

  return getch();

}

void main()

{

  char c,t;

  int x;

  int k,flag,p=1;

  struct TreeNode *bth=NULL;

  window(1,1,80,25);

  textmode(MONO);

  textbackground(BLACK);

  textcolor(WHITE);

  while(1)

  {

  c=menu(); /*显示菜单*/

  putch(c);

  getch();

  switch(c)  /*按菜单函数返回值调用各相应函数*/

  {

  case '1': bth=mbinsert(bth);

    clrscr();

    printf("/n/tThe Btree is:/n");

    mball(bth,p);

    break;

  case '2': bth=mbdel(bth);

    clrscr();

    printf("/n/tThe Btree is:/n");

    mball(bth,p);

    break;

  case '3': clrscr();

    printf("/n/tThe Btree is:/n");

    mball(bth,p);

    break;

  case '4': OutputNode(bth);

    break;

  case '5': borrow(bth);

    break;

  case '6': payback(bth);

    break;

  case '7': clrscr();

    printf("/n/tDo you want to return to DOS?(y/n)");

    t=getch();

    if(t=='y'||t=='Y') exit(0);

    break;

  defult  :break;

  }

  printf("/n/tPress any key to main menu....");

  getch();

}

}

4. 调试分析

   1）在第3题后另一次深刻感到TC跟踪的作用，在关键字插入需要分裂，还有删除关键字需合拼时很容易找错父亲结点，有时找错得真是莫名其妙，故不能忽视到一定时候要从新定义某结点的父亲结点；孩子的分配问题也需要注意，要顾及关键字左右两指针的孩子，曾好几次漏了右边指针的孩子，还有就是合拼后还有改头结点后一定要把结点free掉。

2）算法上不算太好吧，插入经多次测试已没问题，但删除时会偶尔产生死循环，原因到此为止不明，

   需对程序的改进是多方面的，首先是作为一个图书馆管理系统，可以进行load,save是很必要的，我试了很久，save可以了，但load出来很困难，因把每个结点的关键字按原先记录的顺序存放还可以，但需要重新为每个结点的指针域找回它的父亲和孩子真的很困难，我技术差，实现不了， 还有就是不能实现用户对自己现在借了哪几本书作查询，还有借书和还书时的日期需要自行输入，计费系统略显简单……….

3) 最深刻的体会就是要做好一条程序好难！很浪费时间！强烈要求如果出这些题给下一届学生做的话，允许他们放完假再交，不但有利于他们考好四级，而且能让他们本来颓废的放假时间充分利用来做程序，放假那么多空闲时间拿来做程序才能真正把程序搞好。

使用说明：

1． 功能1为添加一本书，输入如下：

Please input the book you want to insert:  31   (添加书号)

Input the Title: Data Structuers 

Input the Writer: CAC

Input the CurrentAmount:10 

Input the TotalAmount: 12

Input the Briefinstruction: Using C and C++

2. 功能2为从库存中删除一本书，输入如下：

  Please input the book your want to delete: 31

3. 功能3为显示现时B树的状态.

4. 功能4为查找库存中的一本书的信息，输入如下：

Please input the book you want to search: 31

5. 功能5 为借书，输入如下：

Please input the book you want to borrow: 31

Do you want this book(y/n): y

Please input your certificate number: 2001374402

Please input the borrow data: 

Year:2003

        Month:4

        Day:22

        Please input the payback data:

        Year:2003

        Month:5

        Day:21

6. 功能6为归还一本书，输入如下：

Please input the book you want to payback: 31

Do you want to payback this book(y/n): y

Please input your certificate number: 2001374402

Today is:

Year:2003

Month:5

Day: 29

7. 功能7为退出。

测试结果：

选择功能4，显示书的信息：

Title: Data Structuers 

Writer: CAC

CurrentAmount:10 

TotalAmount: 12

Briefinstruction: Using C and C++

选择功能6，超时还书时显示读者借书信息：

You borrow this book is in 2002-5-16

You should pay it back in 2002-6-16

Today is 2003-2-13

So you have go out the payback day，You have to pay  24.4 Yuan.

      选择功能3，显示添加测试数据后的B树如下：

5  ﹦﹦﹦﹦﹦﹦﹦﹦﹦﹦﹦﹦

12 ﹦﹦﹦﹦﹦﹦﹦﹦﹦﹦﹦﹦

13 ﹦﹦﹦﹦﹦﹦﹦

15 ﹦﹦﹦﹦﹦﹦﹦﹦﹦﹦﹦﹦

16 ﹦﹦﹦﹦﹦﹦﹦

17 ﹦﹦﹦﹦﹦﹦﹦﹦﹦﹦﹦﹦

18 ﹦﹦

22 ﹦﹦﹦﹦﹦﹦﹦﹦﹦﹦﹦﹦

25 ﹦﹦﹦﹦﹦﹦﹦﹦﹦﹦﹦﹦

35 ﹦﹦﹦﹦﹦﹦﹦

42 ﹦﹦﹦﹦﹦﹦﹦﹦﹦﹦﹦﹦

45 ﹦﹦﹦﹦﹦﹦﹦﹦﹦﹦﹦﹦

50 ﹦﹦

60 ﹦﹦﹦﹦﹦﹦﹦﹦﹦﹦﹦﹦

70 ﹦﹦﹦﹦﹦﹦﹦

90 ﹦﹦﹦﹦﹦﹦﹦﹦﹦﹦﹦﹦

删除测试数据后如下：

5  ﹦﹦﹦﹦﹦﹦﹦﹦﹦﹦﹦﹦

12 ﹦﹦﹦﹦﹦﹦﹦﹦﹦﹦﹦﹦

13 ﹦﹦﹦﹦﹦﹦﹦

15 ﹦﹦﹦﹦﹦﹦﹦﹦﹦﹦﹦﹦

16 ﹦﹦﹦﹦﹦﹦﹦

17 ﹦﹦﹦﹦﹦﹦﹦﹦﹦﹦﹦﹦

18 ﹦﹦

25 ﹦﹦﹦﹦﹦﹦﹦﹦﹦﹦﹦﹦

35 ﹦﹦﹦﹦﹦﹦﹦

60 ﹦﹦﹦﹦﹦﹦﹦﹦﹦﹦﹦﹦

70 ﹦﹦﹦﹦﹦﹦﹦﹦﹦﹦﹦﹦

课程小结

 通过这次课程设计，使我对C语言有了更进一步的认识和了解，要想学好它要重在实践，要通过不断的上机操作才能更好地学习它，再有对C语言的一些标准库函数不太了解，还有对函数调用的正确使用不够熟悉，还有对C语言中经常出现的错误也不了解。

所以后在学习过程中，我会更加注视实践操作，使自己便好地学好计算机。

参考文献

王立萍.基于B／S的图书管理系统的设计与开发[J].承德民族师专学报,2004,24(2):27-28. 

李为华 苏辉 曹庆萍 陈帆.基于B／S结构的图书管理系统设计[J].信阳师范学院学报：自然科学版,2005,18(2):222-225. 

王鹏 雷富强 孙震.ASP网络编程实例[M].北京:中国电力出版社,2001..