Maestro, por favor programe
//Incluye la definición de la estructura del árbol binario, la creación del árbol binario, el algoritmo transversal (recursivo y no recursivo),
/*
Autor: /archiver/tid-787995.html
Tiempo:
Contenido: Complete la creación del árbol binario, recorra el orden frontal, medio y posterior de el árbol binario (recursivamente)
Tiempo:
Contenido:
Tiempo:
Contenido: Búsqueda completa estática y dinámica de árboles binarios (no recursivo)
*/
#Contiene " stdlib.h "
#Definir el nodo máximo 20
#Definir ISIZE 8
#Define NSIZE0 7
#define NSIZE1 8
#Define NSIZE2 15
//SHOWCHAR = 1 (mostrar caracteres )SHOWCHAR = 0 (mostrar números)
# Definir SHOWCHAR 1
//Estructura de árbol binario
Estructura BTNode
{
int data;
BTNode * rchild
BTNode * lchild
};
//Binario no recursivo árbol a través de pila
Base estructural
{
BTNode * ptree
ABTStack * link
};
char TreeNodeS[NSIZE0] = {'A ',' B ', ' C ', ' D ', ' E ', ' F ', ' G ' };
char PreNodo[NSIZE0] = {'A', 'B', 'D', 'E', 'C', 'F', 'G' };
char MidNode[NSIZE0] = {'D', 'B', 'E', 'A', 'C', 'G', 'F' };
int treenode n 0[nsize 1][2]= { { 0, 0}, {1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}, {6, 6}, {7, 7 } }; /p>
int treenode n 1[nsize 1][2]= { { 0, 0}, {4, 1}, {2, 2}, {6, 3}, {1, 4}, { 3, 5}, {5, 6}, {7, 7 } };
int treenode 0[nsize 1][2]= { { ' 0 ', 0}, {'D ', 1}, {'B', 2}, {'F', 3}, {'A', 4}, {'C', 5}, {'E', 6}, {'G', 7} };
int treenode 1[nsize 1][2]= {{'0',0},{'A',1},{'B',2},{'C', 3},{'D',4},{'E',5},{ 'F ', 6}, {'G ', 7 } }
int TreeNode2[NSIZE2][2] ] = {{'0', 0}, {'A', 1}, {'B', 2}, {'C', 3}, {'D', 4}, {'E', 5} , {'F ', 6}, {'G ', 7}, {'H ', 8}, {'I ', 9}, {'J ', 10}, {'K ', 11}, { 'L
int insertar nodo[ISIZE]
= {-10, -8, -5, -1, 0, 12, 14, 16};
//char * prestr = "abde CFG";
// char * midder = " DBEACGF ";
/*
Función de creación de árbol binario dcreatbranchtree 1();
Descripción del parámetro:
Int array[]: matriz de campos de datos del nodo del árbol binario
Int i: el número de serie del nodo actual.
Int n: el número de nodos del árbol binario.
Valor de retorno:
dcreatebranctree 1 = el puntero del nodo raíz del nuevo árbol binario.
Observaciones:
Nodo raíz = matriz [(I j)/2];
Nodo hijo izquierdo = [matriz [I], matriz [(I J) ) ) 2-1]]
Nodo secundario derecho = [matriz [(I j)/2 1, matriz [j]]
*/
BTNode * dcreatebranctree 1(char array[], int i, int n)
{
Nodo Bt * p /*Nodo de árbol binario*/
If (i gt=n)
Retorno (NULL);
p =(Nodo Bt *)malloc(tamañode(nodo Bt));
p -> ; datos = matriz[I];
p->; l niño = dcreatebranctree 1(matriz, 2*i 1, n
p->; dcreatebranctree 1 (matriz, 2*i 2, n);
Retorno (p);
}
/*
Binario; función de creación de árbol dcreatebranchtree 2();
Descripción del parámetro:
Int array[]: matriz de campos de datos de nodo de árbol binario
Int i: el número de serie de el nodo actual.
Int n: el número de nodos del árbol binario.
Valor de retorno:
DCreateBranchTree2 = El puntero del nodo raíz del nuevo árbol binario.
Observaciones:
Nodo raíz = matriz [(I j)/2];
Nodo hijo izquierdo = [matriz [I], matriz [(I J) ) ) 2-1]]
Nodo secundario derecho = [matriz [(I j)/2 1, matriz [j]]
*/
Nodo Bt * dcreatebranctree 2(char array[], int i, int j)
{
Nodo Bt * p /*Nodo de árbol binario*/
Retorno (NULL);
p =(Nodo Bt *)malloc(tamañode(nodo Bt));
p- >; datos = matriz[(I j)/2];
p->; l niño = dcreatebranctree 2(matriz, I, (I j)/2-1);
p->; rchild = dcreatebranctree 2(array, (i j)/2 1, j
Return (p); /*
Función de creación de árbol binario dcreatebranchtree 3():
Se conocen las cadenas de secuencia transversal de preorden y orden del árbol binario y se construye el árbol binario correspondiente. .
ltProgramming Idea>:
Primero, el primer elemento en la secuencia transversal de preorden es el nodo raíz del árbol binario, y luego
, en la secuencia secuencia transversal Si este nodo se encuentra en, entonces el nodo anterior a este nodo debe ser
Su nodo secundario izquierdo debe ser su nodo secundario derecho en el futuro;
Luego, en el intermedio secuencia transversal secuencial, el subárbol izquierdo y el subárbol derecho del nodo raíz son respectivamente
El nodo raíz del subárbol está determinado por el primer carácter de la secuencia transversal correspondiente al antecedente del subárbol, y luego el nodo raíz está determinado por el orden intermedio
La posición del nodo raíz en la secuencia transversal determina su subárbol izquierdo y subárbol derecho respectivamente.
Los nodos;
Por analogía, determine todos los nodos del árbol binario y construya el árbol binario.
Descripción del parámetro:
Char *pre: secuencia transversal de preorden
Char *mid: secuencia transversal de orden medio
Int n: El número de nodos en la secuencia transversal.
Valor de retorno:
DCreateBranchTree3 = El puntero del nodo raíz del nuevo árbol binario.
*/
BTNode * dcreatebranctree 3(char * pre, char *mid, int n)
{
Nodo Bt * p;
char * t;
int left
Si (n lt=0)
Return (NULL); p>
p =(nodo Bt *)malloc(sizeof(nodo Bt));
p->; datos = * pre
for(t = mid ; t ltmid n; t )
if(* t = = * pre)break;/*Encontrar el nodo raíz en la secuencia transversal de orden medio*/
Izquierda = t- mid;/ *El número de nodos en el subárbol izquierdo*/
p->; l child = dcreatebranctree 3(pre 1, t, left); rchild = dcreatebranctree 3 (pre 1 izquierda, t 1, n-1-izquierda
Retorno (p>
}
/*
Función de creación de árbol binario createbranchtree():
Descripción del parámetro:
Int array[]: matriz de campos de datos de nodo de árbol binario
Int n : el número de nodos del árbol binario.
Valor de retorno:
CreateBranchTree = el puntero del nodo raíz del nuevo árbol binario.
*/
Nodo Bt * crear árbol de ramas(int array[][2], int n)
{
BTNode *head, *p;
Bt node *node addr[MAXNODE]; //Búfer temporal de dirección de nodo
int i, norder, rorder
head = NULL
Printf("Datos originales del árbol binario: \t ");
for(I = 1; i lt= n; i)
{
p =(nodo Bt *)malloc(tamañode(nodo Bt));
if(p==NULL)
{
printf("\n¡Desbordamiento de memoria al crear un nuevo nodo!\n ");
Retorno (NULL);
}
Otros
{
p->; datos = matriz[I][0];
p->; l niño = p- rchild = NULL
norder = matriz[I][1];
dirección de nodo[norder]= p;
if(norder gt; 1)
{
ror der = norder/2; /*Nodo no raíz: vinculado a su propio nodo padre*/
if(norder 2 == 0)
dirección de nodo[ror der]- gt;l child = p;
Otro
dirección de nodo[ror der]- gt;rchild = p;
}
Otros
head = p; /*Nodo raíz*/
if(SHOWCHAR)
printf("c ", p - gt; datos);
Otro
printf("d ", p- gt; datos);
}
}
Return (head);
}
// - Parte recursiva.
/*
Función transversal de pedido anticipado de árbol binario dpre _ order _ access();
Descripción del parámetro:
BTNode * head: puntero al nodo raíz del árbol binario.
*/
void dpre _ Order _ Access(Bt node * head)
{
if (head!=null)
{
if(SHOWCHAR)
printf("c", head- gt; data
Otros
printf("d ",head- gt; data);
dpre _ Order _ Access(head- gt; l child /* Recorre recursivamente el subárbol izquierdo*/
dpre _ Order _ Access(head- gt; rchild);/*Atraviesa recursivamente el subárbol de la derecha*/
}
}
/*
Función transversal ordenada dmid _ order _ access() en un árbol binario
Descripción del parámetro:
BTNode *head: el nodo raíz de el puntero del árbol binario.
*/
void dmid _ Order _ Access(Bt node * head)
{
if (head!=null)
{
dmid _ Order _ Access(head- gt; l child);/*Atraviesa recursivamente el subárbol izquierdo*/
if(SHOWCHAR)
printf("c",head-gt;data);
Otros
printf("d",head-gt;data);
Otros
printf("d",head-gt;data);
p>
dmid _ Order _ Access(head- gt; rchild); /*Atraviesa recursivamente el subárbol de la derecha*/
}
}
/*
Función transversal de postorden del árbol binario dlast_order_access();
Descripción del parámetro:
BTNode *head: el puntero del nodo raíz del árbol binario.
*/
void dlast _ Order _ Access(Bt node * head)
{
if (head!=null)
{
dlast _ Order _ Access(head- gt; l child); /* Recorre recursivamente el subárbol izquierdo*/
dlast _ Order _ Access (head- gt; rchild); /* Recorre recursivamente el subárbol de la derecha*/
if(SHOWCHAR)
printf("c ", head- gt; data);
Otro
printf("d",head- gt; data);
}
}
// - parte recursiva.
// - Parte no recursiva.
/*
Función transversal de pedido anticipado de árbol binario pre_order_access():
Descripción del parámetro:
BTNode *head: Puntero a el nodo raíz del árbol binario.
*/
Anular pre_pedido_acceso(Bt nodo * cabeza)
{
BTNodo * pt
ABTStack *ps, *top
pt = head;
top = NULL
printf("\nReordenar los resultados del recorrido del árbol binario:\ t " );
Y (pt!=NULL ||top!=NULL) /*El árbol binario no ha sido recorrido por completo o la pila no está vacía*/
{
Y (pt!=null)
{
if(SHOWCHAR)
printf("c ", pt- gt; datos ); /*Acceder al nodo raíz*/
Otros
printf("d", pt- gt; data /*Acceder al nodo raíz*/
);PS =(abt stack *)malloc(sizeof(abt stack));/*Nodo raíz en la pila*/
PS- gt; - gt; link = top
top = ps
pt = pt- lchild/*Atraviesa el subárbol derecho del nodo y los nodos pasados se apilan en secuencia*/
}
If (top!=null)
{
pt = top- ptree/*El nodo en el la parte superior de la pila sale de la pila*/
ps = top
top = top- gt
Gratis /*Nodo libre; espacio en la parte superior de la pila*/
pt = pt- gt;*Atraviesa el subárbol derecho del nodo*/
}
}
}
/*
Acceso a pedidos a medio plazo ():
Descripción del parámetro:
BTNode *head: el puntero del nodo raíz del árbol binario.
*/
void mid _ Order _ Access(Bt node * head)
{
BTNode * pt
ABTStack *ps, *top
int contador = 1;
pt = encabezado
top = NULL
printf; ("\nResultado del recorrido en orden del árbol binario:\t");
And (pt!=NULL ||top!=NULL) /*El árbol binario no se ha recorrido por completo o la pila está no vacío* /
{
Y (pt!=null)
{
PS =(abt stack *)malloc( sizeof(abt stack));/*Nodo raíz en la pila*/
PS- gt; ptree = pt
PS- gt = top
pt = pt- gt; lchild/*Atraviesa el subárbol derecho del nodo y los nodos pasados se apilan en secuencia*/
}
If (top! = vacío)
{
pt = top- gt; ptree/*El nodo en la parte superior de la pila sale de la pila*/
ps = top
top = top- gt;
Gratis /*Espacio de nodo libre en la parte superior de la pila*/
if(SHOWCHAR)
printf("c ", pt- gt; data /*Acceder al nodo raíz*/
Otros
pt = pt- gt/*Atraviesa el subárbol derecho del nodo*/
}
}
}
/*
Acceso al último pedido():
Descripción del parámetro:
BTNode *head: la raíz del puntero de nodo del árbol binario.
*/
Anular último _ pedido _ Acceso (nodo Bt * cabeza)
{
BTNodo * pt
ABTStack *ps, *top
int contador = 1;
pt = encabezado
top = NULL
printf; ("\nResultado del recorrido en orden inverso del árbol binario:\t");
And (pt!=NULL ||top!=NULL) /*El árbol binario no se ha recorrido por completo, o la pila no está vacío*/
{
Y (pt!=null)
{
PS =(abt stack *)malloc (sizeof(abt stack )); /*Nodo raíz en la pila*/
PS- gt; ptree = pt
PS- gt; p>top = ps
pt = pt- gt; lchild/*Atraviesa el subárbol derecho del nodo y los nodos pasados se apilan en secuencia*/
}
If (top! = Vacío)
{
pt = top- gt; ptree/*El nodo en la parte superior de la pila sale de la pila*/
ps = top
top = top- gt;
Gratis (PS) /*Espacio de nodo libre en la parte superior de la pila*/
printf("c ", pt- gt; data);/*Acceder al nodo raíz*/
pt = pt- gt;rchild/*Atravesar el subárbol derecho del nodo* /
}
}
}
/*
Función de búsqueda estática del árbol de búsqueda binaria static_search_Stree() :
Descripción del parámetro:
BTNode *head: el puntero del nodo raíz del árbol de búsqueda binario.
Clave int: clave de búsqueda
Valor de retorno:
Static_Search_STree = Puntero de nodo con valor clave (encontrado)
Static_Search_STree = NULL( no encontrado)
*/
Nodo Bt * estático _ Buscar _ STree(nodo Bt * cabeza, tecla int)
{
mientras (head!=null)
{
if (head- gt; data == clave)
{
printf (" \ n campo de datos = d \ t dirección = d \ t \ n ", encabezado- gt; datos, encabezado
Return (head) /*find*/<); p>}
if(head- gt; data gt key)
head = head- gt; lchild/*continuar buscando en el subárbol izquierdo*/
Otros
head = head- gt;rchild/*Continuar buscando en el subárbol derecho*/
}
Return (NULL );/*No encontrado */
}
/*
Función de búsqueda dinámica del árbol de búsqueda binariodynamic_search_stree():
p>Descripción del parámetro:
BTNode *head: el puntero del nodo raíz del árbol de búsqueda binario.
BTNode **parent: Puntero al nodo padre del nodo con el valor clave.
BTNode **head: Puntero al puntero de nodo cuyo valor clave es (encontrado) o NULL (no encontrado).
Clave int: clave de búsqueda
Nota:
*parent == NULL y *p == NULL no encontrado (el árbol binario está vacío)
*parent == NULL y *p! =NULL encontrado (nodo raíz encontrado)
*¡Padre! = NULL y *p == NULL (nodo hoja) > no encontrado.
*¡Padres! = NULO y *p! =Nulo encontrado (nodo intermedio)
*/
voiddynamic _ Search _ STree(Bt node * head, BTNode **parent, BTNode **p, int key)
{
* padre = NULL
*p =cabeza;
mientras(*p!=null)
{
if((* p)- gt; datos == clave)
return; /*buscar*/
* padre = * p; /*Continuar buscando con el nodo actual como nodo padre*/
if ((* p)- gt; data gt key)
* p = (* p)- gt;lchild/*Continuar buscando en el subárbol izquierdo*/
Otros
* p =(* p)- gt;rchild/*Continuar buscando en el subárbol derecho */
}
}
/*
Función de nodo de inserción del árbol de búsqueda binaria insert_node_stree():
Descripción del parámetro :
BTNode *head: el puntero del nodo raíz del árbol de búsqueda binario.
Clave int: clave de búsqueda
Valor de retorno:
Insert_Node_STree = 1 insertado correctamente.
Insert_Node_STree = 0 Error al insertar (el nodo ya existe).
*/
int Insertar _ Nodo _ STree(Bt Node * head, int key)
{
BTNode *p, *q, *nnode
Búsqueda dinámica.
p amp; q, key);
If (q!=null)
return(0); /*El nodo ya existe en el árbol*/
n nodo =(nodo Bt *)malloc(sizeof(nodo Bt));/*Crear nuevo nodo*/
nnodo->;data=key;
nnodo- > ;l child = n nodo- gt;rchild = NULL
if(p==NULL)
head = p;/*El árbol original está vacío, el nuevo nodo está un árbol de búsqueda */
Otro
{
if (p->; clave gt de datos)
p->; = nnode/ *Como nodo secundario izquierdo*/
Otro
p->; rchild = nnode/*Como nodo secundario derecho*/
}
Return (1); /*Inserción exitosa*/
}
/*
El árbol de búsqueda binaria inserta un lote de nodos función insert_batch_ node_stree():
Descripción del parámetro:
BTNode *head: el puntero del nodo raíz del árbol de búsqueda binario.
Int array[]: matriz de campos de datos insertados.
Int n: El número de nodos que se insertarán.
*/
void Insert _ Batch _ Node _ STree(Bt Node * head, int array[], int n)
{
int I;
for(I = 0; iltn;i)
{
if (!Insert_Node_STree(head, array[i] )
printf("\n¡Error de inserción!\n ",array[I]);
}
}
/ / - Parte no recursiva.
//Implementar la conversión entre árbol y árbol binario
estructura typedef BinaryTreeNode{
estructura binaria treenode * left child;
struct binario treenode * hijo derecho;
int valor;
};
estructura typedef TreeNode{
struct TreeNode * child[];
int child _ count
int valor
};
Nodo de árbol binario * árbol binario (Nodo de árbol * raíz){
if(root == null)
Devuelve null
BinaryTreeNode * raíz binaria = new BinaryTreeNode();
raíz binaria- gt; valor = raíz- gt; valor;
raíz binaria- gt; hijo izquierdo = árbol binario (raíz- gt; hijo[0]); gt; leftChild
for(int I = 1; iltroot- gt; children_count; i){
brother- gt; right child = tobinary tree(root- gt; child[I] ]);
Hermano = hermano - gt; hijo correcto;
}
Devuelve raíz binaria
}