Structure de données de l'arbre binaire (1): arbre binaire ordinaire
Qu'est-ce qu'un arbre binaire: L'arbre
binaire (arbre binaire) fait référence à un arbre ordonné avec des nœuds dans l'arbre ne dépassant pas 2. C'est l'arbre le plus simple et le plus important. La définition récursive d'un arbre binaire est: un arbre binaire est un arbre vide, ou un arbre non vide composé d'un nœud racine et de deux sous-arbres disjoints, gauche et droit appelés la racine; sous-arbre gauche Et le bon sous-arbre est le même arbre binaire.
Comme le montre la figure:
Termes associés:
① Nœud: contient un élément de données et un certain nombre d'informations pointant vers la branche du sous-arbre.
②Le degré du nœud: le nombre de sous-arbres d'un nœud est appelé le degré du nœud.
③Nœuds de feuille: également appelés nœuds terminaux, nœuds sans sous-arbres ou nœuds avec zéro degré.
④Nœud de branche: également appelé nœud non terminal, le nœud dont le degré n'est pas nul est appelé nœud non terminal.
⑤ Degré de l'arbre: la valeur maximale du degré de tous les nœuds de l'arbre.
⑥ Niveau nœud: à partir du nœud racine, supposons que le nœud racine est le premier niveau, et les nœuds enfants du nœud racine sont le deuxième niveau, et ainsi de suite. Si un nœud est situé au niveau Lth, ses nœuds enfants Situé au L + 1 étage.
⑦La profondeur de l'arbre: également appelée la hauteur de l'arbre, le niveau maximum de tous les nœuds de l'arbre est appelé la profondeur de l'arbre.
 Arbre ordonné: si l'ordre des sous-arbres dans l'arborescence est séquentiel, alors l'arbre est appelé un arbre ordonné.
⑨ Arbre non ordonné: si l'ordre des sous-arbres dans l'arborescence n'est pas séquentiel, l'arbre est appelé un arbre non ordonné.
⑩Forêt: Une forêt est composée de m (m≥0) arbres qui ne se croisent pas. Si le nœud racine d'une arborescence non vide est supprimé, l'arbre devient une forêt et les arbres de la forêt sont composés des sous-arbres du nœud racine d'origine.
Types spéciaux:
1. Arbre binaire complet: Si un arbre binaire n'a que des nœuds de degré 0 et des nœuds de degré 2, et que les nœuds de degré 0 sont au même niveau, l'arbre binaire est un arbre binaire complet.
2. Arbre binaire complet: Un arbre binaire avec une profondeur de k et n nœuds est dit complet si et seulement si chaque nœud correspond à un nœud numéroté de 1 à n dans un arbre binaire complet de profondeur k. Arbre binaire.
La caractéristique d'un arbre binaire complet est que les nœuds feuilles ne peuvent apparaître que sur les deux couches avec la plus grande séquence, et la plus grande séquence de descendants sous la branche gauche d'un nœud est égale ou supérieure à la plus grande séquence de descendants sous la branche droite.
Propriétés de l'arbre binaire :
Nature 1: Il y a au plus 2i-1 (i≥1) nœuds au i-ème niveau de l'arbre binaire.
Propriété 2: L'arbre binaire de profondeur h contient au plus 2h-1 nœuds.
Propriété 3: Si dans un arbre binaire, il y a n0 nœuds feuilles et n2 nœuds de degré 2, alors il doit y avoir n0 = n2 + 1.
Propriété 4: La profondeur d'un arbre binaire complet avec n nœuds est log2x + 1 (où x représente le plus grand entier non supérieur à n).
Propriété 5: Si un arbre binaire complet à n nœuds est numéroté séquentiellement (1≤i≤n), alors pour le nœud numéroté i (i≥1):
lorsque i = 1, le nœud est la racine, Il n'a pas de nœud parent.
Lorsque i> 1, le numéro du nœud parent du nœud est i / 2.
Si 2i≤n, il y a une feuille de gauche numérotée 2, sinon il n'y a pas de feuille de gauche.
Si 2 + 1≤n, alors il y a une feuille de droite numérotée 2i + 1, sinon il n'y a pas de feuille de droite.
Implémentation Java:
Ci - dessous, nous essayons d'utiliser du code java pour implémenter un arbre binaire conventionnel.
Dans cet arbre binaire, nous ajoutons des données à chaque nœud de l'arbre, à savoir HeroNode, et chaque nœud stocke le nom d'un héros.
Dans cet arbre binaire, nous définissons des méthodes pour cela:
y compris trois façons de parcourir l'arbre en pré-ordre, ordre intermédiaire et post-ordre, et la manière
de supprimer les nœuds de l'arbre.
La structure de l'arborescence est illustrée dans la figure:
la sortie du parcours de pré-commande, d'ordre intermédiaire et de post-ordre est illustrée dans la figure:
code montrer comme ci-dessous:
package Tree;
public class BinaryTreeDemo {
public static void main(String[] args) {
BinaryTree binaryTree=new BinaryTree();
HeroNode root=new HeroNode("孙悟空");
HeroNode node1=new HeroNode("猪八戒");
HeroNode node2=new HeroNode("唐三藏");
HeroNode node3=new HeroNode("沙和尚");
HeroNode node4=new HeroNode("牛魔王");
HeroNode node5=new HeroNode("红孩儿");
HeroNode node6=new HeroNode("白骨精");
binaryTree.setRoot(root);
root.setLeftNode(node1);
root.setRightNode(node2);
node1.setLeftNode(node3);
node1.setRightNode(node4);
node2.setLeftNode(node5);
node2.setRightNode(node6);
System.out.println("=======前序遍历=======");
binaryTree.frontShow();
System.out.println("=======中序遍历=======");
binaryTree.middleShow();
System.out.println("=======后序遍历=======");
binaryTree.endShow();
System.out.println("=======删除树节点测试======");
binaryTree.deleteNode("唐三藏");
System.out.println("=======再次前序遍历查看结果=======");
binaryTree.frontShow();
}
}
class BinaryTree{
HeroNode root;
public void setRoot(HeroNode root) {
this.root=root;
}
public void frontShow() {
if(this.root!=null) {
this.root.frontShow();
}else {
System.out.println("二叉树为空，无法遍历");
}
}
public void middleShow() {
if(this.root!=null) {
this.root.middleShow();
}else {
System.out.println("二叉树为空，无法遍历");
}
}
public void endShow() {
if(this.root!=null) {
this.root.endShow();
}else {
System.out.println("二叉树为空，无法遍历");
}
}
public void deleteNode(String value) {
if(this.root!=null) {
if(this.root.value.equals(value)) {
this.root=null;
}else {
root.deleteNode(value);
}
}else {
System.out.println("空树,无法删除");
}
}
}
class HeroNode{
HeroNode leftNode;
HeroNode rightNode;
String value;
public HeroNode(String value) {
this.value=value;
}
public HeroNode getLeftNode() {
return leftNode;
}
public void setLeftNode(HeroNode leftNode) {
this.leftNode=leftNode;
}
public HeroNode getRightNode() {
return rightNode;
}
public void setRightNode(HeroNode rightNode) {
this.rightNode=rightNode;
}
@Override
public String toString() {
return "HeroNode [leftNode=" + leftNode + ", rightNode=" + rightNode + ", value=" + value + "]";
}
/**
* 三种遍历方法
*/
//前序遍历：
public void frontShow() {
System.out.println(this.value);
if(this.getLeftNode()!=null) {
this.getLeftNode().frontShow();
}
if(this.getRightNode()!=null) {
this.getRightNode().frontShow();
}
}
//中序遍历
public void middleShow() {
if(this.getLeftNode()!=null) {
this.getLeftNode().middleShow();
}
System.out.println(this.value);
if(this.getRightNode()!=null) {
this.getRightNode().middleShow();
}
}
//后序遍历
public void endShow() {
if(this.getLeftNode()!=null) {
this.getLeftNode().endShow();
}
if(this.getRightNode()!=null) {
this.getRightNode().endShow();
}
System.out.println(this.value);
}
//删除节点
public void deleteNode(String value) {
if(this.leftNode!=null&&this.leftNode.value.equals(value)) {
this.leftNode=null;
return;
}
if(this.rightNode!=null&&this.rightNode.value.equals(value)) {
this.rightNode=null;
return;
}
if(this.leftNode!=null) {
this.leftNode.deleteNode(value);
}
if(this.rightNode!=null) {
this.rightNode.deleteNode(value);
}
//System.out.println("没有找到要删除的元素");
}
}