Suponiendo que el árbol binario está almacenado en modo de conexión, escriba un programa recursivo y no recursivo para realizar un recorrido de preorden del árbol binario.
#Incluye "iostream.h"
#Incluye "string.h"
#Incluye "malloc.h"
# Contiene "stdio.h"
estructura typedef btree
{
int data //Rango de nodos del árbol
int ltag; rtag//Las pistas izquierda y derecha del nodo del árbol
struct btree *left, * right//Los punteros izquierdo y derecho del nodo del árbol, ltag, rtag=1 apuntan al predecesor y al sucesor, de lo contrario, apunta a los nodos secundarios izquierdo y derecho.
}Nodo;
Nodo*Buscar nodo (nodo*q, nodo*r)
{//Pista en orden con dirección de nodo raíz q Buscar el nodo en el árbol binario donde se insertará el nodo R.
nodo * p;
p = q;
mientras(1)
{
mientras( r - gt data ltp -> datos e información ampp -> ltag ! = 1) { p = p -> izquierda } // Continuar mirando hacia la izquierda.
while(r- gt; data gtp->; data and information. ampp->; rtag! = 1) { p = p->;
if(r- gt; datos ltp-> datos e información. ampp->; ltag == 1 | | r- gt; datos gtp->; datos e información. ampp->; rtag = = 1 | datos gtp -> datos y p no están compuestos de hijos
//o r- gt; datos == p- gt; datos, el nodo P lo encuentra y sale del bucle.
}
Return (p); //Devuelve p nodo
}
nodo *InsertNode(nodo *rot, node * s)
{//Inserte el nodo S en el árbol binario de pistas en orden con la dirección del nodo raíz rot.
node * p;
if(rot==NULL)
{//Si el nodo raíz está vacío, inserte el nodo S como nodo raíz .
rot = s;
rot->; datos = s-gt;
rot->; p>rot->; izquierda = NULL
rot->; rtag = 1;
rot->; ;
}
p=SearchNode(rot, s); // Llame a la función SearchNode para encontrar la ubicación del nodo P que será insertado por S.
if(s- gt; data == p- gt; data)
{//Si el nodo ya existe en el árbol, libere el nodo y regrese.
Gratis;
Devolución (rot);
}
if(s- gt; data ltp->; data)
{//Si s- gt; data ltp->; los datos se insertan como el hijo izquierdo de P. En este momento, el predecesor de S es el predecesor de P antes de la inserción y el sucesor de S. es p.
s-gt; ltag = 1;
s-gt; izquierda = p-gt;
s-gt; /p>
s-gt; derecha = p;
p->; ltag = 0;
p->; >}
if(s- gt; data gtp->; data)
{//If s- gt; data gtp->; P, en este momento, el sucesor de S es el sucesor antes de que se insertara P, y el predecesor de S es P.
s-gt; rtag = 1;
s-gt; derecha = p-gt;
s-gt; /p>
s-gt; izquierda = p;
p->; rtag = 0;
p->; >}
Regresar (podredumbre);
}
Nodo*Crear árbol (nodo*rt)
{//Iniciar construcción Un árbol ordenado binario con un nodo raíz vacío devuelve la dirección del nodo raíz.
int m; //Se utiliza para ingresar el rango de valores del nodo raíz.
Nodo * q;
while(1)
{
printf("Ingrese un número: \ nm = ") ;
//scanf("d", ampm);
CIN gtm; //Ingrese el valor del nodo.
if(m==-1) devuelve (rt);
Nodo * s; //Crea un nuevo nodo para insertar.
s =(node *)malloc(sizeof(node)); //Crea un espacio de nodo para s.
s- gt; data = m;
q=InsertNode(rt, s); //Llame a la función InsertNode para insertar cada nodo en el árbol binario de pistas en orden generado. , Formar nuevos árboles.
rt = q;
}
Retorno (rt);
}
nodo *Buscar( node *root, int x)
{//Busque el nodo P con el valor de nodo X en el árbol binario de pistas en orden con la dirección del nodo raíz root y devuelva P. Si no es así existe, devuelve NULL.
node * p; //Devuelve la posición del nodo con valor x.
p = raíz;
mientras(1)
{
mientras(x lt; p->; datos e información. ampp->ltag! = 1){ p = p->left;}
while(x gt;p->datos e información. ampp->rtag!= 1){ p = p-> ;right;}
if(x lt;p->;datos e información. ampp->;ltag = = 1 | | x gt;p->;datos e información. ampp -> rtag = = 1 |
Retorno (p);
}
nodo *P_Next(nodo *raíz, int x)
{//Después En el árbol binario de pistas en orden cuya dirección de nodo raíz es la raíz, busque el nodo posterior Q atravesado por el nodo P con valor de nodo X.
Nodo *p, *q; //p es el nodo con valor de nodo X, Q se utiliza para devolver los nodos posteriores que P atraviesa en orden posterior.
p=Search(root,x); //Llama a la función de búsqueda para encontrar la ubicación del nodo p.
If(p==NULL)//El nodo con valor x no existe. ¡error!
{
Devuelve NULL
}
Si (p->; ltag==0) devuelve (p- gt; left ); //Si este nodo tiene un nodo secundario izquierdo, devuelve el nodo secundario izquierdo.
Otros
{
If (p->rtag==0) return (p-gt;right); //Si este nodo no tiene izquierdas; Nodo secundario, si hay un nodo secundario correcto, devuelve el nodo secundario correcto.
De lo contrario //Si el nodo es un nodo hoja,
{
q = p->;right; //Busca el nodo sucesor de este nodo. .
Si (q==NULL)//el nodo sucesor está vacío, entonces el nodo es el último nodo atravesado en la secuencia anterior y se devuelve vacío.
{
printf("Este nodo es el último nodo\n ");
Devuelve NULL
}
Otro
{
while(q->rtag == 1 amp; ampq->right!= NULL){ q = q- gt;right;} // Si no hay ningún hijo adecuado en el sucesor de este nodo, continúe buscando el nodo en la dirección del sucesor.
Si (q->;right==NULL)
{
Devolver NULL
}
De lo contrario return (q-gt; pair); // Devuelve el nodo secundario derecho del nodo.
}
}
}
}
Visualización vacía (nodo *t)
{//Recorrido en orden no recursivo del árbol de clasificación binaria de pistas en orden
Printf("La secuencia intermedia es: ");
while( t->; ltag! = 1){t = t->left;}// Encuentra el nodo más a la izquierda, que es el primer nodo atravesado en el orden medio.
while(t!=null)
{
printf("d", t- gt; data); //Imprimir valor del nodo
while(t->;Rtag==1)//El puntero derecho del nodo apunta al nodo siguiente.
{
t = t- gt; right;
if(t==NULL) regresa; //t está vacío, el recorrido finaliza.
else printf("d ", t- gt; data); //Imprimir valor del nodo
}
if(t->; Rtag== 0)//Si el nodo tiene un nodo secundario correcto,
{
t = t- gt; //Comienza desde el nodo secundario correcto
while(t->ltag!= 1){ t = t->left}//Continúe buscando hacia la izquierda el nodo más a la izquierda de este subárbol.
}
}
}
void main()
{
int w;
Printf("Ingrese una cadena de números enteros positivos para construir un árbol de clasificación binario de pistas en orden y finalmente use -1 como marca final\n "); p>Nodo * raíz;
raíz = NULL
nodo * p;
Nodo * q;
p=CreatTree(raíz );
Display(p);
while(1)
{
cout lt lt"\nEncuentre los nodos posteriores de x que previamente fueron recorridos secuencialmente\ NX = ";
CIN gt; gtw;
q=P_Next(p,w);
if(q = = NULL)cout lt; lt "Este nodo no está en el árbol, ni en el último nodo recorrido en el orden anterior\n";
Otro
{
cout lt lt" \ nLos nodos posteriores de este nodo son: ";
cout lt ltq->;data;
}
}
}