UNIVERSIDAD AUTÓNOMA “GABRIEL RENÉ MORENO”

FACULTAD DE INGENIERÍA Y CIENCIAS DE

LA COMPUTACIÓN Y TELECOMUNICACIONES
ESTRUCTURAS DE DATOS 2

CONTENIDO:
Tema 2
TAREA-2. ELIMINAR ELEMENTOS DE UN ÁRBOL
TERMINADO:80 %
GRUPO: 13

Alumno DT HG HI Eval.
Fernandez Bascope Marco 3 0 6 80%
Comentario:
Entiendo lo básico sobre lo que es eliminación, la eliminación
por niveles lo dejo pendiente para los próximos días, hacer más
práctica hasta antes del parcial para poder realizar el parcial
sin complicaciones.
Fecha de Presentación: Martes, 06 de junio de 2023
Fecha Presentada: Martes, 06 de junio de 2023
Días de Retraso: 0
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package arbolbb;

import java.util.LinkedList;

/**
*
* @author personal
*/
public class ArbolBB {

public Nodo raiz;

public ArbolBB(){
this.raiz=null;
}
public void insertar(int x){
raiz=insertar(raiz, x);
}
public Nodo insertar(Nodo p, int x){
if(p==null)return new Nodo(x);
if(x<p.elem)
p.izq=insertar(p.izq, x);
else
p.der=insertar(p.der, x);
return p;
}

//------------------------------------------------------------------------------

public int inmediatoSup(Nodo p){

if(p.izq==null)return p.elem;
else return inmediatoSup(p.izq);
}

public Nodo eliminarNodo(Nodo p){

if(p.izq==null && p.der==null)return null;
if(p.izq!=null && p.der==null)return p.izq;
if(p.izq==null && p.der!=null)return p.der;
int y=inmediatoSup(p.der);
p.elem=y;
p.der=eliminar(p.der, y);
return p;
 }

public void eliminar(int x){

raiz=eliminar(raiz, x);
}
public Nodo eliminar(Nodo p, int x){
if(p==null)return null;
if(x==p.elem)return eliminarNodo(p);
if(x<p.elem)
p.izq=eliminar(p.izq, x);
else
p.der=eliminar(p.der, x);
return p;
}
//A1.eliminarHojas() : Método que elimina los nodos hoja de árbol A1.

public void eliminarHojas(){

eliminarHojas(raiz);
}
public void eliminarHojas(Nodo p) {
if (p.izq == null && p.der == null)
eliminar(p.elem);//No hay nodos, es una hoja
else if (p.izq != null && p.der != null){
eliminarHojas(p.izq);
eliminarHojas(p.der);
}
else if (p.izq != null && p.der == null)
eliminarHojas(p.izq);
else
eliminarHojas(p.der);
}
//A1.eliminarPares() : Método que elimina los elementos pares del árbol A1.
public void eliminarPares(){
eliminarPares(raiz);
}
public void eliminarPares(Nodo p){
if(p==null){
return ;
}
if((p.elem%2)==0){
eliminar(p.elem);
}
eliminarPares(p.der);
eliminarPares(p.izq);

}
//A1.eliminar(L1) : Método que elimina los elementos de la lista L1
//que se encuentran en el árbol A1.
 public void eliminar(LinkedList L1){
eliminar(raiz, L1);
}
public void eliminar(Nodo p, LinkedList L1){
if(p==null)
return ;
eliminar(p.izq, L1);
if(L1.contains(p.elem))
eliminar(p.elem);
eliminar(p.der, L1);
}
//A1.eliminarMenor(): Método que elimina el elemento menor del árbol A1.
public void eliminarMenor(){
if(raiz!=null){
Nodo p=raiz;
while(p.izq!=null){
p=p.izq;
}
eliminar(p.elem);
}
}
//A1.eliminarMayor(): Método que elimina el elemento mayor del árbol A1.
public void eliminarMayor(){
if(raiz!=null){
Nodo p=raiz;
while (p.der!=null) {
p=p.der;
}
eliminar(p.elem);
}
}
//A1.eliminarNivel( n ) : Método que elimina los nodos del árbol A1 del nivel n.
public void eliminarNivel(int n){
eliminarNivel(raiz, n);
}
public void eliminarNivel(Nodo p, int recorrido){
LinkedList<Nodo> cola = new LinkedList<Nodo>();
cola.addLast(p);
while(cola.size()> 0){
Nodo tmp = cola.pollFirst();
if(tmp.izq!=null){
eliminar(p.elem);
}
if(tmp.der!=null){
eliminar(p.elem); }
}
}
//A1.eliminarRaices() : Método que elimina los nodos raíces del árbol A1.
//Completar a 15 ejercicios interesantes. En lo posible citar fuente.

//------------------------------------------------------------------------------
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
ArbolBB A1=new ArbolBB();

A1.insertar(50);
A1.insertar(70);
A1.insertar(10);
A1.insertar(80);
A1.insertar(20);
A1.insertar(60);
A1.insertar(90);
A1.insertar(30);

LinkedList<Integer> L1=new LinkedList();

// L1.add(10);
// L1.add(30);
// L1.add(50);
System.out.println(L1);
// A1.eliminar(L1);
//L1.clear();
A1.niveles(L1);
System.out.println(L1);
//A1.eliminarHojas();
//A1.eliminarPares();
A1.eliminarMenor();
A1.eliminarMayor();
L1.clear();
A1.niveles(L1);
System.out.println(L1);