Blog del sitio: Tecnológico

Página: ()  1 ...  7  8  9  10  11  12  13  14  15  16  17  18  19  20  21  22  23  24 ...73   ()
Imagen de Jose David Buelvas Ballesteros
de Jose David Buelvas Ballesteros - sábado, 8 de marzo de 2014, 17:55
Todo el mundo

La lista enlazada 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

 

Tipos de listas enlazadas: 

Tipo De Listas Enlazadas

 

Entrada Anterior               Inicio            Entrada Siguiente

[ Modificado: jueves, 13 de marzo de 2014, 09:20 ]
 
Imagen de Amaury Enrique Puello Tinoco
de Amaury Enrique Puello Tinoco - viernes, 7 de marzo de 2014, 20:06
Todo el mundo

La clase del día 5 de marzo se enfocó en la explicación de la operación de inserción en distintas posiciones de una lista dinámica.

Inserción al inicio: antes del primero

 

En una lista doble:

El siguiente código permite la creación de un nuevo nodo doble en la dirección anterior del primer NodoDoble, y el cambio de dirección de la variable p.

p.setAnt(new NodoDoble(d,null,p));

p=p.getAnt();

En caso que la variable p sea null, habría que validar antes de hacer el proceso de cambio, de manera que si p es diferente de null, se realice el código de arriba; si no, se le asigne a la variable p un nuevo NodoDoble.

 

 

Inserción al final: después del último

En una lista simple:

En este fragmento de código aparece una nueva variable (q) que irá cambiando de posición para apuntar al nodo del final, lo que ayudará con el proceso de inserción:

If(p!=null){

      q.setSig(new Nodo(d,null);

      q=q.getSig();

}else{

      P=q=new Nodo(d,null);

}

 

En una lista doble:

 

Se debe cambiar la dirección a la que apunta q para que apunte a la del nuevo nodo, y la dirección siguiente del último nodo dejará de ser null:

If(q!=null){

      q.setSig(new NodoDoble(d,q,null));

      q=q.getSig();

}else{

      P=q=new NodoDoble(d,null,null);

}

 

 

Inserción antes de: un dato específico

En una lista simple:

En primer lugar se pide el dato antes del cual se va a insertar; luego se realiza un proceso de búsqueda mediante el cual se extrae la posición del nodo que contiene el dato; y, posteriormente, se agrega el nuevo nodo. Aquí, aparece una nueva variable (s), la cual tendrá la posición anterior a r o, lo que es lo mismo, a el nodo que contiene el dato buscado.

Int x=leer.entero(“Digite dato a buscar”);

Nodo r=p;

Nodo s=null;

While(r!=null && r.getDato()!=x){

      s=r;

      r=r.getSig();

}

If(r==null){

Mensaje(“Dato no encontrado”);

}else{

       /*Aquí se puede hacer cualquier tipo de gestión con el dato encontrado, como, modificar, eliminar, mostrar… */

}

If(r!=null){

      If(s!=null){

      s.setSig(new Nodo(d,r);

      }else{

            P=new Nodo(d,p);

      }

}else{

      Mensaje(“El dato no exite”);

}

 

 

Inserción después de: un dato específico

En una lista simple:

Para realizar este proceso de inserción después de encontrar un dato determinado, se debe realizar el proceso de búsqueda, pero esta vez, sin tener en cuenta la variable s, es decir:

Int x=leer.entero(“Digite dato a buscar”);

Nodo r=p;

While(r!=null && r.getDato()!=x){

      r=r.getSig();

}

If(r!=null){

      r.setSig(new Nodo(d,r.getSig());

      if(r==q){

            q=q.getSig();

      }

}else{

      Mensaje(“Error al insertar”);

}

Eliminar: al inicio

En una lista simple:

Simplemente, la variable p deja de referenciar el primer nodo, para apuntar al siguiente.

If(p!=null){

      If(p!=q){

            P=p.getSig();

      }else{

            P=q=null;

      }

}else{

      Mensaje(“Lista vacia”);

}

 
Imagen de Amaury Enrique Puello Tinoco
de Amaury Enrique Puello Tinoco - viernes, 7 de marzo de 2014, 18:13
Todo el mundo

El objetivo de la clase del 4 de marzo fue resolver el primer laboratorio de listas enlazadas, en el cual se consignó una estructura dinámica, y algunas operaciones para realizar sobre ella.

Esta lista contaba con 5 partes:

Cuatro (4) espacios para almacenar direcciones en memoria (dirección superior, inferior, derecha e izquierda) de otros objetos de tipo NodoMultiple y una parte para almacenar datos.

A continuación, el diagrama:

 

La clase que creará cada uno de estos nodos múltiples y el código que contiene la solución, se anexarán con el nombre NodoMultiple y Principal, respectivamente.

 
Todo el mundo
Una lista enlazada es una estructura dinámica compuesta por nodos conectados que permite almacenar datos de forma ordenada. Dato Enlace Cada uno de los elementos apunta al siguiente excepto el último que tiene como valor de enlace “null” (excepto en las circulares). Las listas enlazadas están clasificadas en:  Simples: contiene dos valores, el valor actual del nodo y el enlace al siguiente nodo (puede apuntar a null, o a la lista vacía si es el último).  Doblemente enlazadas: es una lista de dos vías en la que cada nodo tiene dos enlaces, uno apunta al nodo anterior o a null si es el primero, y otro apunta al nodo siguiente o a null si es el último.  Circulares: es una lista sin comienzo y sin fin, pues el primer y último nodo están unidos. La parte siguiente del último nodo apunta al primer nodo.  Doblemente circular: es una lista sin comienzo y sin fin. Cada nodo contiene dos enlaces, donde el enlace anterior del primero apunta al último nodo, y el enlace siguiente del último nodo apunta al primer nodo. Con las listas enlazadas pueden realizarse las siguientes operaciones:  Recorrer  Insertar  Eliminar  Buscar  Ordenar Tanto la inserción como la eliminación de datos pueden realizarse al inicio, al final, antes de y después de un nodo. En este resumen se realizarán operaciones con listas simples y doblemente enlazadas.
 
Imagen de EDGAR EGDUMAR CHAVEZ TRASLAVINA
de EDGAR EGDUMAR CHAVEZ TRASLAVINA - jueves, 6 de marzo de 2014, 17:29
Todo el mundo

 

 

 

 

 

 

 

 

 

 

 

 

 
Imagen de JHON MARIO MURILLO CORDOBA
de JHON MARIO MURILLO CORDOBA - jueves, 6 de marzo de 2014, 17:22
Todo el mundo

nodo multiple

24-02-2014

CLASE NODO MULTIPLE EN JAVA

public class Nodomultiple {
    private Object dato;
    private Nodomultiple sup;
    private Nodomultiple inf;
    private Nodomultiple izq;
    private Nodomultiple der;

public Nodomultiple() {
}

public Nodomultiple(Object dato, Nodomultiple sup, Nodomultiple inf, Nodomultiple izq, Nodomultiple der) {
      this.dato = dato;
      this.sup = sup;
      this.inf = inf;
      this.izq = izq;
      this.der = der;
}

public Object getDato() {
       return dato;
}

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

public Nodomultiple getSup() {
        return sup;
}

public void setSup(Nodomultiple sup) {
       this.sup = sup;
}

public Nodomultiple getInf() {
      return inf;
}

public void setInf(Nodomultiple inf) {
     this.inf = inf;
}

public Nodomultiple getIzq() {
      return izq;
}

public void setIzq(Nodomultiple izq) {
     this.izq = izq;
}

public Nodomultiple getDer() {
     return der;
}

public void setDer(Nodomultiple der) {
     this.der = der;
}


}

  • En una lista simple circular hay que tener porque null y puede convertirse en un ciclo infinito.
  • En el diagrama de java, Objetc se encuentra por encima  de todas las clases (String, Integer, Fraccionario, etc).
  • Object es la clase madre, implicitamente todas heredan de ella(extends Objetc).
  • Object no es compatible con las variables primitivas.

Nodomultiple x;

  x=new Nodomultiple();

  x.setDato(new Fraccionario());

  x.getDato.setNum(1);ERROR

Metodos de la clase Objetc 

  • Equals();
  • ToString();   

Casting

f=(Fraccionario)x.getDato();

f.setNum(1);

Clase Mejorada

public class Nodomultiple <T>{
    private <T> dato;
    private Nodomultiple sup;
    private Nodomultiple inf;
    private Nodomultiple izq;
    private Nodomultiple der;

//CONSTRUTORES

//GETTERS  && SETTERS

}

Nodomultiple <Fraccionario>x;

  x=new Nodomultiple();

  x.setDato(new Fraccionario());

  x.getDato.setNum(1);

26-02-2014 LABORATORIO NODO MULTIPLE 

 

4-03-2014

DESARROLLO DEL LABORATORIO EN ESPAÑOL 26-02-2014

CLASE PRINCIPAL EN LENGUAJE ESPAÑOL

CICLO(for, while, do while)

  Leer.dato

    sino se han creado nodos entonces.

          x,y     toman la direccion del primer nodo (dato, sup, inf, izq, der).

    si hay nodos creados.

         la derecha  de   y    apunta al nuevo nodo(dato, sup, inf, izq, y).

         pasar a    y      al nodo  de la derecha.

   finsi

FIN CICLO

poner   y   donde  esta     x.

CICLO

    Leer.dato

       la parte de    y    apunta un  nuevo nodo  (dato, sup, inf, izq, der).

           si    z   no es null.

               la parte  derecha de z pasa al nodo de la derecha.

          sino

               z    apunta a la parte inferior de     y.

          finsi

              y pasa al nodo de la derecha.

FIN CICLO 

CORRECION DEL LABORATORIO EN JAVA 26-02-2014

CLASE NODO MULTIPLE EN JAVA

public class Nodomultiple {
    private Object dato;
    private Nodomultiple sup;
    private Nodomultiple inf;
    private Nodomultiple izq;
    private Nodomultiple der;

public Nodomultiple() {
}

public Nodomultiple(Object dato, Nodomultiple sup, Nodomultiple inf, Nodomultiple izq, Nodomultiple der) {
      this.dato = dato;
      this.sup = sup;
      this.inf = inf;
      this.izq = izq;
      this.der = der;
}

public Object getDato() {
       return dato;
}

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

public Nodomultiple getSup() {
        return sup;
}

public void setSup(Nodomultiple sup) {
       this.sup = sup;
}

public Nodomultiple getInf() {
      return inf;
}

public void setInf(Nodomultiple inf) {
     this.inf = inf;
}

public Nodomultiple getIzq() {
      return izq;
}

public void setIzq(Nodomultiple izq) {
     this.izq = izq;
}

public Nodomultiple getDer() {
     return der;
}

public void setDer(Nodomultiple der) {
     this.der = der;
}


}

CLASE PRINCIPAL EN JAVA


public static void main(String[] args) {
   Nodomultiple p;
   Nodomultiple q;
   Nodomultiple s;
   p=q=s=null;
   int num;
  String cad;
      for (int i=1;i<=3;i++){
             num= Leer.entero("DIGITE NUMERO");
                 if(p==null){
                      q= p = new Nodomultiple(num,null,null,null,null);
                   }else{
                       p.setDer(new Nodomultiple (num,null,null,null,q));
                       q=q.getDer();
                   }
}
   q=p;
   for (int i=1;i<=3;i++){
      cad=Leer.cadena("DIGITE DATO");
      q.setInf(new Nodomultiple(cad , q,null,null,s));
         if(s!=null){
            s.setDer(q.getInf());
         }else{
            s=q.getInf();
         }
            q=q.getDer();
 }
   q=p;
     while(q!=null){
       s=q;
          while(s!=null){
               System.out.print(s.getDato());
               s=s.getDer();
}
              System.out.println();
              q=q.getInf();
}

}

}

  • Para mostrar una variable envolvente referenciada por un Objetc  no nesesita casting.
  • Solo se utiliza el casting para realizar una operacion aritmetica.

 NODO

05-03-2014

OPERACIONES DE LISTAS ENLAZADAS

 

 

 

 

 

 

 

 

 
Imagen de JESSICA  PAOLA LEDESMA  FIGUEROA
de JESSICA PAOLA LEDESMA FIGUEROA - jueves, 6 de marzo de 2014, 14:19
Todo el mundo

Los tipos de listas enlazadas dependen de los nodos y los nodos dependen del usuario (programador).

Trabajarempos con dos simples y enlazadas dobles:

nodos 

En las lista para decir que un nodo tiene la direccion del siguiente, se representa con una flecha, asi:

rep  

Ahora veamos esto como memoria:

memoria 

Algunas de Las ventajas de las listas son:

  1. si empiezan en el nodo 3, el primero seria 3, y se perderia el primero que es 7.
  2. no se pierde el objeto.
  3. no se pierde ningun nodo porque se regresan.
  4. se implementan en lo que queramos segun el usuario.

Y algunas de las desventajas son:

  1. si hago un ciclo nunca va a dejar de par porque no encuentra el null X.
  2. hay que tener cuidado con los ciclos infinitos porque no paran.

Este es el codigo java para un Nodo multiple: 

public class NodoMultiple {

private int dato;

private NodoMultiple sup;

private NodoMultiple der;

private NodoMultiple inf;

private NodoMultiple izq;

Public NodoMultiple ( ); 

//Creamos metodos get y set y listo.

}

Para generalizar una clase y que reciba cualquier atributo se coloca object --> clase madre de java, las demas clases heredan de object.

Puede almacenar direcciones de todos los objetos, se convierte en un contenedor generico.

No es compatible con datos primitivos como int, etc.

Cuando pongo un punto de tipo object, solo puedo poner metodos de esa clase(object)

object= equals( ), to String ( ), ...

ult 

codigo (con casting)

NodoMultiple X;

x = new NodoMultiple ( );

x.setDato(new Fraccionario( ));

x.getDato( ).setNum(1); //aqui hay un error porque en el get dato retorna una direccion objecto.

 

Fraccionario f;

f = (Fraccionario) x.getDato( );

f.setNum(1);

Codigo

public class NodoMultiple <T>{

private T dato;

private NodoMultiple sup;

-----

------

-------

}

NodoMultiple<Fraccionario> x;

x= new NodoMultiple ( );

x.setDato( new Fraccionario( ));

x.getDato( ).setNum (1);

 
Imagen de JESSICA  PAOLA LEDESMA  FIGUEROA
de JESSICA PAOLA LEDESMA FIGUEROA - jueves, 6 de marzo de 2014, 13:01
Todo el mundo

Las listas enlazadas son estructuras dinamicas que van creciendo y tambien pueden decrecer, cosa que nno podemos hacer con un arreglo.

Cada objeto que conforma la lista es llamado nodo, se pueden eliminar objetos de una lista cosa que no podemos hacer con un arreglo.

img 

implementamos en un codigo java la estructura de la grafica:

Nodo p = null;

Nodo q = null;

p=new Nodo ( );

q=p;

p.setDato (7);

p = new Nodo( );

q.setSig(p);

p.setDato(4);

p.setSig(new Nodo ( ));

p=p.getSig( );

p.setDato (9);

p.setSig (new Nodo( ));

p=p.getSig( );

p.setDato(3);

p.setSig(null);

esto mismo que acabamos de hacer se puede hacer de una manera mas corta .

creamos 2 nuevas variables( d -i ).

Nodo p= null;

Nodo q = null;

int d;

for (int i=1; i<= 4; i++){

d=Leer.entero("Digite dato:");

if (q==null){

   p=q=new Nodo (d, null);

}else{

p.setSig (new Nodo (d, null);

p.getSig( );

}

}

El siguiente codigo, muestra en pantalla o recorre:

p=q;

while( p! = null){

System.out.println(p.getDato( ));

p = p.getSig( );

}

  • un metodo va despues de un punto y lleva parentesis.
  • metodo static: son los que se usan sin instanciar.

 

 

 
Imagen de Fredys Manuel Barrios Del Rio
de Fredys Manuel Barrios Del Rio - jueves, 6 de marzo de 2014, 11:48
Todo el mundo

Las listas de tipo simple circular tienen la ventaja que si se cambia el puntero de la variable por el de otro objeto, el objeto que al cual apuntaba dicha variable no se pierde, lo que si sucede en las listas simples.

 

Clase Nodo multiple

 

Public class NodoMultiple{

private Object dato;

private Nodomultiple sup;

private Nodomultiple inf;

private Nodomultiple der;

private Nodomultiple izq;

 

public NodoMultiple() {
}

public NodoMultiple(Object dato, NodoMultiple Sup, NodoMultiple Inf, NodoMultiple Der, NodoMultiple Izq) {
this.dato = dato;
this.Sup = Sup;
this.Inf = Inf;
this.Der = Der;
this.Izq = Izq;
}

public Object getDato() {
return dato;
}

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

public NodoMultiple getSup() {
return Sup;
}

public void setSup(NodoMultiple Sup) {
this.Sup = Sup;
}

public NodoMultiple getInf() {
return Inf;
}

public void setInf(NodoMultiple Inf) {
this.Inf = Inf;
}

public NodoMultiple getDer() {
return Der;
}

public void setDer(NodoMultiple Der) {
this.Der = Der;
}

public NodoMultiple getIzq() {
return Izq;
}

public void setIzq(NodoMultiple Izq) {
this.Izq = Izq;
}

}

public class principal{

NodoMultiple x;

x= new NodoMultiple();

x.setDato(7, null, null, null, null);

}

 
Todo el mundo

Esta clase se estuvo retro alimentando lo del laboraotorio ya que muchas personas no sabias como hacerlo, ni tampoco por donde empezar, entonces el profesor empezo a guiarnos de como podiamos resolverlo con Object utilizando 3 variables la general que es x, y que es la se desplaza en los 3 primeros nodos y z la que es utilizada en los  3 nodos de abajo. Se explico que debian utilizarse tres ciclos for uno para recorrer el de arriba y el otro el de abajo y para imprimirlo podiamos utilizar un while, en mi casa no alcanze a terminarlo y se dejo que el habiamos echo en el laboratorio que cumplia el diagrama puesto y funcionaba con las clases genericas.

 
Página: ()  1 ...  7  8  9  10  11  12  13  14  15  16  17  18  19  20  21  22  23  24 ...73   ()