Árbol de expresión de aplicación simple de árbol binario

Aplicación simple de árbol binario: árbol de expresión

Esta aplicación utiliza principalmente la estructura de un árbol binario.

Si ahora hay una fórmula matemática: (2-3) * (4 + 5)

Abandonar el concepto de paréntesis y precedencia, solo cambiar el orden de los símbolos ** $\ast -23+45$ **

En la formulaAvance del operadorHasta,A cada operador le siguen dos operandos, Recorra de izquierda a derecha para obtener el único paso de cálculo, esta es la expresión polaca

Si existe la siguiente expresión infija:

(2-3) * (4 + 5)

Para encontrar rápidamente las expresiones de prefijo y sufijo, primero completamos los paréntesis a lo siguiente:

((2-3) * (4 + 5))

Luego, coloque todos los operadores delante del paréntesis de apertura al que corresponde, así:

* (- (2 3) + (4 5))

Finalmente, quita los paréntesis y hazte así:

*** - 2 3 + 4 5 **

Esta es la expresión de prefijo y, de la misma forma, se puede obtener la expresión de sufijo.

1. Expresiones binarias y árboles binarios

Las expresiones matemáticas (expresiones aritméticas) tienen una estructura recursiva jerárquica. Un operador actúa sobre el operando correspondiente y su operando puede ser una expresión arbitrariamente compleja. La estructura recursiva de un árbol binario solo se usa para expresar este tipo de expresión. La relación entre el nodo y el subárbol en el árbol binario se puede utilizar para expresar la relación entre el operador y el operando.

Las expresiones que solo contienen operadores binarios se denominan expresiones binarias. De hecho, el ámbito de aplicación del conteo propuesto aquí es mucho más que las expresiones binarias, y se puede utilizar para expresar expresiones matemáticas generales, expresiones lógicas, etc. Las expresiones son un caso especial de expresiones matemáticas binarias, en las que las expresiones básicas son todas números.

Las expresiones binarias se pueden asignar de forma natural a árboles binarios

• Utilice operandos básicos (números y variables) como datos en los nodos hoja
• Datos con operadores como nodos de sucursal
  • Sus dos subárboles son sus operandos
  • El subárbol puede ser un operando básico o una expresión binaria arbitrariamente compleja

Una expresión binaria correctamente estructurada corresponde a un árbol binario completo

Cruce del primer orden raíz: representación de prefijo de la expresión x-ab + / cde (expresión polaca)

Traslado del orden raíz: representación infija de la expresión ab-cd / e + x (expresión polaca inversa)

Cruce de orden de raíz media: representación de sufijo de la expresión a-bxc / d + e

2. Construyendo la expresión

Dado que las expresiones matemáticas establecidas nunca cambiarán, las operaciones matemáticas y las operaciones se basan en expresiones existentes para construir nuevas expresiones. Por lo tanto, una forma razonable es implementarlo como un árbol binario "invariante". La tupla de Python se utiliza como base para la implementación, y la tupla ternaria se usa para implementar nodos de árbol binario

Para que la representación relevante sea más concisa y clara, se realiza una pequeña modificación a la representación del árbol binario propuesto anteriormente. En la tupla correspondiente a la expresión binaria, el objeto de operación básica (número o variable) se colocará directamente en la posición del árbol vacío como objeto básico. Expresión $3\ast (2+5)\; Se$ asigna directamente al árbol binario

('*', (3, Ninguno, Ninguno), ('+', (2, Ninguno, Ninguno), (5, Ninguno, Ninguno)))

Esto significa que siempre habrá una gran cantidad de None que no tiene un significado práctico Para evitar esta situación, lo siguiente se simplifica a una expresión de prefijo entre paréntesis, y los paréntesis indican el alcance del operador.

('*', 3, ('+', 2, 5))

Con esta expresión modificada, la expresión consta de dos estructuras:

• Si es una tupla, es una expresión compuesta en la que el operador actúa sobre el operando
• De lo contrario, es una expresión básica, es decir, un número o una variable.

Los dos anteriores se pueden utilizar para analizar la estructura de la expresión y realizar el procesamiento de la expresión.

# 定义几个表达式构造函数
def make_sum(a,b):
    return ('+', a, b)

def make_pro(a,b):
    return ('*', a, b)

def make_diff(a,b):
    return ('-', a, b)

def make_div(a, b):
    return ('/', a, b)

La siguiente declaración construye una expresión aritmética simple:

el = make_pro (3, make_sum (2,5))

Obviamente, el uso de esta estructura puede construir expresiones con estructuras complejas y usar cadenas para representar variables para construir varias expresiones algebraicas, como:

make_sum (make_prod ('a', a), make_prod ('b', 7))

Al definir funciones de procesamiento de expresiones, a menudo es necesario distinguir entre expresiones básicas (procesamiento directo) y expresiones compuestas (procesamiento recursivo). Para distinguir entre estas dos situaciones, defina una función para determinar si es una expresión básica:

def is_basic_exp(a):
	return not isinstance(a, tuple)

def is_number(x):
    return (isinstance(x, int) or isinstance(x, float) isinstance(x,complex))

Tres. Evaluación de la expresión

La expresión binaria definida anteriormente es una implementación de Python de expresiones matemáticas simples. Según estas definiciones, se pueden implementar varias operaciones de expresión según sea necesario. Por ejemplo, puede definir una función de Python para sumar dos expresiones binarias. Producto, etc., aquí considere una función que encuentra el valor de la expresión.

Reglas para la evaluación de expresiones:

• Para números y variables en expresiones, sus valores son ellos mismos
• Otras expresiones se procesan de acuerdo con la condición del operador y se pueden definir funciones de procesamiento especiales
• Si los dos operandos de un operador son números, puede encontrar un valor

En algunos casos, si el sumando es 0 y el multiplicador es 0 o 1, puede evaluar y simplificar algunas de las expresiones relevantes. En resumen, la llamada evaluación consiste en hacer algunas simplificaciones simples en las expresiones y calcular el Calcular todo

Estas son las partes básicas de la función de evaluación:

def eval_exp(e):
    if is_basic_exp(e):
        return e
    op, a, b = e[0], eval_exp(e[1]), eval_exp(e[2]) # **
    if op == '+':
        return eval_sum(a,b)
    elif op == '-':
        return eval_diff(a,b)
    elif op == '*':
        return eval_prod(a, b)
    elif op == '/':
        return eval_div(a,b)
    else:
        raise ValueError("Unknown operator:", op)
        
def eval_sum(a, b):
    if is_number(a) and is_number(b):
        return a+b
    if is_number(a) and a == 0:
        return b
    if is_number(b) and b == 0:
        return a
    return make_sum(a,b)

def eval_div(a, b):
    if is_number(a) and is_number(b):
        return a / b
    if is_number(a) and a == 0:
        return 0
    if is_number(b) and b == 1:
        return a
    if is_number(b) and b == 0:
        raise ZeroDivisonError
    return make_div(a, b)

El método básico aquí es distribuir diferentes cálculos a funciones específicas basadas en operadores reales. Lo que es particularmente digno de mención es la declaración marcada "**", en la que la sub-expresión es procesada por dos llamadas recursivas a esta función para completar la posibilidad As puede ver más adelante, todo el procesamiento recursivo de árboles binarios usará este modo

Cuando se genera una excepción en la última línea, se proporcionan dos parámetros reales para la excepción ValueError. De hecho, se puede enviar cualquier número de parámetros reales cuando se genera la excepción. Si no hay otro procesamiento, la información de la excepción se emitirá cuando el intérprete de Python muestre la información de la excepción. Los valores de estos parámetros reales, por ejemplo, para la situación anterior, genera los valores reales de las cadenas Operador desconocido y op. Si desea capturar y manejar En tales excepciones, puede obtener los valores de estos parámetros reales a través del mecanismo especial proporcionado por Python.

En el caso de una excepción, se proporcionan dos parámetros reales para la excepción ValueError. De hecho, se puede enviar cualquier número de parámetros reales cuando se genera una excepción. Si no hay otro procesamiento, cuando el intérprete de Python muestra la excepción información, estos parámetros reales se mostrarán. Valor, por ejemplo, para la situación anterior, genera el valor real de la cadena Operador y operación desconocidos. Si desea capturar y manejar esta excepción, puede obtener el valor de estos parámetros a través del mecanismo especial proporcionado por python.