Computing">
Nothing Special   »   [go: up one dir, main page]
Scribd Logo
Cargar

¡Te damos la bienvenida a Scribd!

  • 24 vistas

    Arboles

    Cargado por

    Hector Glez
    El documento describe una clase Nodo y una clase ArbolBinario. La clase Nodo representa los nodos de un árbol binario con etiqueta, dato y referencias a hijos e padre. La clase ArbolBinario incluye métodos para crear, buscar, insertar, eliminar y recorrer nodos en un árbol binario.

    Copyright:

    © All Rights Reserved
    Descargue como TXT, PDF, TXT o lea en línea desde Scribd

    Arboles

    Cargado por

    Hector Glez
    24 vistas6 páginas
    El documento describe una clase Nodo y una clase ArbolBinario. La clase Nodo representa los nodos de un árbol binario con etiqueta, dato y referencias a hijos e padre. La clase ArbolBinario incluye métodos para crear, buscar, insertar, eliminar y recorrer nodos en un árbol binario.

    Descripción original:

    Título original

    Arboles.txt

    Derechos de autor

    © © All Rights Reserved

    Formatos disponibles

    TXT, PDF, TXT o lea en línea desde Scribd

    ¿Le pareció útil este documento?

    ¿Este contenido es inapropiado?

    El documento describe una clase Nodo y una clase ArbolBinario. La clase Nodo representa los nodos de un árbol binario con etiqueta, dato y referencias a hijos e padre. La clase ArbolBinario incluye métodos para crear, buscar, insertar, eliminar y recorrer nodos en un árbol binario.

    Copyright:

    © All Rights Reserved
    Descargue como TXT, PDF, TXT o lea en línea desde Scribd
    Descargar como txt, pdf o txt
    24 vistas6 páginas

    Arboles

    Cargado por

    Hector Glez
    El documento describe una clase Nodo y una clase ArbolBinario. La clase Nodo representa los nodos de un árbol binario con etiqueta, dato y referencias a hijos e padre. La clase ArbolBinario incluye métodos para crear, buscar, insertar, eliminar y recorrer nodos en un árbol binario.

    Copyright:

    © All Rights Reserved
    Descargue como TXT, PDF, TXT o lea en línea desde Scribd
    Descargar como txt, pdf o txt
    de 6

    // Todos los metodos funcionan perfectamente

    // De Marcos

    //-----<) Clase 1
    (>---------------------------------------------------------------------------------
    -------------
    package Arbol_Binario;

    public class Nodo<T> {

    private String etiqueta;

    private T dato;
    private Nodo padre;

    private Nodo hijoIzq;


    private Nodo hijoDer;

    public Nodo(String etiqueta, T dato, Nodo padre) {

    this.etiqueta = etiqueta;

    this.dato = dato;
    this.padre = padre;

    hijoIzq = null;
    hijoDer = null;
    }

    public void setEtiqueta(String etiqueta) {


    this.etiqueta = etiqueta;
    }

    public void setDato(T dato) {


    this.dato = dato;
    }

    public void setPadre(Nodo padre) {


    this.padre = padre;
    }

    public void setHijoIzq(Nodo hijoIzq) {


    this.hijoIzq = hijoIzq;
    }

    public void setHijoDer(Nodo hijoDer) {


    this.hijoDer = hijoDer;
    }

    public String getEtiqueta() {


    return etiqueta;
    }

    public T getDato() {
    return dato;
    }
    public Nodo getPadre() {
    return padre;
    }

    public Nodo getHijoIzq() {


    return hijoIzq;
    }

    public Nodo getHijoDer() {


    return hijoDer;
    }
    }

    //-----<) Clase 2
    (>---------------------------------------------------------------------------------
    -------------
    package Arbol_Binario;

    import java.util.LinkedList;

    public class ArbolBinario {

    private Nodo raiz;

    public ArbolBinario() {
    this.raiz = null;
    }

    public void setRaiz(Nodo raiz) {


    this.raiz = raiz;
    }

    public Nodo getRaiz() {


    return raiz;
    }

    //------------------------------------------------------------------------------
    public boolean existeRaiz() {
    return getRaiz() != null;
    }

    public boolean insertarRaiz(String etiqueta) {


    if (!existeRaiz()) {
    setRaiz(new Nodo(etiqueta, null, null));
    return true;
    }
    return false;
    }

    public Nodo buscarNodo(String etiqueta) {


    if (existeRaiz()) {
    return buscarNodo(raiz, etiqueta);
    }
    return null;
    }

    private Nodo buscarNodo(Nodo raiz, String etiqueta) {

    Nodo aux = raiz;


    if (aux.getEtiqueta().equals(etiqueta)) {
    return aux;
    }
    if (aux.getHijoIzq() != null) {
    aux = buscarNodo(aux.getHijoIzq(), etiqueta);

    if (aux != null) {
    return aux;
    }
    }
    if (raiz.getHijoDer() != null) {
    aux = buscarNodo(raiz.getHijoDer(), etiqueta);

    if (aux != null) {
    return aux;
    }
    }
    return null;
    }

    public boolean insertarNodo(String etiquetaPadre, String etiquetaNodo) {

    Nodo aux = buscarNodo(etiquetaPadre);

    if (aux.getHijoIzq() == null) {
    aux.setHijoIzq(new Nodo(etiquetaNodo, null, aux));
    return true;
    }
    if (aux.getHijoDer() == null) {
    aux.setHijoDer(new Nodo(etiquetaNodo, null, aux));
    return true;
    }
    return false;
    }

    public int contarNodos() {


    if (existeRaiz()) {
    return contarNodos(raiz, 0);
    }
    return 0;
    }

    private int contarNodos(Nodo raiz, int cantidadNodos) {

    Nodo aux = raiz;


    cantidadNodos++;

    if (raiz.getHijoIzq() != null) {
    cantidadNodos = contarNodos(raiz.getHijoIzq(), cantidadNodos);
    }
    if (raiz.getHijoDer() != null) {
    cantidadNodos = contarNodos(raiz.getHijoDer(), cantidadNodos);
    }
    return cantidadNodos;
    }

    public int contarNodosDe2Hijos() {


    if (existeRaiz()) {
    return contarNodosDe2Hijos(raiz, 0);
    }
    return 0;
    }

    private int contarNodosDe2Hijos(Nodo raiz, int cantidadNodos) {

    Nodo aux = raiz;

    if ((raiz.getHijoIzq() != null) && (raiz.getHijoDer() != null)) {


    cantidadNodos++;
    }
    if (raiz.getHijoIzq() != null) {
    cantidadNodos = contarNodosDe2Hijos(raiz.getHijoIzq(), cantidadNodos);
    }
    if (raiz.getHijoDer() != null) {
    cantidadNodos = contarNodosDe2Hijos(raiz.getHijoDer(), cantidadNodos);
    }
    return cantidadNodos;
    }

    public boolean eliminarNodo(String etiquetaNodo) {

    Nodo aux = buscarNodo(etiquetaNodo).getPadre();

    if (aux.getHijoIzq().getEtiqueta().equals(etiquetaNodo)) {
    aux.setHijoIzq(null);
    return true;
    }
    if (aux.getHijoDer().getEtiqueta().equals(etiquetaNodo)) {
    aux.setHijoDer(null);
    return true;
    }
    return false;
    }

    public LinkedList<Nodo> descendientesDeNodo(String etiquetaNodo) {

    Nodo aux = buscarNodo(etiquetaNodo);


    LinkedList descendientes = descendientesDeNodo(aux, new LinkedList<>());

    return descendientes;
    }

    private LinkedList<Nodo> descendientesDeNodo(Nodo raiz, LinkedList<Nodo>


    descendientes) {

    if (raiz.getHijoIzq() != null) {

    descendientes.add(raiz.getHijoIzq());
    descendientesDeNodo(raiz.getHijoIzq(), descendientes);
    }
    if (raiz.getHijoDer() != null) {

    descendientes.add(raiz.getHijoDer());
    descendientesDeNodo(raiz.getHijoDer(), descendientes);
    }
    return descendientes;
    }
    public LinkedList<Nodo> ancestrosDeNodo(String etiquetaNodo) {

    Nodo aux = buscarNodo(etiquetaNodo);


    LinkedList ancestros = ancestrosDeNodo(aux, new LinkedList<>());

    return ancestros;
    }

    private LinkedList<Nodo> ancestrosDeNodo(Nodo raiz, LinkedList<Nodo> ancestros)


    {

    if (raiz.getPadre() != null) {

    ancestros.add(raiz.getPadre());
    ancestrosDeNodo(raiz.getPadre(), ancestros);
    }
    return ancestros;
    }

    public int nivelDelNodo(String etiquetaNodo) {

    return ancestrosDeNodo(etiquetaNodo).size() + 1;
    }

    //-------< Recorridos
    >----------------------------------------------------------------------------------
    --------
    public LinkedList<Nodo> recorridoPreOrden() {
    if (existeRaiz()) {
    return recorridoPreOrden(raiz, new LinkedList<>());
    }
    return null;
    }

    public LinkedList<Nodo> recorridoPreOrden(Nodo raiz, LinkedList<Nodo> lista) {

    lista.add(raiz);

    if (raiz.getHijoIzq() != null) {
    recorridoPreOrden(raiz.getHijoIzq(), lista);
    }
    if (raiz.getHijoDer() != null) {
    recorridoPreOrden(raiz.getHijoDer(), lista);
    }
    return lista;
    }

    public LinkedList<Nodo> recorridoInOrden() {


    if (existeRaiz()) {
    return recorridoInOrden(raiz, new LinkedList<>());
    }
    return null;
    }

    public LinkedList<Nodo> recorridoInOrden(Nodo raiz, LinkedList<Nodo> lista) {

    if (raiz.getHijoIzq() != null) {
    recorridoInOrden(raiz.getHijoIzq(), lista);
    }
    lista.add(raiz);

    if (raiz.getHijoDer() != null) {
    recorridoInOrden(raiz.getHijoDer(), lista);
    }
    return lista;
    }

    public LinkedList<Nodo> recorridoPosOrden() {


    if (existeRaiz()) {
    return recorridoPosOrden(raiz, new LinkedList<>());
    }
    return null;
    }

    public LinkedList<Nodo> recorridoPosOrden(Nodo raiz, LinkedList<Nodo> lista) {

    if (raiz.getHijoIzq() != null) {
    recorridoPosOrden(raiz.getHijoIzq(), lista);
    }
    if (raiz.getHijoDer() != null) {
    recorridoPosOrden(raiz.getHijoDer(), lista);
    }
    lista.add(raiz);

    return lista;
    }

    También podría gustarte