只用鏈表不用algorithm實現支持負數的高精度運算(加、減、乘、輸入、輸出)，並對代碼進行詳細解釋

以下是使用链表实现支持负数的高精度运算（加、减、乘、输入、输出）的代码：

#include <iostream>
#include <string>
using namespace std;

struct Node {
    int val;
    Node* next;
    Node(int x) : val(x), next(NULL) {}
};

class BigInteger {
private:
    Node* head;
public:
    BigInteger() : head(NULL) {}
    ~BigInteger() {
        Node* p = head;
        while (p) {
            Node* q = p;
            p = p->next;
            delete q;
        }
    }

    void input() {
        string str;
        cin >> str;
        int len = str.size();
        Node* p = head;
        for (int i = 0; i < len; i++) {
            if (i == 0 && str[i] == '-') {
                p->val = -1;
            }
            else {
                p->next = new Node(str[i] - '0');
                p = p->next;
            }
        }
    }

    void output() {
        Node* p = head;
        if (p->val == -1) {
            cout << '-';
            p = p->next;
        }
        while (p) {
            cout << p->val;
            p = p->next;
        }
        cout << endl;
    }

    void add(BigInteger& a, BigInteger& b) {
        head = new Node(0);
        Node* p = head;
        Node* pa = a.head;
        Node* pb = b.head;
        int carry = 0;
        while (pa || pb) {
            int sum = carry + (pa ? pa->val : 0) + (pb ? pb->val : 0);
            carry = sum / 10;
            p->next = new Node(sum % 10);
            p = p->next;
            if (pa) pa = pa->next;
            if (pb) pb = pb->next;
        }
        if (carry > 0) {
            p->next = new Node(carry);
        }
    }

    void sub(BigInteger& a, BigInteger& b) {
        head = new Node(0);
        Node* p = head;
        Node* pa = a.head;
        Node* pb = b.head;
        int carry = 0;
        while (pa || pb) {
            int diff = carry + (pa ? pa->val : 0) - (pb ? pb->val : 0);
            carry = (diff < 0) ? -1 : 0;
            p->next = new Node((diff + 10) % 10);
            p = p->next;
            if (pa) pa = pa->next;
            if (pb) pb = pb->next;
        }
        while (head->next && head->next->val == 0) {
            Node* q = head->next;
            head->next = q->next;
            delete q;
        }
        if (!head->next) {
            head->val = 0;
        }
    }

    void mul(BigInteger& a, BigInteger& b) {
        head = new Node(0);
        Node* pa = a.head;
        while (pa) {
            Node* pb = b.head;
            int carry = 0;
            Node* p = head;
            while (pb) {
                int prod = carry + pa->val * pb->val + p->val;
                carry = prod / 10;
                if (p->next) {
                    p->next->val += prod % 10;
                }
                else {
                    p->next = new Node(prod % 10);
                }
                p = p->next;
                pb = pb->next;
            }
            if (carry > 0) {
                if (p->next) {
                    p->next->val += carry;
                }
                else {
                    p->next = new Node(carry);
                }
            }
            pa = pa->next;
        }
        while (head->next && head->next->val == 0) {
            Node* q = head->next;
            head->next = q->next;
            delete q;
        }
        if (!head->next) {
            head->val = 0;
        }
    }
};

int main() {
    BigInteger a, b, c;
    a.input();
    b.input();
    c.add(a, b);
    c.output();
    c.sub(a, b);
    c.output();
    c.mul(a, b);
    c.output();
    return 0;
}

这个高精度类的实现中，使用了链表来存储每一位数字，其中头结点的值为-1表示这个高精度数是负数，否则表示是正数，节点的值为0~9之间的整数。

在输入时，将字符串中的每一位数字逐个转换成节点并插入链表中，如果第一位是负号则将头节点的值设为-1。

在输出时，先判断头节点的值是否为-1，如果是则输出负号，然后逐个输出链表中的节点的值。

在加法、减法、乘法运算中，使用链表的遍历操作完成高精度数的加减乘运算，需要注意进位、借位和高位的处理。

其中，加法和乘法的实现比较容易，主要是考虑进位和高位的处理。

而减法的实现则需要考虑借位和高位的处理，以及结果中的前导0的去除。

总之，链表是一种非常适合实现高精度数的数据结构，本实现也是一个比较好的例子。