设计一个简单的语法分析器，能够将输入的单词序列分析成语法树，支持语法规则、优先级等特性

好的，这是一个相对复杂的任务，需要用到编译原理中的知识。我会尽可能简单地解释一下。

首先，需要定义语法规则，也就是文法。文法是一个四元组 G=(V, T, P, S)，其中：

- V 是一个非终结符的集合；
- T 是一个终结符的集合；
- P 是一个产生式规则的集合，每个规则形如 A -> α，其中 A∈V，α∈(V∪T)*；
- S 是一个起始符号，也就是文法的根节点，S∈V。

例如，下面是一个简单的四则运算文法：

V = {S, E, T, F}
T = {+, -, *, /, (, ), id, num}
P = {
S -> E,
E -> E + T | E - T | T,
T -> T * F | T / F | F,
F -> ( E ) | id | num
}
S = S

这个文法包含了四个非终结符和八个终结符，其中 id 和 num 表示标识符和数字。产生式规则描述了如何从一个符号推导出另一个符号。

接下来，需要实现一个词法分析器，也就是将输入的字符串按照文法规则分成一个个单词，也就是终结符。例如，输入字符串 "2 + 3 * (5 - 2)" 应该被分成这样几个单词：

num, +, num, *, (, num, -, num, )

然后，需要实现一个语法分析器，将这些单词按照文法规则组合成语法树。语法树是一个树形结构，其中每个节点表示一个符号，每个叶子节点表示一个终结符。

具体实现可以用递归下降分析法，也就是写一个函数来处理每个非终结符。例如，对于上面的四则运算文法，可以写出下面的代码：

// E -> E + T | E - T | T
Node* parse_E() {
    Node* node = parse_T();
    while (current_token.type == PLUS || current_token.type == MINUS) {
        Token op = current_token;
        eat(op.type);
        Node* right = parse_T();
        node = new Node(op, node, right);
    }
    return node;
}

// T -> T * F | T / F | F
Node* parse_T() {
    Node* node = parse_F();
    while (current_token.type == MULTIPLY || current_token.type == DIVIDE) {
        Token op = current_token;
        eat(op.type);
        Node* right = parse_F();
        node = new Node(op, node, right);
    }
    return node;
}

// F -> ( E ) | id | num
Node* parse_F() {
    if (current_token.type == LPAREN) {
        eat(LPAREN);
        Node* node = parse_E();
        eat(RPAREN);
        return node;
    } else if (current_token.type == ID) {
        Token id = current_token;
        eat(ID);
        return new Node(id);
    } else if (current_token.type == NUM) {
        Token num = current_token;
        eat(NUM);
        return new Node(num);
    } else {
        // 报错
    }
}

这个代码使用了一个全局变量 current_token 表示当前的终结符，eat 函数表示读入并消耗一个终结符。每个函数返回一个语法树节点。

最后，需要将语法树输出成字符串或者其他形式。输出方法根据具体需求而定。

当然，这只是一个简单的示例，实际实现中可能需要考虑更多问题，例如错误处理、优先级、左递归等等。但是基本思路是相似的。