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.

PEAJE DE CAMIONES

QUINTA PRACTICA

Problema a resolver:

Calcular el costo de peaje de camiones. Los camiones que llegan a una estación de peaje deben pagar $50 por cada eje mas $100 por cada tonelada de peso total del camión.

Procedimiento:

1.   Comenzamos a analizar el programa a resolver.

2.   Identificamos los datos de entrada (50 y 100) y salida (costo de peaje de camiones).

3.   Creamos  el diagrama UML, la cual contiene el  nombre de la clase,  atributos y métodos.

4.   Comenzamos a codificar y creamos la clase llamada Peaje.

5.   Después utilizamos una herramienta de java conocido como refactor  para las variables (int pxe, int pxt, int pt, int tc, int ce) y de esa manera realizamos  el programa más rápido y mejor organizado. 

6.   Posteriormente comenzamos  a crear los métodos: captura, calcular e imprimir.

7.   Luego creamos la clase llamada Solución, en la que integramos una variable “a”, la cual tiene la función de utilizar las operaciones aritméticas de los distintos métodos asignados.

8.   Por último ejecutamos el programa, así logrando imprimir el costo de peaje de camiones deseados.

DIAGRAMAS UML

SOLUCIÓN EN JAVA

comienza la clase peaje

import javax.swing.JOptionPane;

public class Peaje {

    private int pxe;

    private int ce;

    private int pxt;

    private int tc;

    private int pt;

    public void captura(){

        ce=Integer.parseInt(JOptionPane.showInputDialog("cantidad de eje "));

        tc=Integer.parseInt(JOptionPane.showInputDialog("cantidad de toneladas "));

    }

    public void calcular(){

        pxe=ce*50;

        pxt=tc*100;

        pt=pxe+pxt;

    }

    public void imprimir(){

        JOptionPane.showMessageDialog(null,"PAGO TOTAL  "+pt);

    }

    }

termina la clase peaje

comienza la clase solución

public class Solucion {

   public static void main(String []largs){

       Peaje a;

       

       a=new Peaje();

       

       a.captura();

       a.calcular();

       a.imprimir();

   }  

}

termina la clase solución

CONCLUSIÓN

En esta  practica resolvimos como calcular el pago del peaje y ejes de un camión,se nos hizo facilicimo crear este programa ya que con los conocimientos adquiridos hasta hoy,gracias a estructura de datos aprendimos a programar mas fácil, divertido y organizado.

Autores

Javier  Arley Gonzalez Roblero, Manuel  Alejandro Mendez lopez y Saulo Ortiz Ortiz

SALARIO

CUARTA PRACTICA

Problema a resolver:

Calcular el salario de un empleado con base en lo siguiente:
1)por cada hora trabajada recibe $17.50, para las primeras 8 horas.
2)por cada hora extra recibe 1.5 veces el costo de la hora de trabajo dentro del horario normal.

Procedimiento:

1.   Comenzamos a analizar el programa a resolver.

2.   Identificamos los datos de entrada ($17.50 las 8 hrs. De trabajo normal y 1.5 veces más para las hrs. extras) y salida (salario final del empleado).

3.   Creamos  el diagrama UML, la cual contiene el  nombre de la clase,  atributos y métodos.

4.   Comenzamos a codificar y creamos la clase llamada Salario.

5.   Después utilizamos una herramienta de java conocido como refactor  para las variables (int ht, float pxh, float s, float st) y de esa manera realizamos  el programa más rápido y mejor organizado. 

6.   Posteriormente comenzamos  a crear los métodos: captura, calcula e imprimir.

7.   Luego creamos la clase llamada Calculasalario, en la que creamos una variable “z”, la cual tiene la función de realizar las operaciones aritméticas del método que le asignemos.

Por último ejecutamos el programa, así logrando imprimir el salario del empleado deseado.


DIAGRAMAS UML

SOLUCIÓN EN JAVA

comienza la clase salario
import javax.swing.JOptionPane;
public class Salario {
    private int ht;
    private int ph;
    private double salario;
    private double salarioextra;
 
    public void captura(){
        ht=Integer.parseInt(JOptionPane.showInputDialog("horas trabajadas "));
        ph=Integer.parseInt(JOptionPane.showInputDialog("pago x hora "));
    }
    public void calcula(){
        if(ht>8){
            salario=(ht-8)*(ph*1.5);
            salarioextra=(8*ph)+salario;
        }
        else{
            salario=ht*ph;
        }
    }
    public void imprimir(){
        JOptionPane.showMessageDialog(null,"El SALARIO CON HORAS EXTRAS  "+salarioextra+"\n"+"EL SALARIO NORMAL "+salario);
    }
}

Termina la clase salario

comienza la clase calculasalario
public class Calculasalario {
     public static void main(String []largs){
     
         Salario z;
         z=new Salario();
       
         z.captura();
         z.calcula();
         z.imprimir();
     }
   }

Termina la clase calculasalario

CONCLUSIÓN

Esta práctica fue fácil de realizar ya que utilizamos todo lo aprendido hasta el momento y sobretodo porque es un problema sencillo de resolver, todos estamos relacionados en la vida cotidiana con el calculo de salarios normales y con horas extras.

Autores

Javier  Arley Gonzalez Roblero, Manuel  Alejandro Mendez lopez y Saulo Ortiz Ortiz