按照升幂排列的一元多项式可以用线性表来表示，对于一元多项式各种操作，实际上可以利用线性表来处理。若多项式的非零项指数很高并且非零项很少称之为稀疏多项式，此时使用链式存储结构较为方便。设计一个程序，实现一元稀疏多项式简单计算器。 【基本要求】 一元稀疏多项式简单计算器的基本功能是： （1）输入并建立多项式； （2）输出多项式，输出形式为整数序列：，其中n是多项式的项数，和分别是第i项的系数和指数，序列按指数升幂排列； （3）多项式a和b相加，建立多项式a+b； （4）多项式a和c相减，建立多项式a-b； （5）计算多项式在x处的值。 【测试数据】 （1） （2）当，多项式。 （3）计算完成后销毁多项式。

好的，我可以给出一个简单的实现，包括建立多项式、输出多项式、多项式加减、计算多项式值等基本功能。具体实现如下：

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

class Poly:
    def __init__(self):
        self.head = Node(None, None)

    def create(self):
        n = int(input("请输入多项式的项数："))
        for i in range(n):
            coef, expn = map(int, input("请输入第%d项的系数和指数，用空格隔开：" % (i+1)).split())
            node = Node(coef, expn)
            p = self.head
            while p.next and p.next.expn < expn:
                p = p.next
            if p.next and p.next.expn == expn:
                p.next.coef += coef
                if p.next.coef == 0:
                    p.next = p.next.next
            else:
                node.next = p.next
                p.next = node

    def print(self):
        p = self.head.next
        print("多项式：")
        while p:
            print("(%d,%d)" % (p.coef, p.expn), end=' ')
            p = p.next
        print()

    def add(self, b):
        c = Poly()
        p, q = self.head.next, b.head.next
        while p and q:
            if p.expn < q.expn:
                c.insert(p.coef, p.expn)
                p = p.next
            elif p.expn > q.expn:
                c.insert(q.coef, q.expn)
                q = q.next
            else:
                coef = p.coef + q.coef
                if coef != 0:
                    c.insert(coef, p.expn)
                p, q = p.next, q.next
        while p:
            c.insert(p.coef, p.expn)
            p = p.next
        while q:
            c.insert(q.coef, q.expn)
            q = q.next
        return c

    def sub(self, b):
        c = Poly()
        p, q = self.head.next, b.head.next
        while p and q:
            if p.expn < q.expn:
                c.insert(p.coef, p.expn)
                p = p.next
            elif p.expn > q.expn:
                c.insert(-q.coef, q.expn)
                q = q.next
            else:
                coef = p.coef - q.coef
                if coef != 0:
                    c.insert(coef, p.expn)
                p, q = p.next, q.next
        while p:
            c.insert(p.coef, p.expn)
            p = p.next
        while q:
            c.insert(-q.coef, q.expn)
            q = q.next
        return c

    def calc(self, x):
        p = self.head.next
        res = 0
        while p:
            res += p.coef * x ** p.expn
            p = p.next
        return res

    def insert(self, coef, expn):
        node = Node(coef, expn)
        p = self.head
        while p.next and p.next.expn < expn:
            p = p.next
        if p.next and p.next.expn == expn:
            p.next.coef += coef
            if p.next.coef == 0:
                p.next = p.next.next
        else:
            node.next = p.next
            p.next = node

其中，Node类表示多项式的一项，包括系数和指数，Poly类表示多项式。具体实现如下：

- create方法：根据输入建立多项式，使用链表存储。
- print方法：输出多项式，按指数升幂排列。
- add方法：多项式加法。
- sub方法：多项式减法。
- calc方法：计算多项式在x处的值。
- insert方法：将一项插入到多项式中，按指数升幂排列。

使用示例：

a = Poly()
a.create()
a.print()

b = Poly()
b.create()
b.print()

c = a.add(b)
c.print()

d = a.sub(b)
d.print()

x = int(input("请输入x的值："))
res = a.calc(x)
print("多项式在x=%d处的值为：%d" % (x, res))

上述代码实现了一元稀疏多项式的简单计算器，满足基本要求。