Bagaimana untuk Membina Kalkulator PHP Menggunakan Algoritma Shunting-Yard?

Cara Membuat Kalkulator dalam PHP

Masalah:

Buat kalkulator PHP yang boleh menilai ungkapan algebra mudah yang dimasukkan oleh pengguna dalam tatatanda algebra standard, termasuk ungkapan dengan kurungan.

Pendekatan Biasa:

Penyelesaian yang tidak cekap tetapi sementara melibatkan penggantian ungkapan dalam perwakilan rentetan ungkapan, seperti:

for ($a=1; $a < 1000; $a++) {
    for ($b=1; $b < 1000; $b++) {
        string_replace($a . '*' . $b, $a*$b, $string);
    }
}

Algoritma Halaman Shunting:

A pendekatan yang lebih cekap ialah menggunakan algoritma Shunting Yard.

Pelaksanaan:

Ungkapan Terminal (Nilai dan Operator):

abstract class TerminalExpression {
    protected $value = '';

    public static function factory($value) {
        // Create terminal expressions based on the provided value (number, operator, or parenthesis)
    }

    abstract public function operate(Stack $stack);
}

class Number extends TerminalExpression {
    public function operate(Stack $stack) {
        return $this->value;
    }
}

class Operator extends TerminalExpression {
    protected $precidence = 0;
    protected $leftAssoc = true;

    public function getPrecidence() {
        return $this->precidence;
    }

    public function isLeftAssoc() {
        return $this->leftAssoc;
    }
}

class Addition extends Operator {
    protected $precidence = 4;
}

class Subtraction extends Operator {
    protected $precidence = 4;
}

class Multiplication extends Operator {
    protected $precidence = 5;
}

class Division extends Operator {
    protected $precidence = 5;
}

class Parenthesis extends TerminalExpression {
    protected $precidence = 7;

    public function isParenthesis() {
        return true;
    }
}

Timbunan Pelaksanaan:

class Stack {
    protected $data = [];
    public function push($element) {
        array_push($this->data, $element);
    }
    public function pop() {
        return array_pop($this->data);
    }
}

Kelas Matematik (Pelaksana):

class Math {
    protected $variables = [];

    public function evaluate($string) {
        $stack = $this->parse($string);
        return $this->run($stack);
    }

    public function parse($string) {
        // Tokenize expression
        $tokens = array_map('trim', preg_split('((\d+|\+|-|\(|\)|\*|/)|\s+)', $string, null, PREG_SPLIT_NO_EMPTY | PREG_SPLIT_DELIM_CAPTURE));

        // Parse operators and parentheses using the Shunting Yard algorithm
        $output = new Stack();
        $operators = new Stack();

        foreach ($tokens as $token) {
            $expression = TerminalExpression::factory($token);

            if ($expression->isOperator()) {
                $this->parseOperator($expression, $output, $operators);
            } elseif ($expression->isParenthesis()) {
                $this->parseParenthesis($expression, $output, $operators);
            } else {
                $output->push($expression);
            }
        }

        // Pop remaining operators on stack and push to output
        while (($op = $operators->pop()) && $op->isOperator()) {
            if ($op->isParenthesis()) {
                throw new RuntimeException('Mismatched Parenthesis');
            }
            $output->push($op);
        }

        return $output;
    }

    public function run(Stack $stack) {
        // Evaluate stack and return result
        while (($operator = $stack->pop()) && $operator->isOperator()) {
            $value = $operator->operate($stack);
            $stack->push(TerminalExpression::factory($value));
        }

        return $operator ? $operator->render() : $this->render($stack);
    }

    protected function extractVariables($token) {
        if ($token[0] == '$') {
            $key = substr($token, 1);
            return isset($this->variables[$key]) ? $this->variables[$key] : 0;
        }
        return $token;
    }

    // ...
}

Menggunakan pelaksanaan ini, anda boleh menilai ungkapan seperti berikut:

$math = new Math();
$answer = $math->evaluate('(2 + 3) * 4'); // 20
$answer = $math->evaluate('1 + 2 * ((3 + 4) * 5 + 6)'); // 83
$answer = $math->evaluate('(1 + 2) * (3 + 4) * (5 + 6)'); // 231
$math->registerVariable('a', 4);
$answer = $math->evaluate('($a + 3) * 4'); // 28

Atas ialah kandungan terperinci Bagaimana untuk Membina Kalkulator PHP Menggunakan Algoritma Shunting-Yard?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!