Diseño del curso de estructura de datos: implementación del árbol de clasificación binaria
#includelt; iostream.hgt;
typedef struct TreeNode
{
int key;
struct TreeNode *izquierda;
struct TreeNode *derecha;
}treeNode;
clase BiSortTree
{
public：
BiSortTree(void);
void desplayTree(void); //muestra este árbol
void insertTree(int key); //inserta un valor en el árbol
deleteTree(int key); //elimina un valor en el árbol
treeNode* searchTree (int key); //busca un valor en el árbol
~BiSortTree();
privado:
treeNode* buildTree(treeNode* head, int number); //construir un árbol
treeNode* search(treeNode* head, int key); //buscar
treeNode* BiSortTree:: searchParent(treeNode* head); , treeNode* p); //busca el puntero al nodo padre de p
treeNode* BiSortTree:: searchMinRight(treeNode* head); //busca el nodo más pequeño en el subárbol derecho
void showTree(treeNode* head); //mostrar
void destroyTree(treeNode* head); //eliminar
treeNode *Head;
} ;
p>/*************** El siguiente es el proceso de construcción de un árbol de clasificación binario************** **/
BiSortTree::BiSortTree()
{
coutlt;lt; "Para construir un árbol de clasificación binario, ingrese todos los números que desee construya el árbol de clasificación (¡con -1 como bandera final! : "lt; lt; endl;
Head=NULL;
int número;
cingt; gt; número;
mientras (¡número!=-1)
{
Cabeza=buildTree( Cabeza, número
cingt;
}
treeNode* BiSortTree::buildTree(treeNode* cabeza, int
número)
{
{
treeNode *p
p=nuevo treeNode;
p- gt; clave=número;
p-gt; izquierda = p-gt=NULL;
if(head==NULL)
{
return p;
}
else
{
if(p-gt; key lt; head -gt;clave)
head-gt;left=buildTree(head-gt;izquierda, número);
else
head-gt;right= buildTree(head-gt; derecha, número);
return cabeza
}
}
/***** ************ A continuación, inserte un número en el árbol de clasificación binaria****************************** ****** ******/
void BiSortTree::insertTree(int key)
{
Head=buildTree(Head, key);
}
/****************** Lo siguiente es encontrar si un número existe en una clasificación binaria árbol************ ****************/
treeNode* BiSortTree::searchTree(int key)
{
return search(Cabeza, clave);
}
treeNode* BiSortTree::search(treeNode* head, int key)
{
if(head ==NULL)
return NULL;
if(head-gt;key==key)
regresar cabeza;
else
{
if(keylt; head-gt; key)
regresar búsqueda( cabeza - gt; izquierda, tecla);
else
volver a buscar( head-gt; derecha, tecla);
}
}
/***** ******* Lo siguiente eliminará el valor dado del árbol ordenado binario ********* ********* ************ ***/
BiSortTree::deleteTree(int key)
{
treeNode *p;
p=NULL;
p=búsqueda(Cabeza, clave);
if(p==NULL)
{
coutlt;lt; "No encuentro la clave";
}
if(p==Cabeza)
{
Head=NULL;
p>}
else
{
treeNode* padre;
padre=mar
rchParent(Head, p);
if(p-gt;left===NULLamp;amp;p-gt;right==NULL)//nodo hoja
{
if(parent-gt; left==p)
{
parent-gt; left=NULL;
}
else
{
parent-gt;right=NULL;
}
}
else/nodo no hoja
{
if(p-gt;right==NULL)//este nodo no tiene ningún hijo derecho
{
if(padre-gt; izquierda==p)
{
padre-gt; izquierda=p-gt;
p> }
else
{
parent-gt; derecha=p-gt;
}
else//hay hijos izquierdo y derecho en este punto
{
treeNode * rightMinSon, * secondParent // secondParent es el padre del nodo más pequeño a la derecha; Nodo del subárbol
rightMinSon=searchMinRight(p-gt;right);
secondParent=searchParent(p-gt;right,rightMinSon);
secondParent-gt ; left=rightMinSongt;right;
if(p-gt;right==rightMinSon)//El padre del nodo más pequeño en el subárbol derecho es p
{
p-gt; derecha=rightMinSon-gt;
}
clave=rightMinSon-gt; }
p>}
}
}
treeNode* BiSortTree::searchParent(treeNode* head, treeNode* p)
{
if(head-gt; left==p||head -gt; right==p||head==p||head==NULL)
volver cabeza;
else
{
if(p-gt; keylt; head-gt; clave)
Return searchParent(head -gt; left, p);
else
return searchParent(head-gt; right, p);
}
}
treeNode* BiSortTree：.searchMinRight(treeNode* head)//encuentra el nodo más pequeño en el subárbol derecho
{
if (cabeza
-gt; izquierda ==NULL||head==NULL)
{
regresar cabeza;
}
else
{
return searchMinRight(head-gt;left);
}
}
/*** ******************* El árbol de clasificación binaria se muestra a continuación************************ *** ********** **********/
void BiSortTree::displayTree(void)
{
showTree(Cabeza);
coutlt;lt;endl;
}
void BiSortTree::showTree(treeNode* Cabeza)
{
if (Cabeza!=NULL)
{
showTree(Cabeza-gt; izquierda);
coutlt;lt ;.Head-gt;keylt;lt; ' ' ;
showTree(Head-gt; derecha ) ;
}
}
/******* ********** Lo siguiente eliminará el árbol de clasificación binaria de enteros ********************* ********* ******/
BiSortTree::~BiSortTree()
{
coutlt;lt; ¡¡¡He eliminado un árbol!!!" lt ;lt; endl;
destroyTree(Head);
}
void BiSortTree: :destroyTree(treeNode* head )
{
if(head!=NULL)
{
destroyTree(head-gt; left);
destroyTree(head-gt ;right );
Eliminar encabezado;
}
}
/*** ********* ***** ****/
void print()
{
coutlt;lt;endllt ;lt;lt;endllt;lt; "Las siguientes son las operaciones básicas en árboles ordenados binarios:"lt;lt;endl
lt; "1. Mostrar el árbol"lt;lt;lt ;endl
lt; "2. Insertar nodo"lt; endl
lt; "3. Buscar nodo"lt;endl
lt;lt; "4. Eliminar nodo "lt;lt;endl;
}
void main()
{
árbol BiSortTree;
int número;
int número de elección;
indicador de caracteres
mientras(1)
{
print();
coutlt;lt; "Seleccione la operación que desea realizar (1~4)"lt;lt;endl;
cingt; gt; número de elección
switch(número de elección)
{
caso 1:
árbol.desplayTree() ;break;
caso 2:
coutlt;lt; "Por favor inserte un número:"lt;lt;endl;
cingt;gt;number;
tree.insertTree(número);
tree.desplayTree();
ruptura
caso 3:
coutlt;lt; "Inserta el número que estás buscando:"lt;lt;endl;
cingt;gt; número
if(tree.searchTree( número)==NULL)
{
coutlt;lt; "No encontrado" lt;lt;endl;
}
else
{
coutlt;lt; "Encontrado"lt;lt;endl;
}
break;
caso 4:
coutlt;lt; "Ingrese el número que desea eliminar: "lt;lt;endl;
cingt;gt; >
tree.deleteTree(número);
tree.desplayTree();
romper
Valor predeterminado: romper
}
coutlt;lt; "¿Quieres continuar (Y/N)?" lt;lt;endl;
cingt;gt;flag;
if(flag=='N'||flag=='n')
descanso;
}
}