Introduction à l'utilisation de la bibliothèque binarytree Python
La bibliothèque binarytree est une bibliothèque tierce pour Python. Cette bibliothèque implémente certaines méthodes couramment utilisées liées aux arbres binaires. Lorsque vous utilisez des arbres binaires, vous pouvez les appeler directement sans avoir à les implémenter vous-même.
Dans le même temps, l'arbre de recherche binaire et le tas sont également implémentés dans binarytree, qui peut être appelé directement.
Un, installez binarytree
pip install binarytreeDans la bibliothèque binarytree, il y a 1 classe et 5 fonctions que nous pouvons importer et utiliser. Ce qui suit présentera successivement l'utilisation de chaque classe ou fonction.
__all__ = ['Node', 'tree', 'bst', 'heap', 'build', 'get_parent']Deuxièmement, l'arbre génère un arbre binaire ordinaire
# 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)résultat de l'opération:
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): Utilisé pour générer un arbre binaire aléatoire, la valeur de retour est le nœud racine. Il y a deux paramètres, la hauteur représente la hauteur de l'arbre, la valeur par défaut est 3, prend en charge un entier allant de 0 à 9, une erreur sera signalée si la plage est dépassée, is_perfect représente si l'arbre binaire est un arbre binaire complet, le La valeur par défaut est False, si elle est True, il doit s'agir d'un arbre binaire complet. Si elle est False, ce n'est pas nécessairement un arbre binaire complet. L'arbre généré est aléatoire, le résultat de chaque exécution est donc différent.
Arbre binaire complet: Un arbre binaire complet avec tous les nœuds feuilles en bas est appelé un arbre binaire complet. Un arbre binaire complet est un cas particulier d'un arbre binaire complet. En plus de satisfaire les caractéristiques d'un arbre binaire complet, il vérifie également que tous les nœuds feuilles sont en bas.
Troisièmement, bst génère un arbre de recherche binaire
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)résultat de l'opération:
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 (height = 3, is_perfect = False): Utilisé pour générer un arbre de recherche binaire aléatoire, la valeur de retour est le nœud racine. Il existe deux paramètres, la hauteur représente la hauteur de l'arbre, la valeur par défaut est 3, prend en charge un entier compris entre 0 et 9 et une erreur sera signalée si la plage est dépassée. is_perfect indique si l'arborescence de recherche binaire est un arbre binaire complet. La valeur par défaut est False. Si la valeur est True, il doit s'agir d'un arbre binaire complet. Si elle est False, ce n'est pas nécessairement un arbre binaire complet. Si is_perfect vaut False, l'arborescence générée est aléatoire, donc le résultat de chaque exécution est différent. Si is_perfect vaut True, l'arbre de recherche binaire généré à chaque fois est le même.
L'arbre de recherche binaire présente les caractéristiques suivantes:
1. Si le sous-arbre gauche de l'arbre binaire n'est pas vide, les valeurs de tous les nœuds du sous-arbre gauche sont inférieures à la valeur de son nœud racine.
2. Si le sous-arbre droit de l'arbre binaire n'est pas vide, les valeurs de tous les nœuds du sous-arbre droit sont supérieures à la valeur de son nœud racine.
3. Si vous le regardez indépendamment, le sous-arbre de gauche et le sous-arbre de droite sont également des arbres de recherche binaires, utilisant la pensée récursive jusqu'aux nœuds feuilles de l'arbre.
Quatre, le tas génère un tas
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)résultat de l'opération:
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 5tas (height = 3, is_max = True, is_perfect = False): Utilisé pour générer un tas aléatoire, la valeur de retour est le nœud racine. Il existe trois paramètres, la hauteur représente la hauteur du tas, la valeur par défaut est 3, prend en charge les entiers allant de 0 à 9 et une erreur sera signalée si la plage est dépassée. is_max indique s'il s'agit d'une grande pile supérieure, la valeur par défaut est True, si elle est True, c'est une grande pile supérieure, et si elle est False, c'est une petite pile supérieure. is_perfect indique si le tas est un arbre binaire complet, la valeur par défaut est False, si elle est True, ce doit être un arbre binaire complet, si elle est False, ce n'est pas nécessairement un arbre binaire complet. L'arbre généré est aléatoire, le résultat de chaque exécution est donc différent.
La structure de la pile est divisée en grande pile supérieure et petite pile supérieure:
Big top pile: la valeur de chaque nœud (à l'exception des nœuds feuilles) est supérieure ou égale à la valeur de ses nœuds enfants, et la valeur du nœud racine est la plus grande parmi tous les nœuds.
Petit segment supérieur: la valeur de chaque nœud (à l'exception des nœuds feuilles) est inférieure ou égale à la valeur de ses nœuds enfants, et la valeur du nœud racine est la plus petite de tous les nœuds.
Cinq, build génère d'abord un arbre binaire basé sur la largeur
values = [10, 17, 50, 7, 30, 24, 27, 45, 15, 5, 36, 21]
build_tree = build(values)
print(build_tree)
print(build_tree.values)résultat de l'opération:
_________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 (valeurs): génère une arborescence binaire basée sur la liste de données fournie, et la valeur de retour est le nœud racine. Ajoutez les données de la liste de données à l'arborescence binaire en commençant par la largeur (traversée de l'ordre des couches, c'est-à-dire de haut en bas, de gauche à droite).
Six, récupérez le nœud parent du nœud
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)résultat de l'opération:
_________10______
/ \
___17__ _50
/ \ / \
_7 30 _24 27
/ \ / \ /
45 15 5 36 21
child_node: 30
parent_node: 17get_parent (root, child): Trouvez son nœud parent en fonction du nœud dans l'arborescence binaire, et la valeur de retour est le nœud parent. Il existe deux paramètres, root représente le nœud racine de l'arborescence binaire et enfant représente le nœud enfant. Si la valeur transmise par child est le nœud racine, le résultat du nœud parent renvoyé est None.
Sept, construisez un arbre binaire en créant des nœuds
root = Node(10)
root.left = Node(5)
root.right = Node(15)
print(root)résultat de l'opération:
10
/ \
5 15Classe de nœud (objet): Node est une classe utilisée pour créer un nœud. Il y a trois paramètres lors de l'initialisation, la valeur représente la valeur du nœud, il n'y a pas de valeur par défaut, c'est un paramètre obligatoire, et le paramètre passé doit être un nombre, pas une chaîne, etc., sinon une exception du mauvais type sera jeté. left et right représentent respectivement le nœud enfant gauche et le nœud enfant droit du nœud, qui sont vides par défaut. Les valeurs de left et right doivent être des instances de la classe Node, sinon une exception d'un type incorrect sera levée.
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)résultat de l'opération:
____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 classe Node est utilisée pour créer des nœuds, puis associer les nœuds à une arborescence via les attributs gauche et droit. C'est un peu encombrant par rapport à l'ajout par lots.
Il existe de nombreuses méthodes implémentées dans la classe Node, et de nombreuses méthodes sont décorées avec @property comme attributs, qui peuvent être appelées directement avec le nœud racine. Telles que les quatre méthodes de traversée dans le code ci-dessus.
Si vous voulez connaître toutes les méthodes de la classe Node, vous pouvez utiliser la méthode intégrée dir () pour imprimer toutes les méthodes. Comme la propriété properties, vous pouvez renvoyer chaque valeur de propriété de l'arborescence binaire actuelle et renvoyer un dictionnaire.
print(dir(root))
print(root.properties)résultat de l'opération:
['__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}L'utilisation des autres attributs de la classe Node ne sera pas introduite un par un. Ces attributs sont généralement bien connus.
Le code source de la bibliothèque d'arbres binaires n'est pas compliqué. Les cinq codes de fonction qui peuvent être appelés sont très peu nombreux. La plupart du code consiste à implémenter la classe Node. Dans la classe Node, le code est principalement dû au fait qu'il implémente de nombreuses méthodes couramment utilisées Lorsque vous regardez l'une des méthodes séparément, le code n'est pas beaucoup.
