Escriba un programa que utilice recorrido de nivel para encontrar la profundidad de un árbol binario. ¡Gracias!
// Nodo de árbol binario de tipo carácter
#include lt; stdio.hgt
#include stdlib.hgt; p >#include lt; string.hgt;
#define null 0
#define MaxSize 1024
árbol de estructura typedef
{ / *Declarar la estructura del árbol*/
estructura del árbol *left; /* Guarda el puntero al subárbol izquierdo*/
estructura del árbol *right /* Guarda el puntero al otro subárbol Puntero */
char data /* Guardar el contenido del nodo*/
} treenode, * b_tree
b_tree Q[ MaxSize];
b_tree Q[MaxSize];
} p>
/* Crea un árbol binario y recorre jerárquicamente la secuencia a través de la entrada completa del árbol binario*/
b_tree createbtree()
{
char ch;
int delante, detrás
b_tree root; , s;
root=NULL;
frontal= 0
ch=getchar(); ();
mientras(ch!='?')
{
p>
s=NULL
if(ch!='.')
{
s=(b_tree)malloc(sizeof(treenode ));
s-gt; ch;
s-gt; izquierda=NULL;
s-gt; derecha=NULL
s-gt; >
p>
}
trasero
Q[trasero]=s
if(trasero==1)
raíz=s;
else
{
if(samp;amp;Q[front])
si (trasero2== 0)
Q[frontal]-gt; izquierda=s
else
Q[frontal]-gt;
if(trasero2==1)
delantero
}
ch=getchar(); >getchar() ;
}
return root;
}
//* Árbol de clasificación binario de impresión transversal previo a la ordenación* /
void preorder_btree(b_tree root)
{
b_tree p= raíz
if(p! =nulo)
{
printf("3c", p-gt; datos
preorder_btree(p-gt; izquierda
preorder_btree(p-gt; right );
}
}
/* El recorrido intermedio imprime el árbol de clasificación binaria*/
orden vacío_
btree(b_tree raíz)
{
b_tree p=root
if(p!=null){
inorder_btree(p -gt; izquierda );
printf("3c", p-gt; datos
inorder_btree(p-gt; derecha
}
}
//* Árbol de clasificación binaria de impresión post-recorrido*/
void postorder_btree(b_tree root)
{
p>
b_tree p=root
if(p!=null)
{
postorder_btree(p-gt; izquierda
p>
postorder_btree(p-gt; derecha
printf("3c", p-gt; datos
}
//* Encuentra la altura del árbol*/
int tree Depth(b_tree bt)
{
int hl, hr, max
if(bt!=null)
{
hl=profundidad del árbol(bt-gt; izquierda
hr= profundidad del árbol(bt-gt; derecha);
max=( hlgt; hr)?hl:
return (max; 1);
}
else
devuelve 0;
}
int count=0; /p>
//* Buscar nodos hoja Número total*/
int leafcount(b_tree bt)
{
if(bt!=null )
{
recuento de hojas(bt-gt; izquierda);
recuento de hojas(bt-gt; derecha
if(); bt- gt; left==nullamp; amp; bt- gt；right==null)
recuento
}
recuento de retornos; >
}
void paintleaf(b_tree bt)
{
if(bt! =nulo)
{
if(bt-gt; izquierda==nullamp; amp; bt-gt; derecha==null)
printf(" 3c", bt-gt; datos);
paintleaf(bt-gt; izquierda);
paintleaf(bt-gt; derecha);
}
}
}
}
typedef b_tree ElemType;
//*Definir QueueNodeType*/
typedef struct QueueNode
{
Datos ElemType
struct QueueNode *siguiente;
}QueueNode;
//*Definir cola**/
typedef struct linkQueue
{
QueueNode * front;
QueueNode * rear;
} linkQueue;
//* Inicializar cola*/
void initQueue( linkQueue * q)
{
q-gt; front=q-gt; rear =null; //---- nodo sin cabeza
}
//* Determinar si la cola está vacía*/
int QueueEmpty(linkQueue * Q)
{
return (Q-gt; front== null )amp; amp (Q-gt; rear==null);
//* De hecho, solo necesita determinar si el puntero del encabezado de la cola está vacío*/
/* Ingresar operación de cola*/
void EnQueue(linkQueue *Q, ElemType x)
{ /*Insertar elemento x al final de la cola de cadena*/
QueueNode *p=(QueueNode *)malloc(sizeof(QueueNode));/* Solicitar un nuevo nodo*/
p- gt; ; p-gt; next=null ;
if(QueueEmpty(Q))/* Insertar x en la cola vacía*//----Nodo sin cabeza
Q-gt ; front=Q-gt; rear =p;
else
{ /*x Inserta la cola no vacía*/
Q- gt; rear-gt; next=p; / *p está vinculado al nodo de cola original*/
Q-gt; /p>
}
}
//// Operación de eliminación de cola*/
ElemType DeQueue (linkQueue *Q)
{
ElemType x;
QueueNode *p
if(QueueEmpty(Q))
{
printf("Desbordamiento de cola");/* desbordamiento*/
exit(1);
}
p=Q-gt; /* Apunta al par de nodos principales*/
x=p-gt; /* Guarda los datos del par de nodos principales*/
Q-gt; p-gt; next; /* Eliminar este par de encabezados de la cadena Nodo**
Q-gt; front=p-gt; este par de nodos principales de la cadena */
if(Q-gt;rear==p)/*Solo hay un nodo en la cola original Después de la eliminación, la cola queda vacía. tiempo, el puntero del encabezado de la cola ya está vacío*/
Q-gt;rear= NULL
free(p); nodo de cabecera de cola**
return x /*Devuelve el número de cabecera de cola original
Según */
}
void visit(b_tree p)
{
printf("3c", p-gt; datos );
}
ancho vacíoFirst2(b_tree root)
{
b_tree p, tmp
tmp=(treenode *)malloc(sizeof(treenode));
q=(linkQueue *)malloc(sizeof( linkQueue)); >
tmp-gt; datos='?';
initQueue(q);
p=root
if(p!=null; )
{
EnQueue(q, p>
mientras(!QueueEmpty(q))
{
p= DeQueue(q);
visita(p);
if(p-gt; datos!='?')
{
if(p-gt; izquierda!=null)
EnQueue(q, p-gt; izquierda
else
if(p-gt;right!=null)
EnQueue(q, tmp);
if(p); - gt; derecha! = nulo)
EnQueue(q, p-gt; derecha
else
EnQueue(q, tmp); p >
}
EnQueue(q, tmp).
}
}
}
}
{
b_tree p;
linkQueue * q
q=(linkQueue *)malloc(sizeof(linkQueue) )
initQueue(q);
p=raíz
if(p!= nulo)
{
EnQueue(q, p);
mientras(!QueueEmpty(q))
{
p=DeQueue(q); p >
visita(p);
if(p-gt; izquierda!=null)
EnQueue(q, p-gt; izquierda
);if(p-gt; derecha!=null)
EnQueue(q, p-gt; derecha
}
}
}
int main ()
{
char nodelist[MaxSize]
int len, flag;
char cmd;
b_tree raíz;
printf("\n\n---------------- - -----------------------------------\n");
printf
("\n**** ¡Siéntete libre de probar y corregir este programa! Este programa se utiliza para estudiar árboles binarios.
****\n");
printf("\n----------------------------- -----------------------\n\n");
hacer
{
printf("\n\n Seleccione qué operación:\n\n");
printf(" c, C... Cree un árbol de clasificación binario\n")
printf(" a, A... Finalizar este programa\n\n");
flag=0
do
; {
if(flag!=0)
printf("¡Error en la operación de selección! ¡Vuelva a seleccionar! \n"); /p>
scanf("c", y cmd);
bandera
} while(cmd!='c'amp; y cmd!=' C'amp;amp;cmd!='a'amp; amp;cmd!='A');
if(cmd=='c'||cmd== 'C')
{
printf("Ingrese el valor del nodo del árbol binario que desea crear que termine en '?)\n"):\ end):\n"
getchar();
root=createbtree();
hacer
{
root =createbtree(); p>
flag=0;
printf("\n\n Seleccione la operación que desea realizar en este árbol binario:\n\n"); p>
printf(" x, /n");
printf(" h, H... Recorrido posterior al orden de este árbol binario"); (" b, B.... .. Recorrido de nivel de este árbol binario");
printf(" d, D... Encuentra la altura de este árbol binario");
printf(" y, Y ...... Encuentra el número total de hojas de este árbol binario");
printf(" j, J...... Genera la hoja nodos de este árbol binario\n");
printf(" q, Q... Finalizar operación en este árbol binario\n/n");
do
{
if(bandera! =0)
printf("¡Error en la operación de selección! ¡Vuelva a seleccionar! \n");
fflush(stdin);
scanf("c", amplificador; cmd);
p>flag;
} while(cmd!='x'amp;amp;cmd!='x'amp;amp;cmd!='z'amp;cmd!=' h' amp;amp;cmd!='h'amp;amp;cmd!='b'amp;amp;cmd!='b'amp;amp;cmd!='d'amp;amp;cmd!=' d' amp;amp;cmd!
Cambiar(cmd)
{
caso 'x':
caso 'X':
printf("\n Inicio del recorrido de precedencia:\n");
preorder_btree(root);
printf("\n Fin del recorrido de precedencia: \n \n");
descanso;
caso 'z':
caso 'Z':
printf(" \n inicio del recorrido de orden medio:\n");
inorder_btree(root);
printf("\n final del recorrido de orden medio\n\n");
break; <
caso 'h':
caso 'H':
printf("\n inicio del recorrido posterior al pedido:\ n"
postorder_btree(root);
printf("\n fin transversal del pedido posterior\n\n"); p>
caso 'b':
caso 'B':
printf("Comienzo del \n recorrido jerárquico:\n"); >printf("Recorrido (1): no generar hijo vacío \n");
breadthFirst(root);
printf("\n");
printf("Recorrido (2): generando un niño vacío \n");
breadthFirst2(root);
printf("Fin del recorrido en el nivel \n\n ");
descanso;
case 'd':
case 'D':
printf("\nAltura de este árbol binario: \nd\n\n", profundidad del árbol (raíz));
romper;
caso 'y':
caso 'Y':
count=0;
count=leafcount(root);
printf("/nEl número total de hojas en este árbol binario es:/nd\ n", contar);
cuenta=0;
romper; <
/p>
case 'j':
case 'J'.
printf("\n el nodo hoja de este árbol binario es: \n"); /p>
paintleaf(raíz);
printf("\n");
romper
}
}mientras(cmd!='q'amp; amp. cmd!='Q');
}
}
}mientras(cmd!= 'a'amp;amp;cmd!='A');
printf("\n\n--------------------- -------\n\n");
printf("* ***¡Gracias por usarlo! ¡Las correcciones son bienvenidas!****\n\n"); p>
printf("----------------------\n\n"); p> printf("Autor: Resto Número académico: 07082107 Hora: 2008.11.23\n\n");
return
}
/ *( 10
(8 5 3 23 73 15 34 56 32). . Cuando los datos del nodo son 6
6
4
a b c
d*/
Lo anterior es el programa que escribí, espero que te sea útil
/yyy_christine My Baidu Space
p>