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

好的，这是一个比较复杂的问题，我们需要逐步分析和解决。首先，让我们来了解一下什么是高精度运算。

高精度运算是指在计算机中处理高精度数值的运算。在计算机中，一般使用二进制数表示数值，但是二进制数的精度有限，当需要处理更大的数值时，就需要使用高精度运算。

在这里，我们需要实现支持负数的高精度运算，可以使用链表来存储数值，每个节点存储一个数字。对于负数，可以使用一个标志位来表示正负性。

接下来，我们来看一下如何实现高精度加法。首先，需要将两个数的各位数字相加，如果有进位，则需要将进位加到下一位的计算中。具体实现可以参考如下代码：

ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
    ListNode* head = new ListNode(0);
    ListNode* tail = head;
    int carry = 0;
    while (l1 || l2 || carry) {
        int sum = (l1 ? l1->val : 0) + (l2 ? l2->val : 0) + carry;
        carry = sum / 10;
        tail->next = new ListNode(sum % 10);
        tail = tail->next;
        if (l1) l1 = l1->next;
        if (l2) l2 = l2->next;
    }
    return head->next;
}

在这段代码中，我们使用了一个头节点和一个尾节点来构建链表。同时，使用了一个进位标志位来处理进位的情况。在循环中，我们将两个链表的对应节点的值相加，并加上进位，得到当前位的和。然后，将和的个位数存储到新的链表节点中，并将进位保存，用于下一次计算。最后，将链表头节点的next指针返回，即为结果链表。

接下来，我们来看一下如何实现高精度减法。减法的实现与加法类似，只是需要考虑借位的情况。具体实现可以参考如下代码：

ListNode* subtractTwoNumbers(ListNode* l1, ListNode* l2) {
    ListNode* head = new ListNode(0);
    ListNode* tail = head;
    int borrow = 0;
    while (l1 || l2) {
        int x = l1 ? l1->val : 0;
        int y = l2 ? l2->val : 0;
        int diff = x - y - borrow;
        if (diff < 0) {
            diff += 10;
            borrow = 1;
        } else {
            borrow = 0;
        }
        tail->next = new ListNode(diff);
        tail = tail->next;
        if (l1) l1 = l1->next;
        if (l2) l2 = l2->next;
    }
    return head->next;
}

在这段代码中，我们使用了一个头节点和一个尾节点来构建链表。同时，使用了一个借位标志位来处理借位的情况。在循环中，我们将两个链表的对应节点的值相减，并减去借位，得到当前位的差。然后，如果差小于0，则需要向高位借位，将借位标志位设为1。否则，将借位标志位设为0。最后，将差的个位数存储到新的链表节点中，并将借位保存，用于下一次计算。最后，将链表头节点的next指针返回，即为结果链表。

接下来，我们来看一下如何实现高精度乘法。乘法的实现比较复杂，需要将每一位相乘，并将乘积累加到正确的位上。具体实现可以参考如下代码：

ListNode* multiplyTwoNumbers(ListNode* l1, ListNode* l2) {
    ListNode* head = new ListNode(0);
    ListNode* tail = head;
    int len1 = getLength(l1);
    int len2 = getLength(l2);
    vector<int> vals(len1 + len2, 0);
    for (ListNode* p1 = l1; p1; p1 = p1->next) {
        for (ListNode* p2 = l2; p2; p2 = p2->next) {
            int i = p1->val * p2->val;
            vals[p1->index + p2->index] += i;
            vals[p1->index + p2->index + 1] += vals[p1->index + p2->index] / 10;
            vals[p1->index + p2->index] %= 10;
        }
    }
    int i = vals.size() - 1;
    while (i >= 0 && vals[i] == 0) {
        i--;
    }
    if (i < 0) {
        return new ListNode(0);
    }
    while (i >= 0) {
        tail->next = new ListNode(vals[i--]);
        tail = tail->next;
    }
    return head->next;
}

在这段代码中，我们使用了一个头节点和一个尾节点来构建链表。同时，使用了一个长度为l1长度+l2长度的数组来保存每一位的乘积，最后再将数组中的数转换成链表。在循环中，我们将两个链表的对应节点的值相乘，并将乘积累加到正确的位上。具体来说，可以将乘积累加到vals[p1->index + p2->index]和vals[p1->index + p2->index + 1]上，其中p1->index和p2->index分别表示当前节点的位数。最后，将数组中的数转换成链表，并返回结果链表。

需要注意的是，在实现链表存储高精度数的过程中，需要考虑数位的顺序，以及负数的处理方式。同时，在实现高精度乘法时，需要注意数组长度的计算。

希望上述代码和解释能够帮助你理解如何使用链表实现支持负数的高精度运算。