#include "stdio.h" typedef struct node { int digit; struct node *next; }datanode; // 单链表结点类型 datanode * init_link() // 初始化单链表 { datanode *h; h = new datanode; h->next = NULL; return h; } void free(datanode *h) // 释放单链表 { datanode *p=h; do { h=h->next; delete p; p=h; }while(p!=NULL); } void input(datanode *h) // 输入高精度整数 { datanode *p, *q=h; char ch; int stack[256], top=-1; scanf("%c", &ch); while(ch!='\n') { stack[++top]=ch-'0'; scanf("%c", &ch); } while(top!=-1) { p = new datanode; p->digit = stack[top--]; q->next = p; q = p; } p->next=NULL; } void output(datanode *h) // 输出高精度整数 {//************************************************ //================================================= } void plus(datanode *a, datanode *b, datanode *c) // 求a、b两个头指针的单链表中的高精度整数的和 // 和存放于c为头指针的单链表中 {//************************************************ //================================================= } int main() { char s1[256], s2[256]; datanode *d1=NULL, *d2=NULL, *d3=NULL; freopen("BigDataPlus.in", "r", stdin); freopen("BigDataPlus.out", "w", stdout); d1=init_link(); input(d1); d2=init_link(); input(d2); d3=init_link(); plus(d1, d2, d3); output(d3); free(d1); free(d2); free(d3); return 0; }

这是一段高精度加法的代码，使用单链表来存储每一位数字。下面是代码的具体解释和实现细节：

1. 定义单链表结点类型

typedef struct node {
    int digit;           // 存储一个数字
    struct node *next;   // 指向下一个结点的指针
} datanode;

2. 初始化单链表

datanode * init_link() {
    datanode *h;
    h = new datanode;     // 创建头结点
    h->next = NULL;       // 头结点的 next 指针指向 NULL
    return h;
}

3. 释放单链表

void free(datanode *h) {
    datanode *p=h;
    do {
        h=h->next;       // h 指针指向下一个结点
        delete p;        // 释放当前结点
        p=h;
    } while(p!=NULL);
}

4. 输入高精度整数

void input(datanode *h) {
    datanode *p, *q=h;
    char ch;
    int stack[256], top=-1;
    scanf("%c", &ch);
    while(ch!='\n') {
        stack[++top]=ch-'0';   // 将字符转换成数字，并压入栈中
        scanf("%c", &ch);
    }
    while(top!=-1) {
        p = new datanode;        // 创建新结点
        p->digit = stack[top--]; // 取出栈顶元素，并存储到新结点中
        q->next = p;             // 将新结点插入到链表末尾
        q = p;
    }
    p->next=NULL;                // 注意将最后一个结点的 next 指针置为 NULL
}

5. 输出高精度整数

void output(datanode *h) {
    datanode *p=h->next;       // 忽略头结点
    while(p!=NULL) {
        printf("%d", p->digit);  // 输出当前结点存储的数字
        p = p->next;             // 指向下一个结点
    }
    printf("\n");
}

6. 高精度加法

void plus(datanode *a, datanode *b, datanode *c) {
    int carry=0;               // 进位标志
    datanode *pa=a->next, *pb=b->next, *pc=c;  // p 指向 a、b、c 的首个数字结点
    while(pa!=NULL || pb!=NULL || carry!=0) {
        int ai=0, bi=0;
        if(pa!=NULL) ai=pa->digit;  // 如果 a 还有数字，则取出
        if(pb!=NULL) bi=pb->digit;  // 如果 b 还有数字，则取出
        int sum = ai + bi + carry;  // 计算当前位的和
        carry = sum / 10;           // 更新进位标志
        pc->next = new datanode;    // 创建新结点
        pc = pc->next;              // 指向新结点
        pc->digit = sum % 10;       // 存储当前位的数字
        pc->next = NULL;            // 注意将新结点的 next 指针置为 NULL
        if(pa!=NULL) pa = pa->next; // 如果 a 还有数字，则指向下一个结点
        if(pb!=NULL) pb = pb->next; // 如果 b 还有数字，则指向下一个结点
    }
}

7. 主函数

int main() {
    char s1[256], s2[256];
    datanode *d1=NULL, *d2=NULL, *d3=NULL;
    
    d1=init_link();         // 初始化单链表 d1
    input(d1);              // 输入 d1
    
    d2=init_link();         // 初始化单链表 d2
    input(d2);              // 输入 d2
    
    d3=init_link();         // 初始化单链表 d3
    plus(d1, d2, d3);       // 计算 d1 + d2，并将结果存储到 d3 中
    
    output(d3);             // 输出 d3
    
    free(d1);               // 释放链表 d1 的内存
    free(d2);               // 释放链表 d2 的内存
    free(d3);               // 释放链表 d3 的内存
    
    return 0;
}