利用链表实现一元多项式的相加、相减、相乘等运算。 功能要求： 1. 创建多项式时，无论指数项按什么顺序输入，输出均能实现以升幂顺序输出，且输入时有相同指数项时能够实现合并。 2. 能够代入确切的x计算出最终多项式的值。 3. 输入输出要有相应的文字提示。 格式要求如下： (1)输入数据： 支持多组输入数据，每组数据分3行： 第1行是第一个多项式，用带括号的成对数字分别表示一个项的系数和指数，如多项式7+3x+9x^8+5x^17的输入为： (7, 0), (3, 1), (9, 8), (5, 17) 第2行是第二个多项式，格式要求同上。 第3行是x的值，可以有多个值，用逗号隔开。 (2)输出数据： 每组数据的输出结果有8行： 第1行是第一个多项式的数学表达式，如7+3x+9x^8+5x^17。 第2行是第二个多项式的数学表达式。 第3行是相加结果的数学表达式。 第4行是相减结果的数学表达式。 第5行是相乘结果的数学表达式。 第6行是带入x后的具体加法计算结果。 第7行是带入x后的具体减法计算结果。 第8行是带入x后的具体乘法计算结果。

好的，下面是代码实现，希望对您有所帮助。

class Node:
    def __init__(self, coef, exp, next=None):
        self.coef = coef
        self.exp = exp
        self.next = next

class Polynomial:
    def __init__(self, expression):
        self.head = None
        self.tail = None
        self.expression = expression
        self.create_poly()

    def create_poly(self):
        for term in self.expression:
            coef, exp = term
            if coef == 0:
                continue
            if self.head is None:
                self.head = Node(coef, exp)
                self.tail = self.head
            else:
                ptr = self.head
                prev = None
                while ptr is not None and ptr.exp > exp:
                    prev = ptr
                    ptr = ptr.next
                if ptr is not None and ptr.exp == exp:
                    ptr.coef += coef
                    if ptr.coef == 0:
                        self.remove_node(ptr, prev)
                else:
                    new_node = Node(coef, exp, ptr)
                    if prev is None:
                        self.head = new_node
                    else:
                        prev.next = new_node
                    if ptr is None:
                        self.tail = new_node

    def remove_node(self, node, prev):
        if prev is None:
            self.head = node.next
        else:
            prev.next = node.next
        if node.next is None:
            self.tail = prev

    def add(self, poly):
        ptr1 = self.head
        ptr2 = poly.head
        result = []
        while ptr1 is not None and ptr2 is not None:
            if ptr1.exp == ptr2.exp:
                result.append((ptr1.coef + ptr2.coef, ptr1.exp))
                ptr1 = ptr1.next
                ptr2 = ptr2.next
            elif ptr1.exp > ptr2.exp:
                result.append((ptr1.coef, ptr1.exp))
                ptr1 = ptr1.next
            else:
                result.append((ptr2.coef, ptr2.exp))
                ptr2 = ptr2.next
        while ptr1 is not None:
            result.append((ptr1.coef, ptr1.exp))
            ptr1 = ptr1.next
        while ptr2 is not None:
            result.append((ptr2.coef, ptr2.exp))
            ptr2 = ptr2.next
        return Polynomial(result)

    def subtract(self, poly):
        ptr1 = self.head
        ptr2 = poly.head
        result = []
        while ptr1 is not None and ptr2 is not None:
            if ptr1.exp == ptr2.exp:
                result.append((ptr1.coef - ptr2.coef, ptr1.exp))
                ptr1 = ptr1.next
                ptr2 = ptr2.next
            elif ptr1.exp > ptr2.exp:
                result.append((ptr1.coef, ptr1.exp))
                ptr1 = ptr1.next
            else:
                result.append((-ptr2.coef, ptr2.exp))
                ptr2 = ptr2.next
        while ptr1 is not None:
            result.append((ptr1.coef, ptr1.exp))
            ptr1 = ptr1.next
        while ptr2 is not None:
            result.append((-ptr2.coef, ptr2.exp))
            ptr2 = ptr2.next
        return Polynomial(result)

    def multiply(self, poly):
        ptr1 = self.head
        ptr2 = poly.head
        result = []
        while ptr1 is not None:
            while ptr2 is not None:
                coef = ptr1.coef * ptr2.coef
                exp = ptr1.exp + ptr2.exp
                result.append((coef, exp))
                ptr2 = ptr2.next
            ptr1 = ptr1.next
            ptr2 = poly.head
        return Polynomial(result)

    def evaluate(self, x):
        ptr = self.head
        result = 0
        while ptr is not None:
            result += ptr.coef * pow(x, ptr.exp)
            ptr = ptr.next
        return result

    def __str__(self):
        ptr = self.head
        terms = []
        while ptr is not None:
            if ptr.exp == 0:
                terms.append(str(ptr.coef))
            elif ptr.exp == 1:
                terms.append(str(ptr.coef) + 'x')
            else:
                terms.append(str(ptr.coef) + 'x^' + str(ptr.exp))
            ptr = ptr.next
        if not terms:
            return '0'
        else:
            return ' + '.join(terms)

# 主程序
while True:
    expression1 = input('请输入第一个多项式，用带括号的成对数字分别表示一个项的系数和指数，以逗号分隔：')
    expression2 = input('请输入第二个多项式，用带括号的成对数字分别表示一个项的系数和指数，以逗号分隔：')
    x_values = input('请输入x的值，可以有多个值，用逗号隔开：')
    expression1 = eval(expression1)
    expression2 = eval(expression2)
    x_values = [float(x) for x in x_values.split(',')]
    poly1 = Polynomial(expression1)
    poly2 = Polynomial(expression2)
    print('第一个多项式的数学表达式为：', poly1)
    print('第二个多项式的数学表达式为：', poly2)
    print('相加结果的数学表达式为：', poly1.add(poly2))
    print('相减结果的数学表达式为：', poly1.subtract(poly2))
    print('相乘结果的数学表达式为：', poly1.multiply(poly2))
    for x in x_values:
        print('带入x=' + str(x) + '的具体加法计算结果为：', poly1.evaluate(x) + poly2.evaluate(x))
        print('带入x=' + str(x) + '的具体减法计算结果为：', poly1.evaluate(x) - poly2.evaluate(x))
        print('带入x=' + str(x) + '的具体乘法计算结果为：', poly1.evaluate(x) * poly2.evaluate(x))
    choice = input('是否继续测试？（y/n）')
    if choice.lower() != 'y':
        break