jueves, 23 de febrero de 2017

LISTAS DOBLES II

LISTAS DOBLES
Las listas doblemente enlazadas son estructuras de datos semejantes a las listas enlazadas simples.
La asignación de memoria es hecha al momento de la ejecución.

En cambio, en relación a la listas enlazada simple el enlace entre los elementos se hace gracias a dos punteros (uno que apunta hacia el elemento anterior y otro que apunta hacia el elemento siguiente).

El puntero anterior del primer elemento debe apuntar hacia NULL (el inicio de la lista).
El puntero siguiente del último elemento debe apuntar hacia NULL (el fin de la lista).

Para acceder a un elemento, la lista puede ser recorrida en ambos sentidos:
·    comenzando por el inicio, el puntero siguiente permite el desplazamiento hacia el próximo elemento.
·    comenzando por el final, el puntero anterior permite el desplazamiento hacia el elemento anterior.


 CÓDIGO FUENTE

CLASE NODO
public class NodoDoble {
   

    private int precioventa,stock,preciocompra;
    private String nombre;
    
   private NodoDoble siguiente;
   private NodoDoble anterior;

    public NodoDoble(int stock, int preciocompra, String nombre) {
       
        this.preciocompra=preciocompra;
        this.stock=stock;
        this.nombre=nombre;
        this.siguiente = null;
        this.anterior = null;
    }

    public int getPrecioventa() {
        return precioventa;
    }

    public void setPrecioventa(int precioventa) {
        this.precioventa = precioventa;
    }

    public int getStock() {
        return stock;
    }

    public void setStock(int stock) {
        this.stock = stock;
    }

    public int getPreciocompra() {
        return preciocompra;
    }

    public void setPreciocompra(int preciocompra) {
        this.preciocompra = preciocompra;
    }

    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    public NodoDoble getSiguiente() {
        return siguiente;
    }

    public void setSiguiente(NodoDoble siguiente) {
        this.siguiente = siguiente;
    }

    public NodoDoble getAnterior() {
        return anterior;
    }

    public void setAnterior(NodoDoble anterior) {
        this.anterior = anterior;
    }

}
CLASE PRODUCTO
public class OperProducto {

    NodoDoble inicio, fin;

    public OperProducto() {
        inicio = null;
        fin = null;
    }

    public void ingresarnodo(int stock, int preciocompra, String nombre) {
        NodoDoble nodo = new NodoDoble(stock, preciocompra, nombre);

        if (inicio == null) {
            inicio = nodo;
            fin = inicio;
        } else {
            fin.setSiguiente(nodo);
            nodo.setAnterior(fin);
            nodo.setSiguiente(null);
            fin = nodo;
        }
    }

    public boolean buscarnodo(String nombre) {
        NodoDoble nodo;
        nodo = inicio;
        boolean retorno = false;
        while (nodo != null) {
            if (nodo.getNombre() == nombre) {
                retorno = true;
                System.out.println("encontrado..");
                break;
            }
            nodo = nodo.getSiguiente();
        }
        if (retorno == false) {
            //System.out.println("no encontrado");
        }
        return retorno;
    }

    public int calcularprecioventa(String nombre) {
        int preventa = 0;
         NodoDoble temp = inicio;
        if (buscarnodo(nombre)) {
           

            preventa = (int) ((temp.getPreciocompra() + (temp.getPreciocompra() * 0.30)) + 
((temp.getPreciocompra() + (temp.getPreciocompra() * 0.30)) * 0.18));
            temp.setPrecioventa(preventa);
        }
        return preventa;
    }

    public String mostrarventa(String nombre) {
        NodoDoble temp;
        temp = inicio;
        String cadena1 = "";

        if (buscarnodo(nombre)) {
            System.out.println(temp.getNombre() + "" + temp.getPrecioventa());
            cadena1 = cadena1 + "Nombre:\t" + temp.getNombre() + "\nPrecio Venta:\t" + 
temp.getPrecioventa() + "\n\n\n";
        }
        return cadena1;
    }
    
    

    public String mostrar() {
        NodoDoble temp;
        temp = inicio;
        String cadena = "";
        while (temp != null) {
            cadena = cadena + "Nombre:\t" + temp.getNombre() + "\nPrecio Compra:\t" +
 temp.getPreciocompra() + "\nPrecio Venta:\t" + temp.getPrecioventa() + "\nStock:\t" +
 temp.getStock() + "\n";
           
            temp = temp.getSiguiente();
        }
        return cadena;
    }
    public String invertido(){
         NodoDoble temp;
        temp = fin;
        String cadena = "";
        while (temp != null) {
            
            cadena = cadena + "Nombre:\t" + temp.getNombre() + "\nPrecio Compra:\t" +
temp.getPreciocompra() + "\nPrecio Venta:\t" + temp.getPrecioventa() + "\nStock:\t" + 
temp.getStock() + "\n";
           
            temp = temp.getAnterior();
        }
        return cadena;
    }
    
    
    public String mostrarprecioacendente() {
        NodoDoble temp;
        temp = inicio;
        String cadena = "";
        while (temp != null) {
            
            cadena = cadena + "Nombre:\t" + temp.getNombre() + "\nPrecio Compra:\t" +
 temp.getPreciocompra() + "\nPrecio Venta:\t" + temp.getPrecioventa() + "\nStock:\t" +
 temp.getStock() + "\n";
           
            temp = temp.getSiguiente();
        }
        return cadena;
    }
    
    
    
}
MAIN
public class menuproducto {
    public static void main(String[] args) {
        OperProducto op=new OperProducto();
        op.ingresarnodo( 5, 10, "arroz");
        op.ingresarnodo( 6, 2, "papa");
        op.mostrar();
        System.out.println("*****************");
      
        
    }
}

LISTAS ENLAZADAS

La lista enlazada 

Es un TDA que nos permite almacenar datos de una forma organizada, al igual que los vectores pero, a diferencia de estos, esta estructura es dinámica, por lo que no tenemos que saber "a priori" los elementos que puede contener.
En una lista enlazada, cada elemento apunta al siguiente excepto el último que no tiene sucesor y el valor del enlace es null. Por ello los elementos son registros que contienen el dato a almacenar y un enlace al siguiente elemento. Los elementos de una lista, suelen recibir también el nombre de nodos de la lista.

Representa el dato a almacenar. Puede ser de cualquier tipo; en este ejemplo se trata de una lista de enteros.
Es un puntero al siguiente elemento de la lista; con este puntero enlazamos con el sucesor, de forma que podamos construir la lista.


            struct lista {
     gint dato;
     lista *siguiente;
     };
CLASE NODO
public class Nodo {
    private float dato;
    private Nodo siguiente;
  
    public Nodo(float dato){
        this.dato=dato;
        this.siguiente=null;
    }
    public Nodo(float dato, Nodo siguiente){
        this.dato=dato;
        this.siguiente=siguiente;
  
    }

    public float getDato() {
        return dato;
    }

    public void setDato(float dato) {
        this.dato = dato;
    }

    public Nodo getSiguiente() {
        return siguiente;
    }

    public void setSiguiente(Nodo siguiente) {
        this.siguiente = siguiente;
    }

}
  CLASE LISTA 
public class Lista {
    Nodo inicio;
    Nodo fin;
  
    public Lista() {
        inicio=null;
        fin=null;
    }
     public void agregarNodoAlInicio(int dato){//permite agregar nodos al final de la lista
         Nodo nuevo=new Nodo(dato);
         nuevo.setSiguiente(inicio);
         inicio=nuevo;
         if(fin==null)
             fin=nuevo;
    }
  
    public void agregarNodoAlFinal(int dato){//Permite agregar nodos al final de una lista
        Nodo nuevo=new Nodo(dato);
        if(fin!=null){
            fin.setSiguiente(nuevo);
            fin=nuevo;
       }
       else{
            fin=nuevo;
            inicio=nuevo;
       }
    }
    public void recorreLista(){//Esta metodo permite la impresion de la lista
        Nodo aux=inicio;
        while(aux!=null){
            System.out.println(aux.getDato());
            aux=aux.getSiguiente();
        }
  
    }
   public void eliminarNodos(int numero)//permite eliminar los nodos que superen un valor dado
 {
            if(inicio!=null)//comprueba si la lista esta vacia
            {
  if(inicio.getDato()!=numero)
                {
                    inicio=fin=null;
                }
                else if((inicio==fin)&&(inicio.getDato()!=numero))
  {
                    inicio=inicio.getSiguiente();
                }
              
                else
                {
                    Nodo anterior=inicio;
                    Nodo siguiente=inicio.getSiguiente();
                    while((siguiente!=null)&&(siguiente.getDato()!=numero))
                    {
                        anterior=siguiente;
                        siguiente=siguiente.getSiguiente();
                    }
                    if(siguiente!=null)
                    {
                        anterior.setSiguiente(siguiente.getSiguiente());
                        if(siguiente==fin)
                        {
                            fin=anterior;
                        }
                    }
                }
            }
        }

}
MAIN
public class Principal {

    /**
     * @param args the command line arguments
     */
    public static int leerEntero(String texto){//
  Scanner ingreso =new Scanner(System.in);
  System.out.println(texto);
  int dato=ingreso.nextInt();
  return dato;
 }
    public static int menu(){//creacion del menu de opciones
  
  System.out.println("---Menu---");
  System.out.println("1. Agregar Final");
                System.out.println("2. Recorrer lista");
                System.out.println("3. Borar un elemento");
  System.out.println("4. Salir");
  int dato=leerEntero("Seleccione una opcion: ");
  return dato;
 }
    public static void main(String[] args) {
        // TODO code application logic here
        int opcion;
    Lista coleccion=new Lista();//llamado de la clase para el acceso a los metodos
    do{
   opcion=menu();
   switch (opcion) {
   case 1:
    coleccion.agregarNodoAlFinal(leerEntero("Ingrese un valor: "));//Insertar nodos al final
    break;
   case 2:
                                System.out.println("Lista");//impresion de la lista
    coleccion.recorreLista();
    break;
   case 3:
    coleccion.eliminarNodos(leerEntero("Ingrese un valor: "));//Eliminar los nodos con un dato dado
    break;
   default:
    System.out.println("Fin del programa!");;
   }
    }while(opcion!=4);
    }
}

martes, 21 de febrero de 2017

LISTAS DOBLES

LISTAS ENLAZADAS DOBLES
*INVIERTE EL SENTIDO

NODO
public class Nodo {
    String info;
    public Nodo siguiente;
    public  Nodo anterior;
   
    public Nodo(String dato){
        info=dato;
        anterior = null;
        siguiente= null;
    }
    public void verNodo(){
        System.out.println("( "+info+" )");
    }
}

 LISTAS ENLAZADAS 

public class ListaEnlazada {

    Nodo cabeza;
    Nodo cola;

    public ListaEnlazada() {
        cabeza = null;
        cola = null;
    }

    public boolean vacia() {
        if (cabeza == null) {
            return (true);

        } else {
            return (false);
        }

    }

    public void insertarPrimemro(String dato) {
        Nodo temporal = new Nodo(dato);
        if (vacia()) {
            cabeza = temporal;
            cola = temporal;
        } else {
            temporal.siguiente = cabeza;
            cabeza.anterior = temporal;
            cabeza = temporal;
        }

    }

    public void insertaAlFInal(String dato) {
        Nodo temporal = new Nodo(dato);
        if (vacia()) {
            cabeza = temporal;
            cola = temporal;
        } else {
            cola.siguiente = temporal;
            temporal.anterior = cola;
            cola = temporal;
        }
    }

    public void borrarPrimero() {
        cabeza = cabeza.siguiente;
        cabeza.anterior = null;
    }

    public void borrarUltimo() {
        if (cola.anterior == null) {
            cabeza = null;
            cola = null;
        } else {
            cola = cola.anterior;
            cola.siguiente = null;

        }
    }

    public String Listar() {
        String Dato = "";
        Nodo axu = cola;
        while (axu != null) {
            Dato += "{" + axu.info + "}";
            axu = axu.anterior;
        }
        return (Dato);
    }

    public String ListarCola() {
        String Dato = "";
        Nodo axu = cabeza;
        while (axu != null) {
            Dato += "{" + axu.info + "}";
            axu = axu.siguiente;
        }
        return (Dato);
    }


MAIN


}

public class Princnipal {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
   
 
        
        
        ListaEnlazada miLista = new ListaEnlazada();
        miLista.insertarPrimemro("jabon");
        miLista.insertarPrimemro("kolinos");
        miLista.insertarPrimemro("detergente");
        miLista.insertarPrimemro("cepilo");
        miLista.insertarPrimemro("toalla");
      
        System.out.println(miLista.Listar());
       System.out.println(miLista.ListarCola());
     
    }
    
}

ARBOLES

ARBOLES 

En ciencia de la computación, un árbol es una estructura de datos ampliamente usada que emula la forma de un árbol (un conjunto de nodos conectados). Un nodo es la unidad sobre la que se construye el árbol y puede tener cero o mas nodos hijos conectados a él. Se dice que un nodo a es padre de un nodo b, si existe un enlace desde a hasta b (en ese caso, también decimos que b es hijo de a). Sólo puede haber un único nodo sin padres, que llamaremos raíz. Un nodo que no tiene hijos se conoce como hoja.
El árbol También se define como una estructura de datos no lineal. Esta estructura se usa principalmente para representar datos con una relación jerárquica entre sus elementos, como por ejemplo registros, árboles genealógicos y tablas de contenidos. Entre otros tenemos un tipo especial de de árbol que es, llamado árbol binario, que puede ser implementado fácilmente en la computadora.


ARBOLES

Package arboles;

/**
 *
 * @author Greyscp
 */
class Nodo
{
  int info;
  Nodo izq, der;
}

public class ArbolBinario
{
         Nodo raiz;

     public ArbolBinario()
     {
         raiz=null;
     }
   
     public void insertar (int info)
     {
         Nodo nuevo;
         nuevo = new Nodo ();
         nuevo.info = info;
         nuevo.izq = null;
         nuevo.der = null;
         if (raiz == null)
             raiz = nuevo;
         else
         {
             Nodo anterior = null, reco;
             reco = raiz;
             while (reco != null)
             {
                 anterior = reco;
                 if (info < reco.info)
                     reco = reco.izq;
                 else
                     reco = reco.der;
             }
             if (info < anterior.info)
                 anterior.izq = nuevo;
             else
                 anterior.der = nuevo;
         }
     }


     private void imprimirPre (Nodo reco)
     {
         if (reco != null)
         {
             System.out.print(reco.info + " ");
             imprimirPre (reco.izq);
             imprimirPre (reco.der);
         }
     }

     public void imprimirPre ()
     {
         imprimirPre (raiz);
         System.out.println();
     }

     private void imprimirEntre (Nodo reco)
     {
         if (reco != null)
         {  
             imprimirEntre (reco.izq);
             System.out.print(reco.info + " ");
             imprimirEntre (reco.der);
         }
     }

     public void imprimirEntre ()
     {
         imprimirEntre (raiz);
         System.out.println();
     }


     private void imprimirPost (Nodo reco)
     {
         if (reco != null)
         {
             imprimirPost (reco.izq);
             imprimirPost (reco.der);
             System.out.print(reco.info + " ");
         }
     }


     public void imprimirPost ()
     {
         imprimirPost (raiz);
         System.out.println();
     }


}
 MAIN

package arboles;

/**
 *
 * @author Greyscp
 */
public class Principal {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        ArbolBinario ab= new ArbolBinario();
        ab.insertar(1);
        ab.insertar(2);
        ab.insertar(3);
        ab.insertar(4);
        ab.insertar(5);
        ab.insertar(6);
        ab.insertar(7);
             
        System.out.println("imprimir preorden");
        ab.imprimirPre();
        System.out.println("imprimir intOrden");
        ab.imprimirEntre();
        System.out.println("imprimir postOrden");
        ab.imprimirPost();
             

     
     
     
     
    }
 
}

jueves, 9 de febrero de 2017

Ejercicio de Lista Simple








package En_ClaseLisaSimple;

public class Main {
    public static void main(String[] args) {
        testnodo lista = new testnodo();
     
        lista.agregar(10);
        lista.agregar(9);
        lista.agregar(8);
        lista.agregar(7);
        lista.agregar(6);
        lista.agregar(5);
     
        lista.imprimir();
        System.out.println("Eliminando el 10");
        lista.eliminar(10);
        lista.imprimir();
     
    }
}

*Clase Nodo

package En_ClaseLisaSimple;

public class nodo {
     int dato;
    nodo nodito;
 
 
    public nodo(int x){
        this.dato=x;
        nodito=null;
    }
 
    public String toString(){
        return ""+this.getDato();
    }

    public int getDato() {
        return dato;
    }

    public void setDato(int dato) {
        this.dato = dato;
    }


    public nodo getNodito() {
        return nodito;
    }

 
    public void setNodito(nodo nodito) {
        this.nodito = nodito;
    }


}

*Clase Main

package En_ClaseLisaSimple;

public class testnodo {
    nodo fin;
    
    public testnodo(){
        this.fin=null;
    }
    
    void agregar(int x){
        nodo nuevo=new nodo(x);
        
        if (fin==null) {
            fin=nuevo;
        }else{
            nuevo.nodito=fin;
            fin=nuevo;
        }
    }
    
    void imprimir(){
        nodo temp=fin;
        while(temp!=null){
            System.out.println(temp.toString());
            temp=temp.nodito;
        }   
    }
    
    
    boolean estaContenido(int x){
        boolean band=false;
        nodo temp =fin;
        while(temp!=null){
            if (temp.getDato()==x) {
                band =true;
                break;
            }
            temp=temp.nodito;
        }
        return band;
    }
    
     void eliminar(int x){
        nodo temp=fin,temp2=fin;
        
        if(estaContenido(x)){
            while(temp!=null){
                if (temp.getDato()==x) {
                    if (fin.getDato()==x) {
                        fin= fin.nodito;
                    break;
                    }
                else{
                    temp2.nodito=temp.nodito;
                    break;
                }
                  
            }temp2 = temp;
                temp = temp.getNodito();
         
            } 
       
        }
     }
     
     void modificar(int x){
     
     }
}