Algorithm 表达式树的后缀表示法

关于如何将表达式树转换为后缀符号，有足够的资源，这并不难

但我必须将后缀表达式解析为表达式树

表达方式是：

A 2^2 A*B*-B 2^+A B-/

---

我真的不知道如何解释这个表达。有人知道如何处理这个问题吗？

创建一个包含可能是树的一部分的节点的堆栈

将堆栈上的操作数（a、2、B等都是操作数）作为叶节点推送，不绑定到任何方向的任何树

对于操作符，从堆栈中弹出必要的操作数，创建一个操作符位于顶部的节点，操作数悬挂在其下方，将新节点推到堆栈上

对于您的数据：

将一个容器推到堆栈上

将2推到堆栈上

弹出2和A，创建^-节点（下面有A和2），将其推到堆栈上

将2推到堆栈上

在堆栈上推

弹出A和2并组合成*-节点

等等

等等

以下是一个可以进行试验的程序：

// Add the following two using-directives to LINQPad:
// System.Drawing
// System.Drawing.Imaging

static Bitmap _Dummy = new Bitmap(16, 16, PixelFormat.Format24bppRgb);
static Font _Font = new Font("Arial", 12);

void Main()
{
    var elementsAsString = "A 2 ^ 2 A * B * - B 2 ^ + A B - / 2 ^";
    var elements = elementsAsString.Split(' ');

    var stack = new Stack<Node>();
    foreach (var element in elements)
        if (IsOperator(element))
        {
            Node rightOperand = stack.Pop();
            Node leftOperand = stack.Pop();
            stack.Push(new Node(element, leftOperand, rightOperand));
        }
        else
            stack.Push(new Node(element));

    Visualize(stack.Pop());
}

void Visualize(Node node)
{
    node.ToBitmap().Dump();
}

class Node
{
    public Node(string value)
        : this(value, null, null)
    {
    }

    public Node(string value, Node left, Node right)
    {
        Value = value;
        Left = left;
        Right = right;
    }

    public string Value;
    public Node Left;
    public Node Right;

    public Bitmap ToBitmap()
    {
        Size valueSize;
        using (Graphics g = Graphics.FromImage(_Dummy))
        {
            var tempSize = g.MeasureString(Value, _Font);
            valueSize = new Size((int)tempSize.Width + 4, (int)tempSize.Height + 4);
        }

        Bitmap bitmap;
        Color valueColor = Color.LightPink;
        if (Left == null && Right == null)
        {
            bitmap = new Bitmap(valueSize.Width, valueSize.Height);
            valueColor = Color.LightGreen;
        }
        else
        {
            using (var leftBitmap = Left.ToBitmap())
            using (var rightBitmap = Right.ToBitmap())
            {
                int subNodeHeight = Math.Max(leftBitmap.Height, rightBitmap.Height);
                bitmap = new Bitmap(
                    leftBitmap.Width + rightBitmap.Width + valueSize.Width,
                    valueSize.Height + 32 + subNodeHeight);

                using (var g = Graphics.FromImage(bitmap))
                {
                    int baseY  = valueSize.Height + 32;

                    int leftTop = baseY; // + (subNodeHeight - leftBitmap.Height) / 2;
                    g.DrawImage(leftBitmap, 0, leftTop);

                    int rightTop = baseY; // + (subNodeHeight - rightBitmap.Height) / 2;
                    g.DrawImage(rightBitmap, bitmap.Width - rightBitmap.Width, rightTop);

                    g.DrawLine(Pens.Black, bitmap.Width / 2 - 4, valueSize.Height, leftBitmap.Width / 2, leftTop);
                    g.DrawLine(Pens.Black, bitmap.Width / 2 + 4, valueSize.Height, bitmap.Width - rightBitmap.Width / 2, rightTop);
                }
            }
        }

        using (var g = Graphics.FromImage(bitmap))
        {
            float x = (bitmap.Width - valueSize.Width) / 2;
            using (var b = new SolidBrush(valueColor))
                g.FillRectangle(b, x, 0, valueSize.Width - 1, valueSize.Height - 1);
            g.DrawRectangle(Pens.Black, x, 0, valueSize.Width - 1, valueSize.Height - 1);
            g.DrawString(Value, _Font, Brushes.Black, x + 1, 2);
        }

        return bitmap;
    }
}

bool IsOperator(string s)
{
    switch (s)
    {
        case "*":
        case "/":
        case "^":
        case "+":
        case "-":
            return true;

        default:
            return false;
    }
}

//将以下两个using指令添加到LINQPad：
//系统图
//系统、绘图、成像
静态位图_Dummy=新位图（16,16，PixelFormat.Format24bppRgb）；
静态字体_Font=新字体（“Arial”，12）；
void Main（）
{
var elementsastring=“A2^2A*B*-B2^+AB-/2^”；
var elements=elementsAsString.Split（“”）；
var stack=新堆栈（）；
foreach（元素中的var元素）
if（等参器（元件））
{
节点右操作数=stack.Pop（）；
节点leftOperator=stack.Pop（）；
Push（新节点（元素、左操作数、右操作数））；
}
其他的
stack.Push（新节点（元素））；
可视化（stack.Pop（））；
}
void可视化（节点）
{
node.ToBitmap（）.Dump（）；
}
类节点
{
公共节点（字符串值）
：此（值，null，null）
{
}
公共节点（字符串值、左节点、右节点）
{
价值=价值；
左=左；
右=右；
}
公共字符串值；
公共节点左；
公共节点权；
公共位图ToBitmap（）
{
大小值大小；
使用（Graphics g=Graphics.FromImage（_Dummy））
{
var tempSize=g.MeasureString（值，字体）；
valueSize=新尺寸（（int）tempSize.Width+4，（int）tempSize.Height+4）；
}
位图；
颜色值Color=Color.LightPink；
if（Left==null&&Right==null）
{
位图=新位图（valueSize.Width、valueSize.Height）；
valueColor=Color.LightGreen；
}
其他的
{
使用（var leftBitmap=Left.ToBitmap（））
使用（var rightbimat=Right.ToBitmap（））
{
int subNodeHeight=Math.Max（leftBitmap.Height，righbitmap.Height）；
位图=新位图(
leftBitmap.Width+rightBitmap.Width+valueSize.Width，
valueSize.Height+32+子节点高度）；
使用（var g=Graphics.FromImage（位图））
{
int baseY=valueSize.Height+32；
int leftTop=baseY；//+（subNodeHeight-leftBitmap.Height）/2；
g、 DrawImage（leftBitmap，0，leftTop）；
int rightTop=baseY；//+（子节点高度-rightBitmap.Height）/2；
g、 DrawImage（rightBitmap，bitmap.Width-rightBitmap.Width，rightTop）；
g、 绘图线（Pens.Black，bitmap.Width/2-4，valueSize.Height，leftBitmap.Width/2，leftTop）；
g、 绘图线（Pens.Black，bitmap.Width/2+4，valueSize.Height，bitmap.Width-rightBitmap.Width/2，rightTop）；
}
}
}
使用（var g=Graphics.FromImage（位图））
{
浮点x=（bitmap.Width-valueSize.Width）/2；
使用（var b=新的SolidBrush（valueColor））
g、 圆角矩形（b，x，0，valueSize.Width-1，valueSize.Height-1）；
g、 DrawRectangle（画笔，黑色，x，0，valueSize.Width-1，valueSize.Height-1）；
g、 抽绳（数值、字体、画笔、黑色、x+1、2）；
}
返回位图；
}
}
布尔等参器（串s）
{
开关
{
案例“*”：
案例“/：
案例“^”：
格“+”：
案例“-”：
返回true；
违约：
返回false；
}
}

输出：

---

这看起来正确吗：

for n in items:
    if n is argument:
        push n
    if n is operator:
        b = pop      // first pop shall yield second operand   
        a = pop      // second pop shall yield first operand
        push a+n+b
 answer = pop



A 2 ^ 2 A * B * - B 2 ^ + A B - /

在Station上运行此操作将产生一个堆栈，其演变如下：

[A]
[A, 2]
[A^2]
[A^2, 2]
[A^2, 2, A]
[A^2, 2*A]
[A^2, 2*A, B]
[A^2, 2*A*B]
[A^2-2*A*B]
[A^2-2*A*B, B]
[A^2-2*A*B, B, 2]
[A^2-2*A*B, B^2]
[A^2-2*A*B+B^2]
[A^2-2*A*B+B^2, A]
[A^2-2*A*B+B^2, A, B]
[A^2-2*A*B+B^2, A-B]
[A^2-2*A*B+B^2/A-B]

---

是的，这比我将要发布的内容更容易理解。谢谢，但这并不完全正确。在第3步和第4步之间，你忘记了在堆栈上推一个2。堆栈反转操作数，因此必须在堆栈上放置b+n+a