Introducción al uso de la biblioteca binarytree de Python
La biblioteca binarytree es una biblioteca de terceros para Python. Esta biblioteca implementa algunos métodos de uso común relacionados con árboles binarios. Cuando utilice árboles binarios, puede llamarlos directamente sin tener que implementarlos usted mismo.
Al mismo tiempo, el árbol de búsqueda binaria y el montón también se implementan en binarytree, al que se puede llamar directamente.
Uno, instale binarytree
pip install binarytreeEn la biblioteca binarytree, hay 1 clase y 5 funciones que podemos importar y utilizar. A continuación, se presentará el uso de cada clase o función a su vez.
__all__ = ['Node', 'tree', 'bst', 'heap', 'build', 'get_parent']Dos, el árbol genera un árbol binario ordinario.
# coding=utf-8
from binarytree import *
tree0 = tree()
print('tree0:', tree0)
tree1 = tree(height=2, is_perfect=True)
print('tree1:', tree1)
tree2 = tree(height=2, is_perfect=False)
print('tree2:', tree2)resultado de la operación:
tree0:
_______13_____
/ \
___11__ _0__
/ \ / \
1 6 10 8
\ / \ / / \
14 2 3 5 9 4
tree1:
__2__
/ \
3 4
/ \ / \
1 5 6 0
tree2:
2__
/ \
0 6
/ /
3 1tree (height = 3, is_perfect = False): se utiliza para generar un árbol binario aleatorio, el valor de retorno es el nodo raíz. Hay dos parámetros, la altura representa la altura del árbol, el valor predeterminado es 3, admite un número entero de 0 a 9, se informará un error si se excede el rango, is_perfect representa si el árbol binario es un árbol binario completo, el el valor predeterminado es Falso, si es Verdadero, debe ser un árbol binario completo. Si es Falso, no es necesariamente un árbol binario completo. El árbol generado es aleatorio, por lo que el resultado de cada ejecución es diferente.
Árbol binario completo: un árbol binario completo con todos los nodos de hojas en la parte inferior se denomina árbol binario completo. Un árbol binario completo es un caso especial de un árbol binario completo. Además de satisfacer las características de un árbol binario completo, también satisface que todos los nodos de hojas estén en la parte inferior.
Tres, bst genera un árbol de búsqueda binario
bst0 = bst()
print('bst0:', bst0)
bst1 = bst(height=2, is_perfect=True)
print('bst1:', bst1)
bst2 = bst(height=2, is_perfect=False)
print('bst2:', bst2)resultado de la operación:
bst0:
____4______
/ \
0__ __11___
\ / \
3 8 _13
/ / \ / \
1 7 9 12 14
bst1:
__3__
/ \
1 5
/ \ / \
0 2 4 6
bst2:
__3
/ \
1 4
/ \
0 2bst (altura = 3, is_perfect = False): se utiliza para generar un árbol de búsqueda binario aleatorio, el valor de retorno es el nodo raíz. Hay dos parámetros, la altura representa la altura del árbol, el valor predeterminado es 3, admite un número entero de 0 a 9 y se informará un error si se excede el rango. is_perfect indica si el árbol de búsqueda binario es un árbol binario completo. El valor predeterminado es Falso. Si es Verdadero, debe ser un árbol binario completo. Si es Falso, no es necesariamente un árbol binario completo. Si is_perfect es False, el árbol generado es aleatorio, por lo que el resultado de cada ejecución es diferente. Si is_perfect es Verdadero, el árbol de búsqueda binario generado es el mismo.
El árbol de búsqueda binaria tiene las siguientes características:
1. Si el subárbol izquierdo del árbol binario no está vacío, los valores de todos los nodos del subárbol izquierdo son menores que el valor de su nodo raíz.
2. Si el subárbol derecho del árbol binario no está vacío, los valores de todos los nodos del subárbol derecho son mayores que el valor de su nodo raíz.
3. Si lo mira de forma independiente, el subárbol izquierdo y el subárbol derecho también son árboles de búsqueda binarios, utilizando el pensamiento recursivo hasta los nodos hoja del árbol.
Cuatro, el montón genera un montón
heap0 = heap()
print('heap0:', heap0)
heap1 = heap(height=2, is_max=True, is_perfect=True)
print('heap1:', heap1)
heap2 = heap(height=2, is_max=False, is_perfect=True)
print('heap2:', heap2)
heap3 = heap(height=2, is_max=False, is_perfect=False)
print('heap3:', heap3)resultado de la operación:
heap0:
_______14________
/ \
__10__ ____13__
/ \ / \
8 9 12 5
/ \ / \ / \ / \
7 2 6 3 1 11 4 0
heap1:
__6__
/ \
5 4
/ \ / \
1 2 3 0
heap2:
__0__
/ \
4 1
/ \ / \
6 5 2 3
heap3:
__1
/ \
4 3
/ \
6 5heap (altura = 3, is_max = True, is_perfect = False): se utiliza para generar un montón aleatorio, el valor de retorno es el nodo raíz. Hay tres parámetros, la altura representa la altura del montón, el valor predeterminado es 3, admite números enteros que van de 0 a 9 y se informará un error si se excede el rango. is_max indica si es una pila superior grande, el valor predeterminado es Verdadero, si es Verdadero, es una pila superior grande y si es Falso, es una pila superior pequeña. is_perfect indica si el montón es un árbol binario completo, el valor predeterminado es Falso, si es Verdadero, debe ser un árbol binario completo, si es Falso, no es necesariamente un árbol binario completo. El árbol generado es aleatorio, por lo que el resultado de cada ejecución es diferente.
La estructura de la pila se divide en pila superior grande y pila superior pequeña:
Pila superior grande: el valor de cada nodo (excepto los nodos hoja) es mayor o igual que el valor de sus nodos secundarios, y el valor del nodo raíz es el mayor entre todos los nodos.
Montón superior pequeño: el valor de cada nodo (excepto los nodos hoja) es menor o igual que el valor de sus nodos secundarios, y el valor del nodo raíz es el más pequeño entre todos los nodos.
Cinco, build genera un árbol binario basado en la amplitud primero
values = [10, 17, 50, 7, 30, 24, 27, 45, 15, 5, 36, 21]
build_tree = build(values)
print(build_tree)
print(build_tree.values)resultado de la operación:
_________10______
/ \
___17__ _50
/ \ / \
_7 30 _24 27
/ \ / \ /
45 15 5 36 21
[10, 17, 50, 7, 30, 24, 27, 45, 15, 5, 36, 21]build (valores): genera un árbol binario basado en la lista de datos proporcionada, y el valor de retorno es el nodo raíz. Agregue los datos en la lista de datos al árbol binario de una manera en amplitud (orden transversal de la capa, es decir, de arriba a abajo, de izquierda a derecha).
Seis, obtén el nodo padre del nodo.
values = [10, 17, 50, 7, 30, 24, 27, 45, 15, 5, 36, 21]
build_tree = build(values)
print(build_tree)
child_node = build_tree.left.right
print('child_node: ', child_node.value)
parent = get_parent(build_tree, child_node)
print('parent_node: ', parent.value)resultado de la operación:
_________10______
/ \
___17__ _50
/ \ / \
_7 30 _24 27
/ \ / \ /
45 15 5 36 21
child_node: 30
parent_node: 17get_parent (root, child): encuentra su nodo principal de acuerdo con el nodo en el árbol binario, y el valor de retorno es el nodo principal. Hay dos parámetros, la raíz representa el nodo raíz del árbol binario y el secundario representa el nodo secundario. Si el valor pasado por el hijo es el nodo raíz, el resultado del nodo padre devuelto es Ninguno.
Siete, construye un árbol binario creando nodos
root = Node(10)
root.left = Node(5)
root.right = Node(15)
print(root)resultado de la operación:
10
/ \
5 15Clase de nodo (objeto): Nodo es una clase que se utiliza para crear un nodo. Hay tres parámetros durante la inicialización, el valor representa el valor del nodo, no hay un valor predeterminado, es un parámetro obligatorio y el parámetro pasado debe ser un número, no una cadena, etc., de lo contrario una excepción del error se lanzará el tipo. left y right representan el nodo hijo izquierdo y el nodo hijo derecho del nodo respectivamente, que están vacíos por defecto. Los valores de left y right deben ser instancias de la clase Node, de lo contrario se lanzará una excepción del tipo incorrecto.
data = [10, 17, 50, 7, 30, 24, 27, 45, 15, 5, 36, 21]
nodes = [None if i is None else Node(i) for i in data]
root = nodes[0]
root.left = nodes[1]
root.right = nodes[2]
root.left.left = nodes[3]
root.left.right = nodes[4]
root.right.left = nodes[5]
root.right.right = nodes[6]
root.pprint()
print('层序遍历： ', root.levelorder)
print('先序遍历： ', root.preorder)
print('中序遍历： ', root.inorder)
print('后序遍历： ', root.postorder)resultado de la operación:
____10___
/ \
17 _50
/ \ / \
7 30 24 27
层序遍历： [Node(10), Node(17), Node(50), Node(7), Node(30), Node(24), Node(27)]
先序遍历： [Node(10), Node(17), Node(7), Node(30), Node(50), Node(24), Node(27)]
中序遍历： [Node(7), Node(17), Node(30), Node(10), Node(24), Node(50), Node(27)]
后序遍历： [Node(7), Node(30), Node(17), Node(24), Node(27), Node(50), Node(10)]La clase Node se utiliza para crear nodos y luego asociar los nodos a un árbol a través de los atributos izquierdo y derecho, lo que resulta un poco engorroso en comparación con la adición por lotes.
Hay muchos métodos implementados en la clase Node, y muchos métodos están decorados con @property como atributos, que se pueden llamar directamente con el nodo raíz. Como los cuatro métodos transversales del código anterior.
Si desea conocer todos los métodos de la clase Node, puede utilizar el método incorporado dir () para imprimir todos los métodos. Como la propiedad de propiedades, puede devolver cada valor de propiedad del árbol binario actual y devolver un diccionario.
print(dir(root))
print(root.properties)resultado de la operación:
['__class__', '__delattr__', '__delitem__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'height', 'inorder', 'is_balanced', 'is_bst', 'is_complete', 'is_max_heap', 'is_min_heap', 'is_perfect', 'is_strict', 'is_symmetric', 'leaf_count', 'leaves', 'left', 'levelorder', 'levels', 'max_leaf_depth', 'max_node_value', 'min_leaf_depth', 'min_node_value', 'postorder', 'pprint', 'preorder', 'properties', 'right', 'size', 'val', 'validate', 'value', 'values']
{'height': 2, 'size': 7, 'is_max_heap': False, 'is_min_heap': False, 'is_perfect': True, 'is_strict': True, 'is_complete': True, 'leaf_count': 4, 'min_node_value': 7, 'max_node_value': 50, 'min_leaf_depth': 2, 'max_leaf_depth': 2, 'is_bst': False, 'is_balanced': True, 'is_symmetric': False}El uso de otros atributos en la clase Node no se introducirá uno por uno Estos atributos son generalmente bien conocidos.
El código fuente de la biblioteca binarytree no es complicado. Los cinco códigos de función que se pueden llamar son muy pocos. La mayor parte del código es para implementar la clase Node. En la clase Node, el código se debe principalmente a que implementa muchos métodos de uso común Cuando miras uno de los métodos por separado, el código no es mucho.
