求循环小数

对于任意的真分数 N/M （ 0 < N < M ），均可以求出对应的小数。如果采用链表表示各个小数，对于循环节采用循环链表表示，则所有分数均可以表示为如下链表形式。

输入： N M

输出： 转换后的小数（不超过 50 ）

要求： 仅编写将分数转换为小数的函数 change( int n, int m, NODE * head ) 。

预设代码

/* PRESET CODE BEGIN - NEVER TOUCH CODE BELOW */  
 
#include <stdio.h>  
#include <stdlib.h>  
  
typedef struct node  
{   int         data;  
    struct node * next;  
} NODE;  
  
void output( NODE * );  
void change( int, int, NODE * );  
  
void output( NODE * head )  
{   int k=0;  
  
    printf("0.");  
    while ( head->next != NULL && k<50 )  
    {   printf("%d", head->next->data );  
        head = head->next;  
        k ++;  
    }  
    printf("\n");  
}  
  
int main()  
{   int n, m;  
    NODE * head;  
  
    scanf("%d%d", &n, &m);  
    head = (NODE *)malloc( sizeof(NODE) );  
    head->next = NULL;  
    head->data = -1;  
    change( n, m, head );  
    output( head );  
    return 0;  
}  
  
/* PRESET CODE END - NEVER TOUCH CODE ABOVE */  

测试输入	期待的输出	时间限制	内存限制	额外进程
测试用例 1	以文本方式显示 1 8↵	以文本方式显示 0.125↵	1秒	64M	0
测试用例 2	以文本方式显示 29 33↵	以文本方式显示 0.87878787878787878787878787878787878787878787878787↵	1秒	64M	0
测试用例 3	以文本方式显示 7 18↵	以文本方式显示 0.38888888888888888888888888888888888888888888888888↵	1秒	64M	0
测试用例 4	以文本方式显示 2 7↵	以文本方式显示 0.28571428571428571428571428571428571428571428571428↵	1秒	64M	0

#include<stdio.h>  
#include<stdlib.h>  
typedef struct node    
{   int  data;    
    struct node * next;    
} NODE;    
    
void output( NODE * );    
void change( int, int, NODE * );    
    
void output( NODE * head )    
{   int k=0;    
    printf("0.");    
    while ( head->next != NULL && k<50 )    
    {   printf("%d", head->next->data );    
        head = head->next;    
        k ++;    
    }    
    printf("\n");    
}    
    
int main()    
{   int n,m;    
    NODE * head;   
    scanf("%d%d", &n, &m);    
    head = (NODE *)malloc( sizeof(NODE) );    
    head->next = NULL;    
    head->data = -1;    
    change( n, m, head );    
    output( head );    
    return 0;    
}    
  
void change(int n,int m,NODE* head)  
{  
    int quotient[60],remainder[60],i,j,k,g,flag=0;  
    NODE *q,*p,*start;  
    quotient[0]=(n*10)/m;  
    remainder[0]=(n*10)%m;  
    for(i=1;i<60;i++)  
    {  
        quotient[i]=(remainder[i-1]*10)/m;  
        remainder[i]=(remainder[i-1]*10)%m;  
        for(j=0;j<i;j++)  
        {  
            if((quotient[i]==quotient[j])&&(remainder[i]==remainder[j]))  //发现循环节，跳出   
            {  
                flag=1;  
                break;  
            }  
        }  
        if(flag) break;  
    }                             //j为第一个循环节的头，i为第二个循环节的头   
    //printf("%d,%d\n",i,j);   
    for(k=j-1;k>=0;k--) //倒着放置循环节前的数字   
    {  
        if(k==j-1)  
        {  
            p=(NODE*)malloc(sizeof(NODE));  //p存放循环节前一个数字   
            p->next=head->next;  
            head->next=p;  
            p->data=quotient[k];   
        }  
        else  
        {  
            q=(NODE*)malloc(sizeof(NODE)); //q存放循环节前其他数字   
            q->next=head->next;  
            head->next=q;  
            q->data=quotient[k];  
        }  
          
    }  
    if(((quotient[j]==0)&&(quotient[i]==0)&&(i==j+1))==0)//判断是否是循环小数   
    {   
        start=(NODE*)malloc(sizeof(NODE));  
        if(j==0)  head->next=start;      //判断循环节前是否有数字   
        else p->next=start;  
        start->next=start;  
        start->data=quotient[j]; // 存放第一个循环节的头   
        for(g=i-1;g>j;g--) //倒着放置循环节后的数字   
        {  
            q=(NODE*)malloc(sizeof(NODE));  
            if(g==(i-1))    q->next=start;    //循环节自身头尾相连   
            else q->next=start->next;  
            start->next=q;  
            q->data=quotient[g];  
        }  
    }     
}