Wie kann der Shunting Yard-Algorithmus die Auswertung mathematischer Ausdrücke in PHP vereinfachen?

Erstellen eines Rechners in PHP

Vereinfachung mathematischer Ausdrücke, die in ein eingegeben werden -Tags in PHP kann eine Herausforderung sein, insbesondere wenn die Originalnotation erhalten bleibt. Während ein Brute-Force-Ansatz zum Ersetzen von Zeichenfolgen durch berechnete Werte zunächst realisierbar erscheint, wird er ineffizient.

Verwendung des Rangierbahnhof-Algorithmus

Eine effektivere Lösung ist das Rangieren Yard-Algorithmus. Es konvertiert Eingabeausdrücke in die umgekehrte polnische Notation (RPN). RPN vereinfacht Berechnungen, da auf Operanden unmittelbar ihre Operatoren folgen.

Implementierungsbeispiel

Der folgende Code stellt eine Implementierung des Shunting Yard-Algorithmus in PHP bereit:

class Expression {

    protected $tokens;
    protected $output;

    // Shunting Yard Algorithm
    public function shuntingYard($input) {
        $stack = [];
        $tokens = $this->tokenize($input);
        foreach ($tokens as $token) {
            if (is_numeric($token)) {
                $this->output[] = $token;
            } else {
                switch ($token) {
                    case '(':
                        $stack[] = $token;
                        break;
                    case ')':
                        while ($stack && end($stack) != '(') {
                            $this->output[] = array_pop($stack);
                        }
                        if (!empty($stack)) {
                            array_pop($stack);
                        }
                        break;
                    default:
                        while ($stack && $this->precedence($token) <= $this->precedence(end($stack))) {
                            $this->output[] = array_pop($stack);
                        }
                        $stack[] = $token;
                        break;
                }
            }
        }
        while (!empty($stack)) {
            $this->output[] = array_pop($stack);
        }
    }

    // Tokenize the input
    public function tokenize($input) {
        preg_match_all('~\d+|~|~U', $input, $tokens);
        return $tokens[0];
    }

    // Operator precedence
    public function precedence($operator) {
        switch ($operator) {
            case '+':
            case '-':
                return 1;
            case '*':
            case '/':
                return 2;
            default:
                return 0;
        }
    }

    // Evaluate the RPN expression
    public function evaluate() {
        $stack = [];
        foreach ($this->output as $token) {
            if (is_numeric($token)) {
                $stack[] = $token;
            } else {
                $operand2 = array_pop($stack);
                $operand1 = array_pop($stack);
                switch ($token) {
                    case '+':
                        $result = $operand1 + $operand2;
                        break;
                    case '-':
                        $result = $operand1 - $operand2;
                        break;
                    case '*':
                        $result = $operand1 * $operand2;
                        break;
                    case '/':
                        $result = $operand1 / $operand2;
                        break;
                }
                $stack[] = $result;
            }
        }
        return array_pop($stack);
    }
}

$expression = new Expression();
$expression->shuntingYard('8*(5+1)');
$result = $expression->evaluate();

echo $result; // Output: 48

Dieser Code übersetzt die Eingabe in RPN, wertet den resultierenden Stapel aus und gibt das Endergebnis zurück Ergebnis.

Das obige ist der detaillierte Inhalt vonWie kann der Shunting Yard-Algorithmus die Auswertung mathematischer Ausdrücke in PHP vereinfachen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!