实现简单算术表示式到抽象语法树的转换。具体要求如下：（1）用户任意输入一个正确的算术表示式，程序将其转换成抽象语法树输出；（2）输入以#结束的中缀表达式（包括+-*/(）数字)，例如：x=a+b*c；（3）结果需以GUI界面展示。

好的，这个任务我们可以分为以下几个步骤来完成：

1. 设计算法将中缀表达式转化为后缀表达式。
2. 通过后缀表达式构造表达式树。
3. 设计GUI界面，并将表达式树展示在GUI界面上。

首先，我们先来实现第一步，将中缀表达式转化为后缀表达式。这里我们可以用一个栈来辅助实现，具体实现如下：

def infix_to_postfix(infix_expr):
    # 定义运算符优先级
    prec = {'*': 3, '/': 3, '+': 2, '-': 2, '(': 1}
    # 定义一个栈来存储运算符
    op_stack = []
    # 定义一个列表来存储后缀表达式
    postfix_list = []
    # 将中缀表达式按照空格分隔为单词列表
    token_list = infix_expr.split()

    for token in token_list:
        if token.isdigit():
            # 如果是数字，直接添加到后缀表达式列表中
            postfix_list.append(token)
        elif token == '(':
            # 如果是左括号，则将其压入栈中
            op_stack.append(token)
        elif token == ')':
            # 如果是右括号，则将栈顶的运算符弹出并加到后缀表达式列表中，直到遇到左括号
            top_token = op_stack.pop()
            while top_token != '(':
                postfix_list.append(top_token)
                top_token = op_stack.pop()
        else:
            # 如果是运算符，则将其与栈顶运算符进行比较，如果栈顶运算符优先级高，则将其弹出并加到后缀表达式列表中
            while op_stack and prec[op_stack[-1]] >= prec[token]:
                postfix_list.append(op_stack.pop())
            op_stack.append(token)
    # 将栈中所有运算符弹出并加到后缀表达式列表中
    while op_stack:
        postfix_list.append(op_stack.pop())
    # 将后缀表达式列表转化为字符串并返回
    return " ".join(postfix_list)

接下来，我们就可以通过后缀表达式构造表达式树了。具体实现如下：

class TreeNode:
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None


def postfix_to_expr_tree(postfix_expr):
    # 定义一个栈来存储节点
    stack = []
    # 将后缀表达式按照空格分隔为单词列表
    token_list = postfix_expr.split()

    for token in token_list:
        if token.isdigit():
            # 如果是数字，则创建一个叶子节点
            node = TreeNode(token)
            # 将节点压入栈中
            stack.append(node)
        else:
            # 如果是运算符，则创建一个新的节点，并将栈顶的两个节点作为其左右子节点
            right_node = stack.pop()
            left_node = stack.pop()
            node = TreeNode(token)
            node.left = left_node
            node.right = right_node
            # 将新的节点压入栈中
            stack.append(node)
    # 返回栈中最后一个节点，即为根节点
    return stack.pop()

最后，我们需要设计GUI界面，并将表达式树展示在GUI界面上。这里我们可以使用Python的Tkinter库来实现，具体实现如下：

import tkinter as tk


class TreeView(tk.Frame):
    def __init__(self, parent=None, tree=None):
        tk.Frame.__init__(self, parent)
        self.tree = tree
        self.canvas = tk.Canvas(self)
        self.scrollbar = tk.Scrollbar(self, orient='vertical', command=self.canvas.yview)
        self.canvas.config(yscrollcommand=self.scrollbar.set)
        self.scrollbar.pack(side='right', fill='y')
        self.canvas.pack(side='left', fill='both', expand=True)
        self.node_width = 120
        self.node_height = 60
        self.level_height = 120
        self.draw_tree(self.tree)

    def draw_tree(self, tree):
        self.canvas.delete('all')
        if not tree:
            return
        self.draw_node(tree, 0, 0)
        self.canvas.config(scrollregion=self.canvas.bbox('all'))

    def draw_node(self, node, level, count):
        x = count * self.node_width + self.node_width / 2
        y = level * self.level_height + self.node_height / 2
        self.canvas.create_oval(x - self.node_width / 2, y - self.node_height / 2, x + self.node_width / 2,
                                y + self.node_height / 2, fill='white')
        self.canvas.create_text(x, y, text=node.val)
        if node.left:
            self.draw_node(node.left, level + 1, count * 2)
            self.canvas.create_line(x, y + self.node_height / 2, x - self.node_width / 2,
                                    (level + 1) * self.level_height + self.node_height / 2)
        if node.right:
            self.draw_node(node.right, level + 1, count * 2 + 1)
            self.canvas.create_line(x, y + self.node_height / 2, x + self.node_width / 2,
                                    (level + 1) * self.level_height + self.node_height / 2)


class Application(tk.Frame):
    def __init__(self, master=None):
        tk.Frame.__init__(self, master)
        self.pack()
        self.create_widgets()

    def create_widgets(self):
        self.input_label = tk.Label(self, text='请输入算术表达式：')
        self.input_label.pack()
        self.input_entry = tk.Entry(self)
        self.input_entry.pack()
        self.convert_button = tk.Button(self, text='转换', command=self.convert)
        self.convert_button.pack()
        self.tree_view = TreeView(self)
        self.tree_view.pack(fill='both', expand=True)

    def convert(self):
        infix_expr = self.input_entry.get()
        postfix_expr = infix_to_postfix(infix_expr)
        tree = postfix_to_expr_tree(postfix_expr)
        self.tree_view.draw_tree(tree)


if __name__ == '__main__':
    app = Application()
    app.mainloop()

将上述代码保存为一个Python文件，运行后会弹出一个GUI界面，用户可以在输入框中输入算术表达式，点击“转换”按钮后，程序将其转化为表达式树，并展示在GUI界面上。