Fonctionnement de base de l'arbre binaire (implémentation C++)

concept de base

Un arbre binaire est constitué d'un ensemble fini de nœuds.
Cet ensemble fini est soit un ensemble vide, soit un ensemble constitué d'un nœud racine et de deux arbres binaires disjoints appelés les sous-arbres gauche et droit de la racine.

Caractéristiques des arbres binaires

1. Chaque nœud a au plus deux sous-arbres, il n'y a donc aucun nœud avec un degré supérieur à 2 dans l'arbre binaire.
2. Le sous-arbre gauche et le sous-arbre droit sont ordonnés et l'ordre ne peut pas être inversé à volonté.
3. Même si un nœud de l'arbre n'a qu'un seul sous-arbre, il faut aussi distinguer s'il s'agit d'un sous-arbre gauche ou d'un sous-arbre droit.

Cinq formes de base d'arbre binaire

1. arbre binaire vide
2. un seul nœud racine
3. Le nœud racine n'a que le sous-arbre gauche
4. Le nœud racine n'a qu'un sous-arbre droit
5. Le nœud racine a à la fois un sous-arbre gauche et un sous-arbre droit

Notions connexes

Bord : Une paire ordonnée de deux nœuds, appelée bord
Degré d'un nœud : Le nombre de sous-arbres qu'un nœud contient devient le degré du nœud Nœud
feuille : Le degré est 0 Le nœud devient un
nœud feuille Chemin (chemin)
Longueur du chemin (le longueur des chemins)
couches : la racine est la couche 0 (le nombre de couches des autres nœuds est égal au numéro de couche de son nœud parent plus 1)
profondeur : le plus grand nombre de couches Le nombre de couches de nœuds feuilles

Conclusions liées à l'arbre binaire

Structure de stockage arborescente binaire

La structure de stockage séquentielle d'un arbre binaire n'est généralement applicable qu'à un arbre binaire complet. Habituellement, lorsque nous représentons un arbre binaire, nous utilisons une structure de stockage chaînée.

liste chaînée binaire

Un arbre binaire a au plus deux enfants par nœud, il a donc un champ de données et deux champs de pointeur.
Nous appelons une telle liste chaînée une liste chaînée binaire.
Comme indiqué sur l'image :

lenfant	données	enfant

Parmi eux, data est un champ de données, et lchild et rchild sont tous deux des champs de pointeur, qui stockent respectivement des pointeurs vers l'enfant gauche et l'enfant droit.

Définition de la structure de la liste chaînée binaire de l'arbre binaire

/*定义二叉树的结构*/
typedef struct Node
{
    
    
    char data;                    /*数据域*/
    struct Node *lchild, *rchild; /*左子树和右子树*/
} * BiTree, BiNode;
/*整棵树和结点名称*/

Parcours d'arbre binaire

La traversée
visite systématiquement les nœuds d'une structure de données de telle sorte que chaque nœud est visité exactement une fois

Parcours limité de recherche profonde d'arbres binaires :
Voici les définitions récursives de trois parcours en profondeur d'abord :

traversée de précommande

Règles : si l'arbre binaire est vide, l'opération revient, sinon, visitez d'abord le nœud racine, puis visitez le sous-arbre de gauche en préordre, puis visitez le sous-arbre de droite en préordre

Parcours dans l'ordre

Traversez le sous-arbre de gauche dans l'ordre, visitez le nœud racine et traversez le sous-arbre de droite dans l'ordre

J'ai déjà lu l'explication du grand gars sur la traversée dans l'ordre : traitez chaque nœud comme un raisin, projetez ces raisins verticalement sur le même plan, puis visitez de gauche à droite, ce qui est une traversée dans l'ordre.

traversée post-commande

Traversez le sous-arbre gauche en post-ordre, traversez le sous-arbre droit en post-ordre et visitez le nœud racine

petit résumé

Parcours pré-ordre : première racine, puis gauche, puis droite
Parcours dans l'ordre : premier gauche, puis racine, puis droite
Parcours post-ordre : premier gauche, puis droite, puis racine
Cette racine fait référence à la racine de chaque sous-arbre fourchu ( le nœud racine des sous-arbres gauche et droit) Un nœud n'est pas seulement le nœud racine de l'arbre entier

le code

#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
/*定义二叉树的结构*/
typedef struct Node
{
    
    
    char data;                    /*数据域*/
    struct Node *lchild, *rchild; /*左子树和右子树*/
} * BiTree, BiNode;
/*整棵树和结点名称*/

/*先需创建二叉树*/
void CreateBiTree(BiTree &T)
{
    
    
    char ch;
    cin >> ch;
    if (ch == '#')
        T = NULL;
    else
    {
    
    
        T = new BiNode; /*创建一个新节点*/
        T->data = ch;
        CreateBiTree(T->lchild);
        CreateBiTree(T->rchild);
    }
    /*递归创建*/
}
void InOrderTraverse(BiTree T)
{
    
    
    /*中序遍历*/
    if (T)
    {
    
    
        InOrderTraverse(T->lchild);
        cout << T->data;
        InOrderTraverse(T->rchild);
    }
}
void PreOrderTraverse(BiTree T)
{
    
    
    /*先序遍历*/
    if (T)
    {
    
    
        cout << T->data;
        PreOrderTraverse(T->lchild);
        PreOrderTraverse(T->rchild);
    }
}
void PostOrderTraverse(BiTree T)
{
    
    
    /*后序遍历*/
    if (T)
    {
    
    
        PostOrderTraverse(T->lchild);
        PostOrderTraverse(T->rchild);
        cout << T->data;
    }
}
/*统计二叉树中结点的个数*/
int NodeCount(BiTree T)
{
    
    
    if (T == NULL)
        return 0;
    else
        return NodeCount(T->lchild) + NodeCount(T->rchild) + 1;
}
/*求树的深度*/
int Depth(BiTree T)
{
    
    
    if (T == NULL)
        return 0;
    else
    {
    
    
        int i = Depth(T->lchild);
        int j = Depth(T->rchild);
        return i > j ? i + 1 : j + 1;
    }
}
/*复制二叉树*/
void Copy(BiTree T, BiTree &NewT)
{
    
    
    if (T = NULL)
    {
    
    
        NewT = NULL;
        return;
    }
    else
    {
    
    
        NewT = new BiNode;
        NewT->data = T->data;
        Copy(T->lchild, NewT->lchild);
        Copy(T->rchild, NewT->rchild);
    }
}
/*统计二叉树中叶子结点的个数*/
int LeafCount(BiTree T)
{
    
    
    if (!T)
        return 0;
    if (!T->lchild && !T->rchild)
        return 1;
    /*如果二叉树左子树和右子树皆为空，说明该二叉树根节点为叶子结点，结果为1*/
    else
        return LeafCount(T->lchild) + LeafCount(T->rchild);
}
/*二叉树中从每个叶子结点到跟结点的路径*/
void PrintAllPath(BiTree T, char path[], int pathlen)
{
    
    
    int i;
    if (T != NULL)
    {
    
    
        path[pathlen] = T->data; /*将当前结点放入路径中*/
        if (T->lchild == NULL && T->rchild == NULL)
        {
    
    
            /*若这个节点是叶子结点*/
            for (i = pathlen; i >= 0; i--)
                cout << path[i] << "　";
            cout << "\n";
        }
        else
        {
    
    
            PrintAllPath(T->lchild, path, pathlen + 1);
            PrintAllPath(T->rchild, path, pathlen + 1);
        }
    }
}
/*判断二叉树是否为空*/
int BiTree_empty(BiTree T)
{
    
    
    if (T)
        return 1;
    else
        return 0;
}
int main()
{
    
    
    BiTree T;
    //测试数据AB#CD##E##F#GH###
    cout << "先序遍历输入(以#结束)：";
    CreateBiTree(T);
    cout << "中序遍历输出：";
    InOrderTraverse(T);
    cout << endl
         << "先序遍历输出:";
    PreOrderTraverse(T);
    cout << "\n"
         << "后序遍历输出:";
    PostOrderTraverse(T);
    cout << endl
         << "树的深度:" << Depth(T);
    cout << endl
         << "结点的个数:" << NodeCount(T);
    cout << endl
         << "二叉树中从每个叶子结点到根结点的所有路径：" << endl;
    char path[256];
    int pathlen = 0;
    PrintAllPath(T, path, pathlen);
    return 0;
}

arbre binaire spécial

1. Arbre binaire complet
   Dans un arbre binaire, si tous les nœuds de branche ont des sous-arbres gauche et droit et que les sous-arbres gauche et droit sont au même niveau, un tel arbre binaire devient un arbre binaire complet comme le montre la figure
    :
   

2. Tous les nœuds
   n'ont que des sous-arbres gauches appelés arbres obliques gauches. Un arbre binaire dans lequel tous les nœuds n'ont que des sous-arbres droits est appelé un arbre oblique droit. Les deux sont collectivement appelés arbres obliques. (Cette chose est en fait une table linéaire lorsqu'elle est vue verticalement)

3. Si un arbre binaire complet
   est un arbre binaire à n nœuds (numérotés selon la règle de séquence), le nœud numéroté i (1<=i<=n) et le nœud numéroté i dans l'arbre binaire complet de même profondeur sont dans Si les positions dans l'arbre binaire sont les mêmes, l'arbre est un arbre binaire complet, comme le montre la figure :

Les propriétés d'un arbre binaire complet :
1) Les nœuds feuilles ne peuvent être que dans les deux couches inférieures
2) Les feuilles de la couche inférieure doivent être concentrées dans la position continue gauche
3) Si le degré du nœud est 1, le nœud n'a plus qu'à gauche enfants.
4) Dans l'avant-dernière couche, s'il y a un nœud feuille, il doit être situé en position continue à droite.
5) L'arbre binaire du même nœud, la profondeur de l'arbre binaire complet est la plus petite