C++用链表实现大整数加减法操作： 32 位机器直接操作的数据最大为 32 个 bit，若超过 32bit，则需要单独设计算法。在这 里，可以用链表每个结点存储大整数的每一位的十进制数字，则可以进行大整数的算数运算， 该实验仅实现加减法操作。 要求: 1， 随机产生 2 个 1~50 位的数字串，并存储到 2 个链表中。 2， 进行加法或减法操作，结果存储到新的链表中。 3， 打印运算结果。

由于题目没有具体要求使用哪种语言，以下我将使用 C++ 实现。

首先，我们需要定义大整数的数据结构（即链表的结点），包含一个整型数值表示该结点存储的数字，以及一个指向下一个结点的指针。由于大整数可能存在前导 0，因此需要在数据结构中添加一个标记量，标记是否为前导 0。

struct Node {
    int val; // 数字
    bool isLeadingZero; // 是否为前导 0
    Node* next; // 指向下一个结点的指针
    Node(int v=0, bool iz=false, Node* n=nullptr): val(v), isLeadingZero(iz), next(n) {}
};

随机生成大整数实现函数 `generateRandomNumber()`，该函数首先生成一个随机的整数位数，然后在 [1, 9] 中随机生成每一位的数字。在生成第一位时，需要确保不是 0（如果第一位是 0，则可能被误解为前导 0）。

Node* generateRandomNumber() {
    int len = rand() % 50 + 1;
    Node* head = nullptr, *tail = nullptr;
    for(int i=0; i<len; ++i) {
        int digit = rand() % 9 + 1;
        if(i == 0) {
            head = tail = new Node(digit, false);
        } else {
            tail->next = new Node(digit, false);
            tail = tail->next;
        }
    }
    return head;
}

接下来，定义两个大整数相加的函数 `add()`，该函数实现 3 个链表的逐位相加，最终返回新的大整数链表。在实现相加时，需要注意一些细节：

- 如果某位相加后结果超过 10（大于等于 10 可以用取模操作来实现），则需要进位。
- 对于位数不足的整数，赋值为 0 即可。
- 相加后需要处理前导 0。

Node* add(Node* num1, Node* num2) {
    Node* head = nullptr, *tail = nullptr;
    int carry = 0;
    while(num1 != nullptr || num2 != nullptr || carry != 0) {
        int val1 = (num1 == nullptr ? 0 : num1->val);
        int val2 = (num2 == nullptr ? 0 : num2->val);
        int sum = val1 + val2 + carry;
        int digit = sum % 10;
        carry = sum / 10;
        if(head == nullptr) {
            head = tail = new Node(digit, false);
        } else {
            tail->next = new Node(digit, false);
            tail = tail->next;
        }
        num1 = (num1 == nullptr ? nullptr : num1->next);
        num2 = (num2 == nullptr ? nullptr : num2->next);
    }
    return head;
}

同理，定义两个大整数相减的函数 `sub()`，该函数实现 3 个链表的逐位相减，最终返回新的大整数链表。在实现相减时，需要注意一些细节：

- 如果某位相减后结果小于 0，则需要借位。
- 对于位数不足的整数，赋值为 0 即可。
- 需要处理前导 0。

Node* sub(Node* num1, Node* num2) {
    Node* head = nullptr, *tail = nullptr;
    int carry = 0;
    while(num1 != nullptr || num2 != nullptr || carry != 0) {
        int val1 = (num1 == nullptr ? 0 : num1->val);
        int val2 = (num2 == nullptr ? 0 : num2->val);
        int diff = val1 - val2 - carry;
        if(diff < 0) {
            diff += 10;
            carry = 1;
        } else {
            carry = 0;
        }
        if(head == nullptr) {
            head = tail = new Node(diff, (diff == 0 && (num1 == nullptr || num2 == nullptr)));
        } else {
            tail->next = new Node(diff, (diff == 0 && (num1 == nullptr || num2 == nullptr)), nullptr);
            tail = tail->next;
        }
        num1 = (num1 == nullptr ? nullptr : num1->next);
        num2 = (num2 == nullptr ? nullptr : num2->next);
    }
    return head;
}

主函数就比较简单了，先随机生成两个大整数，然后分别进行加减运算，并打印结果。

int main() {
    srand(time(nullptr));
    Node* num1 = generateRandomNumber();
    Node* num2 = generateRandomNumber();
    printf("num1 = ");
    printList(num1);
    printf("num2 = ");
    printList(num2);
    Node* sum = add(num1, num2);
    Node* diff = sub(num1, num2);
    printf("sum = ");
    printList(sum);
    printf("diff = ");
    printList(diff);
    return 0;
}

完整代码：