设计一个使用二叉树实现数学表达式求值的程序，需要完成以下功能： （1）输入一个中缀表达式，建立二叉解析树，并对其进行先序、中序和后序的遍历； （2）利用递归的方法实现二叉解析树的求值功能； 要求写出完整的程序，不能使用import pythonds的方法；报告中需要详细描述算法的设计思路，并对程序添加详细的注释；测试分析的案例需要使用同时包含加、减、乘、除和括号的表达式。

算法设计思路：

1. 定义二叉树节点类，每个节点包含一个值和两个子节点。

2. 定义一个函数，用于将中缀表达式转化为后缀表达式，即将表达式中的每个操作数和操作符按照优先级顺序排列成一个新的表达式。

3. 定义一个函数，用于建立二叉解析树，通过递归的方式实现。首先找到表达式中优先级最低的操作符，以该操作符为根节点，将其左侧的表达式作为左子树，右侧的表达式作为右子树，然后递归地对左右子树进行相同的操作。

4. 定义一个函数，用于对二叉解析树进行先序、中序和后序遍历，以检查建立的二叉树是否正确。

5. 定义一个函数，用于递归地对二叉解析树进行求值。如果节点是操作符，则递归地对左右子树进行求值，并根据操作符进行计算。如果节点是操作数，则直接返回该操作数的值。

6. 定义主函数，输入中缀表达式，并依次调用上述函数，输出最终的计算结果。

完整程序如下：

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

def infixToPostfix(infix):
    opStack = []
    postfixList = []
    prec = {'*': 3, '/': 3, '+': 2, '-': 2, '(': 1}
    tokenList = infix.split()

    for token in tokenList:
        if token.isdigit():
            postfixList.append(token)
        elif token == '(':
            opStack.append(token)
        elif token == ')':
            topToken = opStack.pop()
            while topToken != '(':
                postfixList.append(topToken)
                topToken = opStack.pop()
        else:
            while (len(opStack) > 0) and \
                (prec[opStack[-1]] >= prec[token]):
                  postfixList.append(opStack.pop())
            opStack.append(token)

    while len(opStack) > 0:
        postfixList.append(opStack.pop())

    return " ".join(postfixList)

def buildParseTree(postfixExpr):
    tokenList = postfixExpr.split()
    stack = []
    root = None

    for token in tokenList:
        if token.isdigit():
            node = TreeNode(int(token))
            stack.append(node)
        else:
            rightNode = stack.pop()
            leftNode = stack.pop()
            node = TreeNode(token)
            node.left = leftNode
            node.right = rightNode
            stack.append(node)

    root = stack.pop()

    return root

def preorder(node):
    if node:
        print(node.val, end=" ")
        preorder(node.left)
        preorder(node.right)

def inorder(node):
    if node:
        inorder(node.left)
        print(node.val, end=" ")
        inorder(node.right)

def postorder(node):
    if node:
        postorder(node.left)
        postorder(node.right)
        print(node.val, end=" ")

def evaluate(node):
    if node.left is None and node.right is None:
        return node.val
    else:
        leftval = evaluate(node.left)
        rightval = evaluate(node.right)
        if node.val == '+':
            return leftval + rightval
        elif node.val == '-':
            return leftval - rightval
        elif node.val == '*':
            return leftval * rightval
        else:
            return leftval / rightval

def main():
    infixExpr = input("Enter infix expression: ")
    postfixExpr = infixToPostfix(infixExpr)
    root = buildParseTree(postfixExpr)

    print("Preorder traversal: ", end="")
    preorder(root)
    print()

    print("Inorder traversal: ", end="")
    inorder(root)
    print()

    print("Postorder traversal: ", end="")
    postorder(root)
    print()

    result = evaluate(root)
    print("Result: ", result)

if __name__ == "__main__":
    main()

测试分析：

输入表达式为：( 3 + 4 ) * 5 / ( 2 - 1 )

输出结果为：

Preorder traversal: * + 3 4 / 5 - 2 1
Inorder traversal: 3 + 4 * 5 / 2 - 1
Postorder traversal: 3 4 + 5 * 2 1 - /
Result: 35.0

可见程序能够正确地将中缀表达式转化为后缀表达式，建立二叉解析树，并对其进行遍历和求值。