Arbre de tri binaire
1 Commencez par examiner une exigence.
Donnez-vous une séquence (7, 3, 10, 12, 5, 1, 9), qui nécessite une requête et un ajout de données efficaces.
2 Analyse de la solution
Utiliser un tableau Le
tableau n'est pas trié Avantages: ajouter directement à la fin du tableau, ce qui est rapide. Inconvénients: vitesse de recherche lente.
Tri des tableaux. Avantages: la recherche binaire peut être utilisée. La vitesse de recherche est rapide. Inconvénients: Afin d'assurer l'ordre du tableau, lors de l'ajout de nouvelles données, après avoir trouvé la position d'insertion
, les données suivantes ont besoin être déplacé dans son ensemble, ce qui est lent.
Utiliser la liste liée au stockage en chaîne
Peu importe si la liste liée est ordonnée ou non, la vitesse de recherche est lente et la vitesse d'ajout de données est plus rapide que celle des tableaux, et il n'est pas nécessaire de déplacer les données dans leur ensemble.
Utilisez un arbre de tri binaire
3 L'arbre de tri binaire décrit l'arbre de tri
binaire: BST: ( Arbre de tri binaire (recherche )), pour tout arbre de tri binaire de noeud non-feuille, la valeur requise du noeud enfant gauche que lorsqu'une
petite valeur avant le noeud, et son fils droit La valeur du nœud est supérieure à la valeur du nœud actuel.
Remarque spéciale: si vous avez la même valeur, vous pouvez placer le nœud dans le nœud enfant gauche ou dans le nœud enfant droit. Par
exemple, pour les données précédentes (7, 3, 10, 12, 5, 1, 9), le l'arbre de tri binaire correspondant est: 
4 Création d'arbre de tri binaire et parcours d'
un tableau pour créer un arbre de tri binaire correspondant, et utilisation du parcours dans l'ordre de l'arbre de tri binaire, par exemple: le tableau est Array (7, 3, 10, 12, 5, 1, 9) L'
arbre de tri binaire correspondant est créé comme suit: 
5 Suppression de l'
arbre de tri binaire La situation de suppression de l'arbre de tri binaire est plus compliquée et il y a trois situations à considérer.
- Supprimer les nœuds feuilles (par exemple: 2, 5, 9, 12)
- Supprimer les nœuds avec un seul sous-arbre (par exemple: 1)
- Supprimez les nœuds avec deux sous-arbres (par exemple: 7, 3, 10)
- Analyse
de l'idée d'opération Analyse de réflexion de différentes situations de suppression de nœuds: La
première situation:
suppression de nœuds feuilles (par exemple: 2, 5, 9, 12)
Idées
(1) Besoin de trouver le nœud à supprimer targetNode
( 2) Trouver le parent nœud parent de
targetNode (3) Déterminer si targetNode est le noeud enfant gauche ou noeud enfant droit de parent
(4) Supprimer en conséquence en fonction de la situation antérieure
gauche nœud enfant parent.left = null
parent nœud enfant droit de .RIGHT = null;
Le deuxième cas: supprimer un nœud avec un seul sous-arbre tel que 1
idée
(1) d'abord besoin de trouver le nœud à supprimer targetNode
(2) trouver le nœud parent de targetNode
(3) déterminer le targetNode Est le nœud enfant un nœud enfant gauche ou un nœud enfant droit
(4) Est targetNode un nœud enfant gauche ou un nœud enfant droit du parent
(5) Si targetNode a un nœud enfant gauche
(5). 1 Si targetNode est un nœud enfant gauche du parent Child node
parent.left = targetNode.left;
(5) .2 Si targetNode est le nœud enfant droit du parent
parent.right = targetNode.left;
(6) Si targetNode a un nœud enfant droit
(6). 1 Si targetNode est le nœud enfant gauche du parent
parent.left = targetNode.right;
(6). 2 Si targetNode est le nœud enfant droit du parent
parent.right = targetNode.righ
Cas 3: Supprimez le nœud avec deux sous-arbres. (Par exemple: 7, 3, 10)
Idée
(1) Besoin de trouver le nœud à supprimer en premier targetNode
(2) Trouvez le nœud parent du parent targetNode
(3) ) Trouvez le plus petit nœud du sous-arbre droit de targetNode
(4) Utilisez une variable temporaire pour enregistrer la valeur du plus petit nœud temp = 11
(5) Supprimez le plus petit nœud
(6) targetNode.value = temp
6
Paquet d' implémentation de code de suppression d'arbre de tri binaire com.lin.binarysorttree_0314;
classe publique BinarySortTreeTest {
public static void main(String[] args) {
int[] arr = {7, 3, 10, 12, 5, 1, 9};
BinarySortTree binarySortTree = new BinarySortTree();
for (int i = 0; i < arr.length; i++) {
binarySortTree.add(new SNode(arr[i]));
}
binarySortTree.add(new SNode(2));
binarySortTree.infixOrder();
// 删除
System.out.println("***********");
binarySortTree.delNode(2);
binarySortTree.delNode(3);
binarySortTree.delNode(5);
binarySortTree.delNode(7);
binarySortTree.delNode(9);
binarySortTree.delNode(12);
System.out.println("root:" + binarySortTree.getRoot());
binarySortTree.infixOrder();
}
}
class BinarySortTree { private SNode root; // Trouver le nœud à supprimer public SNode getRoot () { return root; } public SNode searchDelNode (int value) { if (root == null) { return null; } else { return root. searchDelNode (value); } } // Trouver le nœud parent du nœud à supprimer SNode public searchParent (int value) { if (root == null) { return null; } else { return root.searchParent (value); } } / ** * @param node le nœud entrant (en tant que nœud racine de l'arbre de tri binaire) * @return la valeur du plus petit nœud de l'arbre de tri binaire avec node comme nœud racine * / public int delRightTreeMin (nœud SNode ) { Cible SNode = nœud;
// Trouvez le nœud gauche dans une boucle, et vous trouverez la valeur minimale
while (target.left! = Null) { target = target.left; } delNode (target.value); // !!! return target.value ; //! !! }
// 删除节点
public void delNode(int value) {
if(root == null) {
return;
} else {
// 找删除节点
SNode targetNode = searchDelNode(value);
// 没有找到
if(targetNode == null) {
return;
}
// 如果发现当前这棵二叉树只有一个节点
if(root.left == null && root.right == null) {
root = null;
return;
}
// 去找到targetNode的父节点
SNode parent = searchParent(value);
// 如果删除的节点是叶子节点
if(targetNode.left == null && targetNode.right == null) {
// 判断targetNode是父节点的左子节点还是右子节点
if(parent.left != null && parent.left.value == value) {
parent.left = null;
} else if(parent.right != null && parent.right.value == value) {
parent.right = null;
}
} else if(targetNode.left != null && targetNode.right != null) { // 有左右子节点
int delRightTreeMin = delRightTreeMin(targetNode.right);
targetNode.value = delRightTreeMin;
} else {// 只有一个子节点
// 要删除的节点只有左节点
if(targetNode.left != null) {
if(parent != null) {
// 如果targetNode是parent的左子节点
if(parent.left.value == value) {
parent.left = targetNode.left;
} else {
parent.right = targetNode.left;
}
} else {
root = targetNode.left;
}
} else {// 要删除的节点有右子节点
if(parent != null) {
if(parent.left.value == value) {
parent.left = targetNode.right;
} else {
parent.right = targetNode.right;
}
} else {
root = targetNode.right;
}
}
}
}
}
// 中序遍历
public void infixOrder() {
if(root == null) {
System.out.println("空树！");
} else {
root.infixOrder();
}
}
// 添加
public void add(SNode node) {
if(root == null) {
root = node;
} else {
root.add(node);
}
}
}
classe SNode { valeur int protégée; protégé SNode gauche; droit SNode protégé;
public SNode(int value) {
// TODO Auto-generated constructor stub
this.value = value;
}
@Override
public String toString() {
// TODO Auto-generated method stub
return "Node = [value = " + value + "]";
}
// 添加节点
public void add(SNode node) {
if(node == null) {
return;
}
if(node.value < this.value) {
if(this.left == null) {
this.left = node;
} else {
this.left.add(node);
}
} else {
if(this.right == null) {
this.right = node;
} else {
this.right.add(node);
}
}
}
// 中序遍历
public void infixOrder() {
if(this.left != null) {
this.left.infixOrder();
}
System.out.println(this);
if(this.right != null) {
this.right.infixOrder();
}
}
// 查找要删除的节点
public SNode searchDelNode(int value) {
if(this.value == value) {
return this;
} else if(this.value > value) {
// 如果左子节点为空
if(this.left == null) {
return null;
}
return this.left.searchDelNode(value);
} else {
if(this.right == null) {
return null;
}
return this.right.searchDelNode(value);
}
}
// 查找要删除节点的父节点, 如果没有则返回null
public SNode searchParent(int value) {
if(( this.left != null && this.left.value == value)
|| ( this.right != null && this.right.value == value )) {
return this;
} else {
// 如果查找的值小于当前节点的值，并且当前节点的左子节点不为空
if(value < this.value && this.left != null) {
return this.left.searchParent(value);
} else if(value >= this.value && this.right != null) {
return this.right.searchParent(value);
} else {
return null;
}
}
}
} 
Toutes les similitudes sont purement fortuites. Suivez l'éditeur pour plus d'informations ...