Funcionamiento básico del árbol binario (implementación C++)

concepto basico

Un árbol binario consta de un conjunto finito de nodos.
Este conjunto finito es un conjunto vacío o un conjunto que consta de un nodo raíz y dos árboles binarios disjuntos llamados subárboles izquierdo y derecho de la raíz.

Características de los árboles binarios

1. Cada nodo tiene como máximo dos subárboles, por lo que no hay ningún nodo con grado mayor que 2 en el árbol binario.
2. El subárbol izquierdo y el subárbol derecho están ordenados y el orden no se puede invertir a voluntad.
3. Incluso si un nodo en el árbol tiene solo un subárbol, también es necesario distinguir si es un subárbol izquierdo o un subárbol derecho.

Cinco formas básicas de árbol binario

1. árbol binario vacío
2. solo un nodo raíz
3. El nodo raíz solo ha dejado el subárbol
4. El nodo raíz solo tiene un subárbol derecho
5. El nodo raíz tiene un subárbol izquierdo y un subárbol derecho

Conceptos relacionados

Arista: Un par ordenado de dos nodos, llamado arista
Grado de un nodo: El número de subárboles que contiene un nodo se convierte en el grado del nodo Nodo
hoja: El grado es 0 El nodo se convierte en un
nodo hoja Ruta (ruta)
longitud de la ruta (la longitud de los caminos)
capas: la raíz es la capa 0 (el número de capa de otros nodos es igual al número de capa de su nodo padre más 1)
profundidad: el mayor número de capas El número de capas de nodos hoja

Conclusiones relacionadas con el árbol binario

Estructura de almacenamiento de árbol binario

La estructura de almacenamiento secuencial de un árbol binario generalmente solo se aplica a un árbol binario completo. Por lo general, cuando representamos un árbol binario, usamos una estructura de almacenamiento encadenada.

lista enlazada binaria

Un árbol binario tiene como máximo dos hijos por nodo, por lo que tiene un campo de datos y dos campos de puntero.
Llamamos a una lista enlazada de este tipo una lista enlazada binaria.
Como se muestra en la imagen:

niño	datos	niño

Entre ellos, data es un campo de datos, y lchild y rchild son ambos campos de puntero, que almacenan punteros al hijo izquierdo y derecho respectivamente.

Definición de estructura de lista enlazada binaria de árbol binario

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

Recorrido de árbol binario

Traversal
visita sistemáticamente los nodos en una estructura de datos de modo que cada nodo se visita exactamente una vez

Recorrido limitado de búsqueda profunda de árboles binarios :
Las siguientes son las definiciones recursivas de tres recorridos primero en profundidad:

recorrido de pedido anticipado

Reglas: si el árbol binario está vacío, la operación regresa, de lo contrario, visite primero el nodo raíz, luego visite el subárbol izquierdo en orden previo, luego visite el subárbol derecho en orden previo

Recorrido en orden

Atraviese el subárbol izquierdo en orden, visite el nodo raíz y atraviese el subárbol derecho en orden

He leído la explicación del tipo grande sobre el recorrido en orden antes: trate cada nodo como una uva, proyecte estas uvas verticalmente en el mismo plano y luego visite de izquierda a derecha, que es un recorrido en orden.

traspaso de pedidos posteriores

Atraviese el subárbol izquierdo en orden posterior, atraviese el subárbol derecho en orden posterior y visite el nodo raíz

pequeño resumen

Recorrido en orden previo : primero la raíz, luego a la izquierda, luego a la derecha
Recorrido en orden : primero a la izquierda, luego a la raíz, luego a la derecha
Recorrido en orden posterior : primero a la izquierda, luego a la derecha, luego a la raíz
Esta raíz se refiere a la raíz de cada subárbol bifurcado ( el nodo raíz de los subárboles izquierdo y derecho) Un nodo no es solo el nodo raíz de todo el árbol

el código

#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;
}

árbol binario especial

1. Árbol binario completo
   En un árbol binario, si todos los nodos de las ramas tienen subárboles izquierdo y derecho y los subárboles izquierdo y derecho están en el mismo nivel, dicho árbol binario se convierte en un árbol binario completo como se muestra en la figura
   :
   

2. Todos los nodos
   tienen solo subárboles a la izquierda llamados árboles oblicuos a la izquierda. Un árbol binario en el que todos los nodos tienen solo subárboles derechos se denomina árbol oblicuo derecho. Ambos se conocen colectivamente como árboles oblicuos. (Esta cosa es en realidad una mesa lineal cuando se ve verticalmente)

3. Si un árbol binario completo
   es un árbol binario con n nodos (numerados de acuerdo con la regla de secuencia), el nodo numerado i (1<=i<=n) y el nodo numerado i en el árbol binario completo de la misma profundidad están en Si las posiciones en el árbol binario son las mismas, el árbol es un árbol binario completo, como se muestra en la figura:

Las propiedades de un árbol binario completo:
1) Los nodos hoja solo pueden estar en las dos capas inferiores
2) Las hojas de la capa inferior deben estar concentradas en la posición continua izquierda
3) Si el grado del nodo es 1, el nodo solo ha dejado niños.
4) En la penúltima capa, si hay un nodo hoja, debe ubicarse en la posición continua a la derecha.
5) El árbol binario del mismo nodo, la profundidad del árbol binario completo es la más pequeña