Crear un árbol binario, orden de niveles, preorden, en orden, recorrido posterior al orden (requerido mediante métodos recursivos o no recursivos) y subprocesamiento en orden
#include "stdio.h"
#include "string.h"
#include "stdlib.h"
# define Max 20 //El número máximo de nodos typedef struct node{
char data;
struct node *lchild, *rchild;
}BinTNode; /Personaliza el tipo de nodo del árbol binario typedef BinTNode *BinTree; //Define el puntero del árbol binario int NodeNum, leaf //NodeNum es el número de nodos, leaf es el número de hojas
//===== =====Crear un árbol binario basado en el algoritmo transversal de preorden==============
//===== =Requiere la entrada de una secuencia de pedido anticipado, con nudos virtuales agregados. Haga clic en "#" para mostrar la posición del puntero nulo ==========
BinTree CreatBinTree(void)
{
BinTree T;
char ch;
if((ch=getchar())=='#')
return(NULL); //Leer #, Devolver puntero nulo
else{
T=(BinTNode *)malloc(sizeof(BinTNode)); Generar nodo
T-gt; data =ch;
T-gt; lchild=CreatBinTree(); //Construir el subárbol izquierdo
T-gt ; rchild=CreatBinTree(); //Construye el subárbol derecho
return(T);
}
}
// ========Recorrido de pedido anticipado de NLR== ===========
pedido anticipado anulado (BinTree T)
{
if(T) {
printf("c", T-gt; data); //Nodo de acceso
Preorder(T-gt; lchild); /Preorder atraviesa el subárbol izquierdo
Preorder(T-gt;rchild); //Preorder atraviesa el subárbol derecho
}
}
//======== Recorrido en orden de LNR ===============
void Inorder(BinTree T)
{
if(T ) {
Inorder(T-gt; lchild); // En orden recorre el subárbol izquierdo
printf(" c", T-gt; data); //Accede al resultado Point
Inorder(T-gt;rchild); //Atraviesa en orden el subárbol derecho
}
}
// ==========Recorrido posterior al pedido LRN========
====
void Postorder(BinTree T)
{
if(T) {
Postorder(T-gt; lchild); //Postorder recorre el subárbol izquierdo
Postorder(T-gt; rchild); //Postorder recorre el subárbol derecho
printf("c", T- gt; data); //Nodos de acceso
}
}
//====== Utilice el recorrido posterior al pedido para encontrar la profundidad y el nodo de el algoritmo recursivo del árbol binario para el número de puntos y hojas ========
int TreeDepth(BinTree T)
{
int hl, hr, max;
if(T){
hl=TreeDepth(T-gt; lchild); //Encontrar la profundidad izquierda
hr=TreeDepth); (T-gt; rchild); //Encontrar la profundidad correcta
max=hlgt; hl: hl: //Obtener el valor máximo de la profundidad izquierda y derecha
NodeNum=NodeNum 1; // Encuentra el número de nodos
if(hl==0amp;amp;hr==0) leaf=leaf 1 // Si la profundidad izquierda y derecha es 0; es una hoja.
retorno(máximo 1);
}
más retorno(0); /====Utilice la cola "primero en entrar, primero en salir" (FIFO) para recorrer el árbol binario por nivel==========
void Levelorder(BinTree T)
{
int front=0, rear=1;
BinTNode *cq[Max], *p //define la matriz de punteros cq del nodo
cq[1]=T; //En cola raíz
while(front!=rear)
{
front=(front 1)NodeNum;
p=cq[front]; //quitar de la cola
printf("c", p-gt; data); //quitar de la cola, genera el valor de nodo
if(p-gt;lchild!=NULL){
rear=(trasero 1)NodeNum;
cq[trasero]=p-gt ;lchild; / /Subárbol izquierdo en cola
}
if(p-gt; rchild!=NULL){
rear=(rear 1)NodeNum;
p>cq[rear]=p-gt;rchild; //Pon en cola el subárbol derecho
}
}
}
//==========Función principal=================
void main()
{
raíz de BinTree;
int i, profundidad
printf("\n"); > printf( "Creat Bin_Tree; Ingrese el pedido previo:"); //Ingrese la secuencia del pedido previo del árbol binario completo,
//Use # para representar nodos virtuales, como ABD###CE## F##
root=CreatBinTree(); //Crea un árbol binario y devuelve el nodo raíz
//do { //Selecciona el método transversal del menú e ingresa la secuencia número.
printf("\t********** seleccione ***********\n");
printf(" \t1: Recorrido de pedidos anticipados\n");
printf("\t2: Recorrido de pedidos previos\n");
printf("\t3: Recorrido de pedidos posteriores\n");
printf("\t4: PostTreeDepth, número de nodo, número de hoja\n");
printf("\t5: profundidad de nivel\n"); Antes, primero seleccione 4 para encontrar el número de nodos del árbol.
printf("\t0: Salir\n");
printf("\t******************* *** ************\n");
do { //Seleccione el método transversal en el menú e ingrese el número de secuencia.
scanf("d", amp; i); //Ingrese el número de menú (0-5)
switch (i){
caso 1: printf("Imprimir Bin_tree Preorder: ");
Preorder(root); //Recorrido de preorder
break
caso 2: printf("Imprimir Bin_Tree; Inorder: ");
Inorder(root); //Recorrido en orden
break;
caso 3: printf("Imprimir Bin_Tree Postorder: ");
Postorder(root); //Recorrido del postorder
break;
caso 4: profundidad=TreeDepth(root); de hojas
printf("BinTree Depth=d BinTree Node number=d", profundidad, NodeNum
printf("BinTree Leaf número=d", hoja
break;
caso 5: printf("LevePrint Bin_Tree: ");
Levelorder(root); //Recorrer por nivel
romper;
predeterminado: salir(1);
}
printf("\n"); !=0);
}