AGRADECIMIENTOS

¡¡¡GRACIAS!!! A TODOS NUESTROS COMPAÑEROS DE CLASES POR SU AMISTAD, POR ESTAR SIEMPRE CON NOSOTROS, POR  SOPORTARNOS, AYUDARNOS, APESAR DE LAS DIFERENCIAS PERO SIEMPRE HEMOS RECIBIDO DE SU APOYO.

SOBRE TODO GRACIAS AL PROFESOR GUSTAVO POR SU TIEMPO Y DEDICACIÓN HACIA TODOS NOSOTROS.

¡¡¡GRACIAS A TODOS, DIOS LOS BENDIGA Y TENGAN UNA FELIZ NAVIDAD, UN PROSPERO AÑO NUEVO, Y QUE  TODOS SUS SUEÑOS Y ANHELOS SE HAGAN REALIDAD!!! 

ARBOL

NOVENA PRACTICA

CONCEPTO

 "Es una colección de nodos que tienen arboles", es una estructura no lineal (1 antecesor y varios sucesores)
y dinámica(no hay restricción de eliminar o insertar nodos), sus elementos se llaman nodos, inicia con un nodo llamado raíz (si raíz es null, esta vació el árbol), es una estructura recursiva(se llama así misma), el numero de descendientes de un nodo es el grado del nodo, el  grado del árbol es el máximo de descendientes que puede tener un nodo y su  final se llama hoja

arboles binarios de búsqueda

1- grado 2
2- hijo izquierdo y derecho
3- ordenado: los nodos menores a la raíz van a la izquierda  y los mayores a la derecha
4- operaciones:
4.1- recorrido:
  4.1.1 inorden
  4.1.2 preorden
  4.1.3 postorden
4.2 - insertar
4.3- borrar

 PROCEDIMIENTO

1.  Creamos la clase NodoArbol y el constructor de la clase [NodoArbol ()], refractamos int información, NodoArbol der e izq.

2.   Luego elaboramos la clase Arbol, la cual tiene un constructor [Arbol ()], refractamos NodoArbol raíz, 4 métodos: insertar, inOrden, preOrden y posOrden.

DIAGRAMAS UML

 CODIFICACION


inicia la clase NodoArbol
package Ortiz;
public class NodoArbol {
 private int informacion;
 private NodoArbol der;
 private NodoArbol izq;
 //constructor d la clase
NodoArbol(){
    izq=null;
    der=null;
}
NodoArbol(int x){
   informacion=x;
   izq=null;
   der=null;
}
 }
termina la clase NodoArbol


inicia la clase Arbol
package Ortiz;
public class Arbol {
   private NodoArbol raiz;
   //contructor de la clase
    Arbol(){
        raiz=null;
    }
 
    //metodo recursivo ,r es la raiz, datoes el valor
    public NodoArbol insertar(NodoArbol r,int dato){
        if(r==null){//creamos el nodo que vamos a insertar
            r=new NodoArbol(dato);
        }
        else{
            if(dato < r.getInformacion()){
                r.setIzq(insertar(r.getIzq(),dato));
            }
            else{
                r.setDer(insertar(r.getDer(),dato));
            }
        }
        return r;
    }
    public String inOrden(NodoArbol r){
        String cadena= new String();
        if(r !=null){
            cadena=cadena+inOrden(r.getIzq());
            cadena=cadena+String.valueOf(r.getInformacion()+" ");
            cadena=cadena+inOrden(r.getDer());
        }
        return cadena;
    }
    public String preOrden(NodoArbol r){
        String cadena=new String();
         if(r !=null){
        cadena=cadena+String.valueOf(r.getInformacion()+"   ");
        cadena=cadena+preOrden(r.getIzq());
        cadena=cadena+preOrden(r.getDer());
    }
       return cadena;
    }
    public String postOrden(NodoArbol r){
        String cadena =new String();
        if(r !=null){
          cadena=cadena+preOrden(r.getIzq());
           cadena=cadena+preOrden(r.getDer());
           cadena=cadena+String.valueOf(r.getInformacion()+"   ");
        }
        return cadena;
    }
}
termina la clase ARBOL

CONCLUSIÓN

En esta practica podemos analizar  una colección de nodos organizados en forma recursiva. Cuando hay 0 nodos se dice que el árbol esta vacío, en caso contrario el árbol consiste en un nodo denominado raíz, el cual tiene 0 o más referencias a otros árboles, conocidos como subárboles. Las raíces de los subárboles se denominan hijos de la raíz, y consecuentemente la raíz se denomina padre de las raíces de sus subárboles.

AUTORES

Javier Arley Gonzalez Roblero, Saulo Ortiz Ortiz, Manuel Alejandro Mendez Lopez.

PILA

OCTAVA PRACTICA

CONCEPTO


Es una estructura lineal y dinámica,sus elementos se llaman nodos,los cuales se insertan y eliminan por el mismo extremo(UPS o LIFO) y sus operaciones son: push(inserta al inicio) y pop(elimina al inicio).

PROCEDIMIENTO


1.-Crear la pila.
2.-Comprobar si la pila está vacía. Es necesaria para saber si es posible eliminar elementos.
3.-Acceder al elemento situado en la cima.
4.-Añadir elementos a la cima.
5.-Eliminar elementos de la cima. 

DIAGRAMAS UML

CODIFICACIÓN

empieza la clase Nodo
package Ortiz;
import javax.swing.JOptionPane;
public class Nodo {
  private String informacion;
      private Nodo enlace;
   
      public Nodo (String x)
      {
          informacion=x;
          enlace=null;
      }
      public Nodo(String x, Nodo n){
        informacion=x;
        enlace=n;
      }
    }
  termina la clase Nodo

inicia la clase Pila

package Ortiz;

import javax.swing.JOptionPane;

public class Pila {

    Pila(){

      tope=null;

    }

     public Pila push(String informacion){

   Nodo nuevo;

   nuevo= new Nodo(informacion);//crear nuevo nodo(elemento)

   nuevo.setEnlace(getTope());//enlaza nuevo al frente de la lista

   setTope(nuevo);//mueve inicio y apunta al nuevo nodo

   return this;//devuelve la referencia del objeto pila

   } 

     public String pop(){

      Nodo x=tope;

      tope=tope.getEnlace();//borrado logico

      return x.getInformacion();

     }

      public void imprimir(){

    String cadena="";

    Nodo q=tope;

    int i=1;

    while(q !=null){

      cadena+="\n"+i+". "+q.getInformacion();

      q=q.getEnlace();

      i++;

    }

     JOptionPane.showMessageDialog(null, cadena,"Nodos de la lista",JOptionPane.PLAIN_MESSAGE);

    }

}

termina la clase Pila

CONCLUSIÓN

En esta práctica fue un  requisito típico de almacenamiento de una pila de n elementos. El requisito típico de tiempo de las operaciones también son fáciles de satisfacer con un array o con listas enlazadas simples. 

AUTORES

Javier Arley Gonzalez Roblero, Saulo Ortiz Ortiz, Manuel Alejandro Mendez Lopez.

COLA

SÉPTIMA PRACTICA

CONCEPTO

Es una estructura lineal y dinámica, sus elementos se llaman nodos, los cuales se insertan por un extremo(FINAL), se eliminan por el otro extremo(FRENTE),  es decir PEPS O FIFO.

DIAGRAMAS UML

PROCEDIMIENTO

1.-Crear una cola vacía.
2.- Determinar si la cola está vacía, en cuyo caso no es posible eliminar elementos.
3.- Acceder al elemento inicial de la cola.
5.-- Insertar elementos al final de la cola.
6.- Eliminar elementos del inicio de la cola.

CODIFICACIÓN


inicia la clase Nodo
package Ortiz;
import javax.swing.JOptionPane;
public class Nodo {
  private String informacion;
      private Nodo enlace;
   
      public Nodo (String x)
      {
          informacion=x;
          enlace=null;
      }
      public Nodo(String x, Nodo n){
        informacion=x;
        enlace=n;
      }
   }

termina la clase nodo

inicia la clase Cola

package Ortiz;

import javax.swing.JOptionPane;

public class Cola {

    private Nodo frente;

    private Nodo fin;

   Cola(){

       frente=null;

       fin=null;

   }

    public Cola Inserta(String x){

        Nodo nuevo=new Nodo(x);

        if((frente==null)&&(fin==null)){

            fin=nuevo;

            frente=fin;

        }

        else{

            fin.setEnlace(nuevo);

            fin=nuevo;

        }

        return this;

    }

    public String elimina(){

        Nodo x=frente;

        if(frente==fin){

            frente=null;

            fin=null;

        }

        else{

            frente=frente.getEnlace();

        }

        return x.getInformacion();

    }

    public void imprimir(){

    String cadena="";

    Nodo q=fin;

    int i=1;

    while(q !=null){

      cadena+="\n"+i+". "+q.getInformacion();

      q=q.getEnlace();

      i++;

    }

 JOptionPane.showMessageDialog(null, cadena,"Nodos de la lista",JOptionPane.PLAIN_MESSAGE);

}

}

termina la clase Cola

CONCLUSIÓN

En esta practica  colas son secuencias de elementos caracterizadas porque las operaciones de inserción y borradose realizan sobre extremos opuestos de la secuencia. La inserción se produce en el "final" de la
secuencia, mientras que el borrado se realiza en el otro extremo, el "inicio" de la secuencia.


AUTORES

Javier Arley Gonzalez Roblero, Saulo Ortiz Ortiz, Manuel Alejandro Mendez Lopez.

LISTA

PRACTICA No.6

CONCEPTO

Es una estructura lineal, dinámica, su acceso es secuencial y esta indicado por un puntero llamado inicio, sus elementos es una sucesión de n nodos y tiene tres operaciones básicas: insertar, eliminar y recorrer.

PROCEDIMIENTO

1.- Primero creamos la clase Nodo en la cual refractamos información y enlace, y colocamos un constructor llamado Nodo.
2.-Elaboramos la clase Lista la cual refractamos inicio, un constructor llamado Lista, tiene ocho métodos: inserta al inicio,inserta al final, insertantes, insertadespues, eliminainicio, eliminafinal, eliminax e imprimir.

DIAGRAMAS UML

CODIFICACIÓN:

Comienza la clase Nodo

package Ortiz;
import javax.swing.JOptionPane;
public class Nodo {
      private String informacion;
      private Nodo enlace;
   
      public Nodo (String x)
      {
          informacion=x;
          enlace=null;
      }
      public Nodo(String x, Nodo n){
        informacion=x;
        enlace=n;
      }
}

Termina la clase Nodo


comienza la clase Lista
package Ortiz;
import javax.swing.JOptionPane;
public class Lista {
   private Nodo inicio;
 
   Lista(){
       inicio=null;
   }
   public Lista InsertarInicio(String informacion){
   Nodo nuevo;
   nuevo= new Nodo(informacion);//crear nuevo nodo(elemento)
   nuevo.setEnlace(getInicio());//enlaza nuevo al frente de la lista
   setInicio(nuevo);//mueve inicio y apunta al nuevo nodo
   return this;//devuelve la referencia del objeto lista
   }
   public Lista InsertarFinal(String informacion){//este metodo funciona si por lo menos la lista tiene un nodo
     Nodo ultimo;
     ultimo=inicio;//ultimo se inicializa al comienza de la lista
     while(ultimo.getEnlace() !=null){//recorrido para buscar el ultimo nodo
     ultimo=ultimo.getEnlace();//ultimo toma la direccion del nodo siguiente
     }
     ultimo.setEnlace(new Nodo (informacion)); //se crea el nuevo nodo despues del ultimo
     return this;
   }
   public Lista InsertarAntes(String nombre, String ref){//se utilizan parametros
       Nodo nuevo, actual, anterior= null;
       boolean esta=true;
       actual=inicio;//vamos a recorrer la lista con actual
       while (!actual.getEnlace().equals(ref)&& esta){//para comparar dos cadenas
           if(actual.getEnlace()!=null){
           anterior=actual;
           actual=actual.getEnlace();
       }
           else{
               esta=false;
           }
       }
       if(esta){
           if(inicio==actual){//vamos a insertar antes del primer nodo
               nuevo=new Nodo(nombre, inicio);//se llama al segundo constructor
               inicio=nuevo;
           }
     
           else{
               nuevo=new Nodo(nombre, actual);
               anterior.setEnlace(nuevo);
           }
       }
       return this;
   }
  public Lista insertaDespues(String nombre, String ref){
      Nodo nuevo,actual=null;
      boolean esta=true;
      actual=inicio;//es esencial en todo st programa
      while(! actual.getInformacion().equals(ref)&& esta){
          if(actual.getEnlace() !=null)
              actual =actual.getEnlace();
              else{
              esta=false;
              }
          if(esta){
              nuevo=new Nodo (nombre, actual.getEnlace());
              actual.setEnlace(nuevo);
           }
         }
       return this;
     }
  public String eliminaInicio(){
      Nodo x=inicio;
      inicio=inicio.getEnlace();//borrado logico
      return x.getInformacion();
  }
  public String eliminaFinal(){///quitar de la lista l ultimo nodo
      Nodo ultimo,anterior=null;
      ultimo=inicio;
      while(ultimo.getEnlace()!=null){
          anterior=ultimo;
          ultimo=ultimo.getEnlace();
          }
      if(inicio.getEnlace()==null){
          inicio=null;
      }
      else{
      anterior.setEnlace(null);//borrado logico
      }
      return ultimo.getInformacion();
      }
  public void imprimir(){
    String cadena="";
    Nodo q=inicio;
    int i=1;
    while(q !=null){
      cadena+="\n"+i+". "+q.getInformacion();
      q=q.getEnlace();
      i++;
    }
    JOptionPane.showMessageDialog(null, cadena,"Nodos de la lista",JOptionPane.PLAIN_MESSAGE);
}
  public String eliminaX (String x){
      Nodo actual, anterior =null;
      boolean esta=true;
      actual=inicio;
      while(!actual.getInformacion().equals(x)&& esta){
          if(actual.getEnlace()!=null){
              anterior=actual;
              actual.setEnlace(actual.getEnlace());
          }
          else
              esta=false;
      }
      if(esta){
          anterior.setEnlace(actual);//borrado logico
          return actual.getInformacion();
      }
      else
       return " ";
  }
}

Termina la clase Lista

CONCLUSIÓN

En esta práctica aprendimos a utilizar las direcciones de memoria la cual, o es mas eficiente que declarar arreglos pero a su vez mas peligrosa porque si borramos el nodo inicio perdemos la lista completa.
ventaja es que podemos hacer mejor uso de la memoria  y desventaja si pierdes inicio por descuido
o por falta de conocimiento de como programar pierdes la lista



AUTORES

Javier Arley Gonzalez Roblero, Saulo Ortiz Ortiz, Manuel Alejandro Mendez Lopez.