Construír unha árbore binaria a partir de interrogación de interésación e preordenio

#include

#include

#include

Usando o espazo de nomes STD;

// Estrutura de datos para almacenar un nodo de árbore binario

Nodo de estrutura

{

Int tecla;

nodo * esquerda, * dereita;

};

// función para crear un novo nodo de árbore binario que deu a tecla

nodo * newnode (tecla INT)

{

node * node = nodo novo;

node- > key = tecla;

node- > esquerda = nodo- > dereito = nullptr;

Nodo de devolución;

}

// función recursiva para realizar o percorrido indecedor dunha árbore binaria

Void inorderTraversal (nodo * root )

{

se (root == nullptr)

devolver;

InorderTraversal (root- > á esquerda);

cout < < Root- > ke y < < ”;

InorderTraversal (root- > Dereito);

}

// función recursiva para realizar o percorrido posture dunha árbore binaria

Void preorderstraversal (nodo * root)

{

se (root == nullptr)

devolve;

cout < < Root- > tecla < < ”;

PreorderTraversal (Root- > esquerda);

PreorderTraverSal (Root- > DEREITO );

}

// función recursiva para construír unha árbore binaria a partir de

// Secuencia de comprensión e preordenización

nodo * constrúe (vector < int > const &, Inturer, Int Start, Int End,

Vector < int > const & preorden, int pindex,

Unordered_map < int, int > & mapa)

{

// caixa base

se (iniciar > final )

devolver nullptr;

// O seguinte elemento no preorden será o nodo raíz do subárbol

// formado por InOrder

Nodo * root = newnode (preorden);

// Obter o índice de nodo raíz en menos para determinar a

// límite de subárbase esquerda e dereita

int index = mapa;

// Construír recursivamente o subárbol esquerdo

Root- > esquerda = construír (Inorder, comezar, Índice – 1, preorden, Pindex, mapa);

// Construír recursivamente o subárbol dereito

Root- > dereito = constrúe ( Inorder, índice + 1, final, preorden, Pinderx, mapa);

// devolver o nodo actual

Retorno de raíz;

}

// constrúe unha árbore binaria a partir de trazos de descenso e preordenadores

// Esta función asume S que a entrada é válida

//, é dicir, dada a secuencia de comprensión e preorden a formar unha árbore binaria

nodo * constrúe (vector < int > const & Inorder, vector < int > const &)

{

// obtén o número de nodos na árbore

int n = Inorder.size ();

// Crear un mapa para atopar de forma eficiente o índice de calquera elemento en

// Dada a secuencia de indicación

Unordered_map < int, int > mapa;

para (int i = 0; i < n; i ++)

mapa] = i;

// Pindex Stores Índice do próximo nodo non procesado na secuencia preordenada

// Comezar con nodo raíz (presente a 0 ‘th Índice)

int Pinderx = 0;

Construír de retorno (Inorder, 0, N – 1, preorden, Pinderx, mapa);

}

// función principal

int principal ()

{

/ * Considere a continuación a árbore

2 3

Deixa unha resposta

O teu enderezo electrónico non se publicará Os campos obrigatorios están marcados con *