Cómo construir un árbol binario de clasificación con profundidad mínima

#include lt; stdlib.hgt;

#include string.hgt; Código

#define VERDADERO 1

#define VERDADERO 1

#define FALSO 0

#define OK 1

#define ERROR 0

#define INFEASIBLE -1

#define OVERFLOW -2// El estado es el tipo de función y su valor es el código de estado del resultado de la función

typedef int Status;

// ElemType es el tipo de elemento de datos, definido temporalmente como int

typedef int ElemType;

/ /// Clasificación binaria Estructura de almacenamiento del árbol

typedef struct BiTNode { //Estructura de nodo

ElemType data;

struct BiTNode *lchild, *rchild; Punteros izquierdo y derecho

}.

BiTNode, *BiTree;

void InsertBST(BiTree *T.int Key)

{BiTNode *f, *p;

p=(*T) ;

while(p)

{if(p-gt;data==Clave)

{printf("Ya existe una clave en el árbol que no necesita ser insertado\n");

return;

}

f=p;

p=( Keylt;p-gt;data)?p-gt;lchild:p-gt;rchild;

}

p=(BiTNode*)malloc(sizeof(BiTNode));

p-gt; datos=Clave;

p-gt; lchild=p-gt=NULL;

if ((*T)==NULL) ( *T)=p;

else if (Keylt; f-gt; datos) f-gt; lchild=p

else f-gt=p; p> p>

}/*InsertBST*/

//Creando un árbol de clasificación binario

BiTree CreateBST(void)

{BiTree T;

p>

int Key;

T= NULL;

printf("Ingrese una palabra clave (finalice la entrada cuando ingrese 0):\ n");

scanf("d",&Key);

while(Key)

{InsertBST(amp;T,Key);

scanf("d",&Key);

}

return T;

}

/ / Elemento de consulta

BiTree SearchBST (BiTree T, int key) { // Algoritmo 9.5(a)

// Busca recursivamente la clave en el árbol de clasificación binaria en la clasificación binaria árbol al que apunta el puntero raíz T Elemento de datos igual a clave

// Si la búsqueda es exitosa, devuelve el puntero al nodo del elemento de datos; de lo contrario, devuelve nulo

si (clave ==T-gt; datos) return (T ); // La búsqueda finaliza

else if (keylt; T- gt; datos)

return SearchBST(T-gt; lchild , key); // Continuar al subárbol izquierdo

else

return SearchBST(T-gt;rchild, key // Continuar al subárbol derecho

// Consulta el elemento e invierte el puntero

Estado SearchBST(BiTree T, int key, BiTree f, BiTree amp; p) {

// Algoritmo 9.5(b)

// Busca recursivamente elementos de datos cuya clave sea igual a la clave en el árbol de clasificación binario al que apunta el puntero raíz T, <

/p>

// Si la búsqueda es exitosa, el puntero p apunta al nodo del elemento de datos y devuelve VERDADERO,

// De lo contrario, el puntero p apunta al último nodo visitado en la búsqueda ruta y devuelve FALSO,

p>

// El puntero f apunta al nodo padre doble de T, y su valor de llamada inicial es NULL

if (!T) { p = f; return FALSE; }// La búsqueda no tuvo éxito

else if (T-gt; data==key) { p = T; return TRUE }// >

else if (keylt; T-gt; data)

return SearchBST(T-gt;lchild, key, T, p // Continuar buscando en el subárbol izquierdo

else

return SearchBST(T -gt; rchild, key, T, p // Continuar buscando en el subárbol derecho

}. // SearchBST

// Insertar elemento

Estado InsertBST(BiTree amp; T, ElemType e) { // Algoritmo 9.6

// Cuando ordenación binaria Cuándo no hay ningún elemento de datos con una clave igual a e.key en el árbol T,

// inserta e y devuelve VERDADERO, de lo contrario devuelve FALSO

BiTree p, s

if (!SearchBST(T, e, NULL, p)){ // Búsqueda fallida

s = (BiTree)malloc(sizeof(BiTNode));

s -gt; data = e; s-gt; lchild = s-gt; rchild = NULL;

if (!p) T = s; >

else if (elt; p-gt; data) p-gt; lchild = s; // Inserta s como el nodo secundario izquierdo

else p- gt; Insertar s como nodo secundario derecho

return TRUE;

} else return FALSE // Ya existe un nodo con la misma palabra clave en el árbol, por lo que no se insertará. otra vez

}.

//Insertar BST

//Eliminar el nodo p del árbol ordenado binario y volver a unir su subárbol izquierdo o derecho

void DelBSTNode(BiTree *T, int Key)

{ BiTNode *parent=NULL, *p, *q, *child

p=*T

mientras(p)

{if; (p-gt; datos == Clave) break

parent=p

p=(Keylt; p-gt; datos)?p-gt ;lchild:p- gt;rchild;

}

if (!p) {printf("No se encontró el nodo a eliminar/n");}