yunsuan.txt

设计一个实现任意长的整数进行减法运算的演示程序。要求输入和输出每四位一组

1.宏定义及节点定义：

#define LEN sizeof(struct long_int)

struct long_int

{

       int data;

       int over;

       struct long_int *pro;

       struct long_int *next;

};

每个节点只存储四位十进制数字，即不超过9999的非负整数。双向链表有头指针，它的data值存储长整数的符号，1为正，-1为负，0代表长整数为0；它的over值存储除头节点节点的个数。其他节点的data值存储四位整数，over存储该四位整数溢出0~~9999范围的情况，一般over>0表示四位数超出9999，over<0表示四位数小于0。

2.生成链表函数：

函数C代码：

struct long_int *creat()

{

    struct long_int *head;

    head=(struct long_int *)malloc(LEN);

    if(head==NULL)

    printf("malloc error!\n");

    else

       {

        head->data=0;

        head->over=0;

        head->pro=head;

        head->next=head;

       }

    return(head);

}//creat

3.输出函数设计思路：

先判断长整数的正负，为负时先输出“—”号，然后按节点顺序依次输出，返回到头节点为止，输出前要判断各个节点data值的位数来判断先输出几个0。

函数C代码：

void print(struct long_int *head)

{

    struct long_int *p;

    p=head;

    if(head->next==head)

        printf("longint error!\n");

    else

       {

        if(head->data==-1)

             printf("-");   //判断长整数是否为正

        p=head->next;

           printf("%d",p->data);

           p=p->next;

           while(p!=head)

              {

                   //判断各个节点data值的位数来判断先输出几个0

if(p->data>=0&&p->data<10)

                printf("000%d",p->data);

                  if(p->data>=10&&p->data<100)

                         printf("00%d",p->data);

                  if(p->data>=100&&p->data<1000)

                printf("0%d",p->data);

            if(p->data>=1000)

                printf("%d",p->data);

                  p=p->next;

              }

       printf("\n");

       }

}//print

4.插入函数：

函数C代码：

void insert(struct long_int *head,struct long_int *p)

{  //将节点插到头节点后

    p->next=head->next;

    head->next->pro=p;

    head->next=p;

    p->pro=head;

    head->over=head->over+1;

}insert

5.删除函数：

函数C代码：

void del(struct long_int *head,struct long_int *p)

{  //删除头节点后的节点

    head->next=p->next;

    p->next->pro=head;

    free(p);

    head->over=head->over-1;

}//del

转换函数设计思路：

将长整数的字符形式转化成数字形式，存放到双向循环链表中，先判断长整数若为负，减去

字符串的第一位，将数字部分存到双向循环链表中。

函数C代码：

struct long_int *get(char s[])

{  //将长整数存到双向循环链表

       struct long_int *head,*q;

       int i,j,l=0;

       head=creat();

   //判断长整数的符号，并将信息存到头节点中

       if(s[0]>'0')

              head->data=1;

       if(s[0]=='0')

              head->data=0;

       if(s[0]=='-')

       {

              l=1;

              head->data=-1;

       }

    j=strlen(s)-1;

       for(i=l;i<=j;i++)

              s[i]=s[i]-'0';

       while(j-l>=3)

       {

              q=(struct long_int *)malloc (LEN);

              q->data=s[j]+s[j-1]*10+s[j-2]*100+s[j-3]*1000;

              insert(head,q);

              j=j-4;

       }

       if(j>=l)  //当最后几位数的位数不足四位时

       {

              q=(struct long_int *)malloc(LEN);

              q->data=0;

              while(l<=j)

              {

                     q->data=q->data*10+s[l];

                     l++;

              }

              insert(head,q);

       }

       return(head);

}//get

6.加法函数设计思路：

先将各位做加减，然后根据所得长整数正负和各结点data值进位或退位计算所得长整数的值并输出。

函数C代码：

void plus(struct long_int *a,struct long_int *b)

{

    struct long_int *m,*n,*p,*chead,*q;

    if(a->over==0||b->over==0)

        printf("long int error!\n");

    else

       {

        m=a->pro;

        n=b->pro;

        chead=creat();

        while(m!=a&&n!=b)

              {

            p=(struct long_int *)malloc(LEN);

            p->data=a->data*m->data+b->data*n->data;

            insert(chead,p);

                     m=m->pro;

                     n=n->pro;

              }

              while(m!=a||n!=b)

              {

            if(m==a)

                     {

                p=(struct long_int *)malloc(LEN);

                p->data=b->data*n->data;

                         n=n->pro;

                            insert(chead,p);

                     }

                  else if(n==b)

                     {

                p=(struct long_int *)malloc(LEN);

                p->data=a->data*m->data;

                m=m->pro;

                            insert(chead,p);

                     }

              }

        p=chead->next;

              chead->data=0;

              while(p!=chead)

              {

                     if(p->data>0)

                     {

                            chead->data=1;

                         break;

                     }

                     if(p->data<0)

                     {

                            chead->data=-1;

                            break;

                     }

                     p=p->next;

              }

        p=chead->pro;

        while(p!=chead)

              {

            if(p->next!=chead)

                p->data=p->data*chead->data+p->next->over;

            if(p->next==chead)

                p->data=p->data*chead->data;

                     p->over=0;

            if(p->data>=10000)

                p->over=1;

            if(p->data<0)

                p->over=-1;

            p->data=p->data-p->over*10000;

            p=p->pro;

              }

        p=chead->next;

              while(p->data==0&&p->over==0&&p->next!=chead)

              {

                     q=p;

                     p=p->next;

                     del(chead,q);

              }

        if(p->over>0)

              {

            q=(struct long_int*)malloc(LEN);

            q->data=p->over;

            insert(chead,q);

              }

       }

       if(chead->next->data==0)

              chead->data=0;

    print(chead);

}//plus

6.减法函数设计思路：

将被减数换符号，做加法。

函数C代码：

void minus(struct long_int *a,struct long_int *b)

{

      b->data=(-1)*b->data;  //将被减数的符号改变

       plus(a,b);

}//minus