file.c

实现两个数相加

  #include   <stdio.h>   
  #include   <malloc.h>   
  #include   <math.h>   
    
  struct   Num   {   
                            int   e;   
                            struct   Num   *prir,*next;   
                          };   
    
  main()   
  {   
      struct   Num   *num1,*num2,*sum;   
    
      struct   Num   *create(struct   Num   *n);   
      void   output(struct   Num   *n);   

      struct   Num   *add_Num(struct   Num   *n1,struct   Num   *n2);   
    
      num1=(struct   Num   *)malloc(sizeof(struct   Num));   
      num2=(struct   Num   *)malloc(sizeof(struct   Num));   
      num1=create(num1);   
      num2=create(num2);   
      sum=add_Num(num1,num2);   
      output(sum);   
    }   
    
  void   output(struct   Num   *n)   
  {   
      struct   Num   *p;   
    
      if(n->e<0)   printf("-");   
      printf("%d,",n->next->e);   
      p=n->next->next;   
      while(p!=n->next)   
      {   
          if(p->e<1000)   printf("0");   
          if(p->e<100)   printf("0");   
          if(p->e<10)   printf("0");   
          printf("%d,",p->e);   
          p=p->next;   
        }   
      printf("\b   \b\n");   
    }   
    
  struct   Num   *create(struct   Num   *n)   
  {   
      struct   Num   *p,*t;   
      int   e,iscontinue;   
    
      t=(struct   Num   *)malloc(sizeof(struct   Num));     /*第一个结点*/   
      iscontinue=scanf("%d",&e);   
      if(e<0)   n->e=-1;   
      else   n->e=1;   
      t->e=n->e*e;   
      n->next=t;   
      t->next=t;   
      t->prir=t;   
      n->prir=NULL;   
    
      p=n->next;   
      while(iscontinue!=0)         /*以后结点*/   
      {   
          if(getchar()==',')   iscontinue=scanf("%d",&e);   
          else   break;   
          t=(struct   Num   *)malloc(sizeof(struct   Num));   
          t->e=e;   
          p->next=t;   
          t->prir=p;   
          t->next=n->next;   
          n->next->prir=t;   
          p=p->next;   
        }   
      return(n);   
    }   
    
  struct   Num   *add_Num(struct   Num   *n1,struct   Num   *n2)   
  {   
      struct   Num   *p1,*p2,*t,*s,*sum;   
      int   e1,e2,carry;   
    
      p1=n1->next->prir;   
      p2=n2->next->prir;   
      e1=n1->e;   
      e2=n2->e;   
    
      sum=(struct   Num   *)malloc(sizeof(struct   Num));   
      sum->e=1;   
      sum->prir=NULL;   
      s=(struct   Num   *)malloc(sizeof(struct   Num));   
      s->e=p1->e*e1+p2->e*e2;   
      p1=p1->prir;   
      p2=p2->prir;   
      if(e1*e2==1)   
      {   
          sum->e=e1;   
          s->e=abs(s->e);   
          if(s->e>=10000)   
          {   
              s->e-=10000;   
              carry=1;   
            }   
          else   carry=0;   
        }   
      else   
          if(s->e>=0)   carry=0;   
          else   
          {   
              s->e+=10000;   
              carry=-1;   
            }   
      t=s;   
      s->next=s;   
      s->prir=s;   
      sum->next=s;   
    
      while(p1!=n1->next->prir&&p2!=n2->next->prir)   
      {   
          s=(struct   Num   *)malloc(sizeof(struct   Num));   
          s->e=p1->e*e1+p2->e*e2+sum->e*carry;   
          p1=p1->prir;   
          p2=p2->prir;   
          if(e1*e2==1)   
          {   
              sum->e=e1;   
              s->e=abs(s->e);   
              if(s->e>=10000)   
              {   
                  s->e-=10000;   
                  carry=1;   
                }   
              else   carry=0;   
            }   
          else   
              if(s->e>=0)   carry=0;   
              else   
              {   
                  s->e+=10000;   
                  carry=-1;   
                }   
          s->next=t;   
          t->prir=s;   
          s->prir=sum->next;   
          sum->next->next=s;   
          t=t->prir;   
        }   
    
      if(p1==n1->next->prir)   
          while(p2!=n2->next->prir)   
          {   
              s=(struct   Num   *)malloc(sizeof(struct   Num));   
              s->e=p2->e*e2+sum->e*carry;   
              p2=p2->prir;   
              if(e1*e2==1)   
              {   
                  sum->e=e1;   
                  s->e=abs(s->e);   
                  if(s->e>=10000)   
                  {   
                      s->e-=10000;   
                      carry=1;   
                    }   
                  else   carry=0;   
                }   
              else   
                  if(s->e>=0)   carry=0;   
                  else   
                  {   
                      s->e+=10000;   
                      carry=-1;   
                    }   
              s->next=t;   
              t->prir=s;   
              s->prir=sum->next;   
              sum->next->next=s;   
              t=t->prir;   
            }   
      if(p2==n2->next->prir)   
          while(p1!=n1->next->prir)   
          {   
              s=(struct   Num   *)malloc(sizeof(struct   Num));   
              s->e=p1->e*e1+sum->e*carry;   
              p1=p1->prir;   
              if(e1*e2==1)   
              {   
                  sum->e=e1;   
                  s->e=abs(s->e);   
                  if(s->e>=10000)   
                  {   
                      s->e-=10000;   
                      carry=1;   
                    }   
                  else   carry=0;   
                }   
              else   
                  if(s->e>=0)   carry=0;   
                  else   
                  {   
                      s->e+=10000;   
                      carry=-1;   
                    }   
              s->next=t;   
              t->prir=s;   
              s->prir=sum->next;   
              sum->next->next=s;   
              t=t->prir;   
            }   
    
      if(carry!=0)   
      {   
          s=(struct   Num   *)malloc(sizeof(struct   Num));   
          s->e=1;   
          carry=0;   
          s->next=t;   
          t->prir=s;   
          s->prir=sum->next;   
          sum->next->next=s;   
          t=t->prir;   
        }   
      sum->next=t;   
      do   
      {   
          if(t->e==0)   
          {   
              sum->next=t->next;   
              t->next->prir=t->prir;   
              t->prir->next=t->next;   
              free(t);   
            }   
          else   break;   
          t=sum->next;   
        }while(t!=sum->next->prir);   
      return(sum);   
    }