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

好的，这个任务可以分为以下几个步骤：

1. 定义抽象语法树的节点类，包括数字、变量、加法、减法、乘法和除法节点。
2. 定义中缀表达式的解析器，将中缀表达式转换成抽象语法树。
3. 实现GUI界面，包括输入框、输出框和转换按钮。
4. 将用户输入的中缀表达式转换成抽象语法树，并在输出框中展示。

下面我们来逐步实现这些步骤。

1. 定义抽象语法树的节点类

class Node:
    pass

class NumberNode(Node):
    def __init__(self, value):
        self.value = value

class VariableNode(Node):
    def __init__(self, name):
        self.name = name

class AddNode(Node):
    def __init__(self, left, right):
        self.left = left
        self.right = right

class SubtractNode(Node):
    def __init__(self, left, right):
        self.left = left
        self.right = right

class MultiplyNode(Node):
    def __init__(self, left, right):
        self.left = left
        self.right = right

class DivideNode(Node):
    def __init__(self, left, right):
        self.left = left
        self.right = right

2. 定义中缀表达式的解析器

class Parser:
    def __init__(self, text):
        self.tokens = re.findall('\d+|[a-zA-Z]+|[\+\-\*/\(\)]', text)
        self.position = 0
    
    def parse(self):
        root = self.parse_expression()
        if self.position != len(self.tokens):
            raise SyntaxError('Invalid syntax')
        return root
    
    def parse_expression(self):
        left = self.parse_term()
        while self.position < len(self.tokens) and self.tokens[self.position] in ['+', '-']:
            operator = self.tokens[self.position]
            self.position += 1
            right = self.parse_term()
            if operator == '+':
                left = AddNode(left, right)
            else:
                left = SubtractNode(left, right)
        return left
    
    def parse_term(self):
        left = self.parse_factor()
        while self.position < len(self.tokens) and self.tokens[self.position] in ['*', '/']:
            operator = self.tokens[self.position]
            self.position += 1
            right = self.parse_factor()
            if operator == '*':
                left = MultiplyNode(left, right)
            else:
                left = DivideNode(left, right)
        return left
    
    def parse_factor(self):
        if self.position >= len(self.tokens):
            raise SyntaxError('Unexpected end of input')
        token = self.tokens[self.position]
        self.position += 1
        if re.match('\d+', token):
            return NumberNode(int(token))
        elif re.match('[a-zA-Z]+', token):
            return VariableNode(token)
        elif token == '(':
            node = self.parse_expression()
            if self.position >= len(self.tokens) or self.tokens[self.position] != ')':
                raise SyntaxError('Expected )')
            self.position += 1
            return node
        else:
            raise SyntaxError('Invalid token: ' + token)

3. 实现GUI界面

import tkinter as tk

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

    def create_widgets(self):
        self.input_label = tk.Label(self, text="Expression:")
        self.input_label.pack()
        self.input_entry = tk.Entry(self)
        self.input_entry.pack()

        self.output_label = tk.Label(self, text="Abstract Syntax Tree:")
        self.output_label.pack()
        self.output_text = tk.Text(self)
        self.output_text.pack()

        self.convert_button = tk.Button(self, text="Convert", command=self.convert)
        self.convert_button.pack()

    def convert(self):
        text = self.input_entry.get()
        parser = Parser(text)
        root = parser.parse()
        self.output_text.delete('1.0', tk.END)
        self.output_text.insert(tk.END, str(root))

4. 将用户输入的中缀表达式转换成抽象语法树，并在输出框中展示。

app = Application()
app.mainloop()

这样就完成了整个程序的开发。用户输入一个中缀表达式，点击转换按钮后，程序将其转换成抽象语法树，并在输出框中展示。