关于任意长浮点数相加的小程序

  这个程序是实习老师要求的作业，这几天抽空写了。希望大家看看给点意见！ 

先大致讲解下思路：构建双链表，将数据放进双链表中，然后在add函数中，将小数点对齐（将整数添加小数点，然后补齐零）然后补齐零。
#include <stdio.h> 
#include <stdlib.h> 
#include <malloc.h> 


/* 说明：本程序是关于任意长浮点型数或者整数相加的程序。*/ 
/* 创建数据结构 */ 
struct node 
{ 
    int number; 
    struct node *next;/* 结点后继 */ 
    struct node *prior;/* 结点前驱 */ 
    int flag ; /* 结点进位 */ 
    int point; 
}; 
/* 接受输入的字符，转换成数字，创建结点，并链接成双链表 */ 
/*若输入的是小数点则单独保存*/ 
struct node * receiven(void) 
{    
      char ni = 'a'; 
      int k = 0; 
      struct node * head; 
      struct node * b; 
      struct node *d; 
      head = (struct node * ) malloc ( sizeof (struct node)); 
      d = (struct node * ) malloc ( sizeof (struct node)); 
      d = head; 
      while((ni = getchar())!='/n') 
       { 
           if( ni != '.') 
           { 
                   int i = 0; 
                   i = ni-'0'; 
                   b = (struct node * ) malloc ( sizeof (struct node)); 
                   b->number = i; 
                   b->flag = 0; 
                   b->point = 0; 
                   head->next = b; 
                   b->prior = head; 
                   head = b; 
           } 
           else 
           { 
               b = (struct node * ) malloc ( sizeof (struct node)); 
               b->number = 0; 
               b->flag = 0; 
               b->point = 1; 
               head->next = b; 
               b->prior = head; 
               head = b; 
           } 
       } 
       b->next = NULL; 
       return d; 
} 
/* 将所得到的两个保存浮点数的双链表相加 */ 
struct node * add(struct node * H,struct node * L) 
{ 
    int j = 0; 
    int k = 0; 
    int max2 = 0; 
    int min2 = 0; 
    int l = 0; 
    int m = 0; 
    int o1 = 0;/*表示第一个数的小数的长度*/ 
    int o2 = 0;/*表示第二个数的小数的长度*/ 
    /* j,k分别为两个双链表的长度 */ 
    struct node * q; 
    q = (struct node * ) malloc ( sizeof (struct node)); 
    struct node * r; 
    r = (struct node * ) malloc ( sizeof (struct node));    
    H = H->next; 
   while( (H != NULL)&&(H->point != 1) ) 
       { 
           q = H; 
           H = H->next; 
           j++; 
           o1++; 
       } 
   if( H != NULL ) 
    { 
        j = j - 1; 
        while( H != NULL ) 
        { 
           q = H; 
           H = H->next; 
           j++; 
        } 
    } 
    L = L->next; 
    while( (L != NULL)&&(L->point != 1) ) 
       {   
           r = L; 
           L = L->next; 
           k++; 
           o2++; 
       } 
       if( L != NULL) 
    { 
        k = k - 1; 
        while( L != NULL) 
        { 
           r = L; 
           L = L->next; 
           k++; 
        } 
    } 
    min2 = k > j? j : k; 
    max2 = k > j? k : j; 
    struct node *D; 
    D = (struct node * ) malloc ( sizeof (struct node)); 
    struct node * C; 
    for(l = 0;l < max2+4; l++) 
       { 
           C = (struct node * ) malloc ( sizeof (struct node)); 
           C->flag = 0; 
           C->point = 0; 
           D->next = C; 
           C->prior = D; 
           D = C; 
       } 
    C->next = NULL; 
    /*对浮点型数的小数部分进行对齐，使小数位数相等，不足处填零*/ 
    int p1 = 0;/*第一个双链表的小数部分的位数*/ 
    int p2 = 0;/*第二个双链表的小数部分的位数*/ 
    p1 = j - o1; 
    p2 = k - o2; 
    if(p1 == 0 ) 
    { 
           struct node * C3; 
           C3 = (struct node * ) malloc ( sizeof (struct node)); 
           C3->flag = 0; 
           C3->point = 1; 
           C3->number = 0; 
           q->next = C3; 
           C3->prior = q; 
           q = C3; 
           struct node * C4; 
           C4 = (struct node * ) malloc ( sizeof (struct node)); 
           C4->flag = 0; 
           C4->point = 0; 
           C4->number = 0; 
           q->next = C4; 
           C4->prior = q; 
           q = C4; 
           j++; 
           q->next = NULL; 
           p1 = 1; 
           
    } 
    if(p2 == 0) 
    { 
           struct node * C5; 
           C5 = (struct node * ) malloc ( sizeof (struct node)); 
           C5->flag = 0; 
           C5->point = 1; 
           C5->number = 0; 
           r->next = C5; 
           C5->prior = r; 
           r = C5; 
           struct node * C6; 
           C6 = (struct node * ) malloc ( sizeof (struct node)); 
           C6->flag = 0; 
           C6->point = 0; 
           C6->number = 0; 
           r->next = C6; 
           C6->prior = r; 
           r = C6; 
           k++; 
           r->next = NULL; 
           p2 = 1; 
    } 
    if( p1 > p2) 
    { 
        for(l = 0;l < ( p1 - p2 ); l++) 
        { 
           struct node * C1; 
           C1 = (struct node * ) malloc ( sizeof (struct node)); 
           C1->flag = 0; 
           C1->point = 0; 
           C1->number = 0; 
           r->next = C1; 
           C1->prior = r; 
           r = C1; 
           k++; 
        } 
       r->next = NULL; 
    } 
    if( p2 > p1) 
    { 
        for(l = 0; l < ( p2 - p1 ); l++) 
        {  
           struct node * C2; 
           C2 = (struct node * ) malloc ( sizeof (struct node)); 
           C2->flag = 0; 
           C2->point = 0; 
           C2->number = 0; 
           q->next = C2; 
           C2->prior = q; 
           q = C2; 
           j++; 
        } 
        q->next = NULL; 
    } 
    int min = k > j? j : k; 
    int max = k > j? k : j; 
    /*以小数点对齐，从小数最低位开始相加，遇到小数点则跳到下一个结点*/ 
    /*必须考虑如果a,b的位数大小不等，那么a的第一位的前驱的问题*/ 
        for(m = 0;m < min;m++) 
           { 
               if( q->point != 1) 
               { 
                   int u = 0; 
                   u = q->number + r->number + D->flag; 
                   D->number = ( u % 10 ); 
                   D = D->prior; 
                   D->flag = (u / 10); 
                   q = q->prior; 
                   r = r->prior; 
               } 
              else 
               { 
                   int i1 = 0; 
                   i1 = D->flag; 
                   D->point = 1; 
                   D = D->prior; 
                   D->flag = i1; 
                   q = q->prior; 
                   r = r->prior; 
               } 
           } 
               if( min == max ) 
               { 
                   int u3 = 0; 
                    u3 = q->number + r->number + D->flag; 
                    D->number = ( u3 % 10 ); 
                    D = D->prior; 
                    D->flag = (u3 / 10); 
                    if( D->flag != 0 ) 
                    { 
                        D->number = 1; 
                    } 
                    else 
                    { 
                        D = D->next; 
                    } 
               } 

    if( min != max ) 
       { 
            if(min == j) 
                { 
                    int u2 = 0; 
                    u2 = q->number + r->number + D->flag; 
                    D->number = ( u2 % 10 ); 
                    D = D->prior; 
                    D->flag = (u2 / 10); 
                    r = r->prior; 
                    for(j = min; j < max-1; j++) 
                        { 
                            int v = 0; 
                            v = r->number + D->flag; 
                            D->number = ( v % 10 ); 
                            D = D->prior; 
                            D->flag = (v / 10); 
                            r = r->prior; 
                        } 
                        int p2 = 0; 
                        p2 = r->number + D->flag; 
                        D->number = ( p2 % 10 ); 
                        D = D->prior; 
                        D->flag = (p2 / 10); 
                        if( D->flag != 0 ) 
                        { 
                            D->number = 1; 
                        } 
                        else 
                        { 
                            D = D->next; 
                        } 
                } 
            else 
            { 
                 int u1 = 0; 
                 u1 = q->number + r->number + D->flag; 
                 D->number = ( u1 % 10 ); 
                 D = D->prior; 
                 D->flag = (u1 / 10); 
                 q = q->prior; 
                 for(k = min; k < max-1;k++) 
                 { 
                         int p = 0; 
                         p = q->number + D->flag; 
                         D->number = ( p % 10 ); 
                         D = D->prior; 
                         D->flag = (p / 10); 
                         q = q->prior; 
                } 
                int i = 0; 
                i = q->number + D->flag; 
                D->number = ( i % 10 ); 
                D = D->prior; 
                D->flag = (i / 10); 
                if( D->flag != 0 ) 
                { 
                   D->number = 1; 
                } 
                else 
                { 
                    D = D->next; 
                } 
           }      
       } 
    /*对浮点数双链表进行输出*/ 
      if( min == max) 
      { 
          while(D != NULL) 
          { 
              if( D->point != 1) 
              { 
                  printf("%d",D->number); 
                  D = D->next; 
              } 
              else 
              { 
                  printf("."); 
                  D = D->next; 
               } 
           } 
      } 
      else 
      { 
           while(D != NULL) 
           { 
               if( D->point != 1) 
               { 
                   printf("%d",D->number); 
                   D = D->next; 
               } 
               else 
               { 
                   printf("."); 
                   D = D->next; 
               } 
            } 
      } 
        destroy(q); 
        destroy(r); 
        return D; 
  } 
/*显示双链表的长度*/ 
int linklength(struct node * a) 
{ 
    int j = 0; 
    a = a->next; 
    while(a != NULL ) 
      { if( a->point != 1) 
         { 
             a = a->next; 
             j++; 
         } 
         else 
         { 
             a = a->next; 
         } 
      } 
    return j; 
} 
/*回收双链表内存空间*/ 
int destroy(struct node *p) 
{ 
    struct node * temp; 
    while(p!=NULL) 
     { 
          temp = p; 
          p = p->next; 
          free(temp); 
     } 
     return 0; 
} 

int main() 
{ 
  /* 新建3个结点 */ 
  int lengi = 0; 
  int lengj = 0; 
  struct node *c; 
  struct node *d; 
  struct node *e; 
  printf("******************************************************************/n"); 
  printf("*                                                                */n"); 
  printf("*    本程序实现任意长两个浮点数相加，整数相加                    */n"); 
  printf("*  任意长整数浮点数相加                                          */n"); 
  printf("*                                                                */n"); 
  printf("******************************************************************/n"); 
  printf("Please input the first number you want to add !/n"); 
  c = receiven(); 
  lengi = linklength(c);  
  printf(" /nthe length of the number is %d/n",lengi); 
  printf( "Please input the second number you want to add !/n" ); 
  d = receiven(); 
  lengj = linklength(d);  
  printf(" /nthe length of the number is %d/n ",lengj); 
  printf(" the sum is !/n "); 
  e = add(c,d);  
  destroy(e); 
  system("PAUSE");
  return 0; 
}