Zamiana postaci prefixowej na infixowa i postfixowa

Mam do napisania 2 metody, zmieniajace wyrazenie w postaci prefixowej na infixowa i postfixowa. Mam tez podane 4 klasy:
Pastebin:
- klasa Main
- klasa Expression
- klasa Value (subclass of Expression)
- klasa Operation (subclass of Expression)

I niestety nawet nie wiem jak do tego podejsc. Na poczatek pomoglibyscie wydrukowac to w postaci takiej jaka jest, czyli prefix?

// File name: Main.java
 
public class Main {
    private static String postfixRepr(Expression e) {
        // TODO: implement this
        return "Postfix not implemented!";
    }
 
    private static String infixRepr(Expression e) {
        // TODO: implement this
        return "Infix not implemented";
    }
 
    public static void main(String[] args) {
        System.out.println(postfixRepr(Expression.EXAMPLE_1));
        System.out.println(infixRepr(Expression.EXAMPLE_2));
    }
}

public abstract class Expression {
    public static final Expression EXAMPLE_1 =
        new Operation('*',
            new Value(2),
            new Operation('+',
                new Value(5),
                new Value(7)));
 
    public static final Expression EXAMPLE_2 =
        new Operation('/',
            new Operation('*',
                new Value(2),
                new Operation('+',
                    new Value(3),
                    new Operation('-',
                      new Operation('-',
                            new Value(4),
                            new Value(5)),
                        new Operation('-',                     
                            new Value(1),
                            new Value(2))))),
            new Operation('*',
                new Value(3),
                new Value(4)));            
}

public class Operation extends Expression {
    public char op;     // One of: '+', '-', '*', '/'
    public Expression arg1;
    public Expression arg2;
 
    public Operation(char op, Expression arg1, Expression arg2) {
        this.op = op;
        this.arg1 = arg1;
        this.arg2 = arg2;
    }
}

public class Value extends Expression {
    public int value;   // Always a positive number
 
    public Value(int value) {
        this.value = value;
    }
}```

Twoje wyrażenie tworzy drzewo, które musisz zapisać w innej postaci. Prawdopodobnie transformacja drzewa (np. prefiksowego) polega na transformacji poddrzew i sklejeniu całości jako nowe drzewo (np. infiksowe). Jest to algorytm rekurencyjny. Dla każdej podanej klasy musisz napisać metodę, która dokona jej transformacji, potem tylko lecisz rekurencją i budujesz nowe drzewo.

A to nie jest to samo co zamiana na odwróconą notację polską i na odwrót?

Tu Masz prefix na infix:
https://www.geeksforgeeks.org/prefix-infix-conversion/
A mając infix, infix na prefix:
https://runestone.academy/runestone/books/published/pythonds/BasicDS/InfixPrefixandPostfixExpressions.html#general-infix-to-postfix-conversion

I niestety nawet nie wiem jak do tego podejsc. Na poczatek pomoglibyscie wydrukowac to w postaci takiej jaka jest, czyli prefix?

Po kolei - wydaje mi się, że tutaj nie musisz konwertować z i do prefix/infix, a jedynie wypisać wyrażenie - raz w notacji prefix, drugi raz w infix. Różnica jest taka, że nie musisz pisać konwersji prefix -> infix, a jedynie Expression -> infix.

Obie metody będą miały bardzo podobny kod, jedyna różnica będzie w sformatowaniu klasy Operation.

private static String postfixRepr(Expression e) {	
	if (e == null) { // sprawdzamy, czy nie przychodzi pusty obiekt - jeśli tak to zwracamy pusty tekst
		return "";
	} else if (e.getClass().equals(Value.class)) { // sprawdzamy, czy wyrażenie jest wartością
		Value v = (Value) e;
		return v.value + ""; // jeśli jest to zwracamy po prostu wartość, np. "4"
	} else if (e.getClass().equals(Operation.class)) { // sprawdzamy, czy wyrażenie jest operacją
		Operation o = (Operation) o;
		return o.op + postfixRepr(o.arg1) + postfixRepr(o.arg2); // czyli najpierw zwracamy znak (np. "+", a później wartość z wyrażenia pierwszego (np. "4" i drugiego (np. "+21")
	} else {
		throw new IllegalArgumentException(); // jak tutaj dojdzie to znaczy, że coś poszło nie tak
	}
}

Dla infixu będzie analogicznie, jedyna różnica będzie w linijce gdzie zwracasz tekst dla operacji. Zamiast operator-wyrażenie1-wyrażenie2 musisz zwrócić: wyrażenie1-operator-wyrażenie2 w nawiasie.