martes, 25 de marzo de 2014

11/03/2014

ELIMINACIÓN:

al final:
if (p! = q) {
Nodo R = p;
while (r.getsig (!) = q) {
R = r.getsig ();
r.setsig (null);
                                                                                                q = r;}
                                                                                                           else 
                                                                                                            p = q = null;


espesificamente:





if(r!= null ){
if(s!=null){
s.setsig(r.setsig())
if(r==q){
q=s;}
} else{
if(p==q){
p=q=null;}
 else{p=p.getsig();}
}
 ele
S.O.P("dato no encontrado");

clase 05/03/2014

OPERACIONES ENTRE LISTAS:

Inserción: Al inicio, al final, los los los los antes y despues de.

AL INICIO:
 simple:

p = new Nodo (d, p);





doble:
if (p! = null) {
p.setAnt (nueva NodoDoble (d, null, p));
p = p.getAnt ();
}
Más
      p = new NodoDoble (d, null, null);


AL FINAL:


simple:


if (p! = null) {
q.setSig (nuevo Nodo (d, null));
q = q.getSig ();}

                                                                                     Más
                                                                                                p = q = new nodo (d, null);


doble:
 if (q! = null) {
 q.setSig (nueva NodoDoble (d, q, null));
q = q.getSig ();
}
                                                                                    Otra p = q = new NodoDoble (d, null, null);



ANTES DE:

simple:

 busqueda:
 int x = leer.enterro ("dato");
Nodo r = p, Nodo s = null;
while (R! = null && r, getDato ()! = X) {
s = r, r = r, getSig ();}
if (r == nul) {SOP ("" dato no encontrado);}



if (R! = null) {
if (s! = null) {
s, setSig (nuevo Nodo (d, r));
}
Más
p = new Nodo (d, p);
}

DESPUES DE:
simple
if (R! = null) {
r.setsig (nuevo Nodo (d, r.getsig ()));
Si (R == q) {
q = q.getSig ();
} Else
          SOP ("Error al insertar");




ELIMINAR: Al inicio, al final, espesificamente.

al inicio:
simple:






if (p! = null) {
if (p! = q) {
p = p.getSig ();
} Else {p = q = null}
} Else
SOP ("Lista vascia");

lunes, 3 de marzo de 2014

clase 25/02/2014


CLASE REPASO

-Un object tiene la capacidad de guardar cualquier tipo de dato
-la clase object tiene unos métodos (to string(), equal())
-los objetos de la clase object solo reconoce los métodos de dicha clase
- la clase nodo no tiene datos específicos

................................................................................................................................................................

OPERACIONES EN LISTAS ENLAZADAS:

INSERTAR:     inicio
                        final
                        antes
                        después

RECORRER:  para consultar
                       para modificar
                       mostrar todos los elementos

ELIMINAR:  al inicio
                      al final
                     específicamente


clase 08/02/2014


                                                       DIFERENCIAS 


ESTRUCTURA DINÁMICAS                                          ESTRUCTURAS ESTÁTICAS                          
-  No tiene un tamaño definido.                                          -Su tamaño es definido antes de ejecutar
                                                                                            el programa
-  Al no tener un tamaño definido
   su espacio en memoria depende                                      - su velocidad para acceder  a los datos es
   de la información.                                                              alta

-  Su espacio en memoria se reserva                                  -  No se puede modificar espacio en memoria
    en tiempo de ejecución.                                                      una vez que ente en tiempo de ejecución

- Sus datos se presentan dispersos                                      - desperdicio de memoria cuando no se utiliza  
  por lo tanto esto afecta el                                                      en su  totalidad el tamaño declarado
 rendimiento

- Es difícil implementar en un programa                               -  No es muy bueno para manejar grandes
                                                                                              cantidades de datos.


LISTAS ENLAZADAS

- son una secuencia de nodos , donde un  nodo se enlaza a otro mediante un puntero
- un nodo esta compuesto por un campo llamado dato y otro campo la cual tiene la dirección del siguiente nodo
-el recorrido de una lista enlazada es lento
-si se pierde la dirección del primer nodo en una lista enlazada se pierde todo
 
EJERCICIO

- realiza el código para desarrollar la estructura dinámica  de la gráfica

public class X{
 private int a;
private X b;
}
public getX(){
 returnX;
}
public setX(X b){
 this.b=b;
}


 public class principal{
 public static void main(String arg [])

Xx=new X();
x.setA(7);
x.setB(new x());
x.getB().setA(4);
x.getB().setB(new x());
x.getB().getB().setA(9);
x.getB().getB().setB("null");
}
}

UNA FORMA MAS FACIL!!!

                                                      public class principal{

                                                         public sttic void main (String arg [])
                                                           Xx= null;
                                                           Xy= null;
                                                      for( int i=1 ; i<= 3; i++){
                                                              if(x==null){
                                                                 x=y=newX();
                                                                                         }
                                                           else
                                                                    y.setB(new x());
                                                                         y=y.getB();
                                                                                            }
                                                                       leer.enterno(d);
                                                                        y.setA(d);
                                                                       y.setB(null);
                                                                     y=x
                                                                 while(y!== null){
                                                               S.O.P(y.getA());
                                                               y=y.getB();

                                                                     }
                                                                        }


- En una estructura estatica hay acceso directo para acceder a un arreglo  en cambio en la dinamica  hay que ir  de nodo en nodo para llegar al nodo deseado.

TIPOS DE LISTAS ENLAZADAS
- La base de cualquier lista es un objeto nodo
-el nodo puede tener muchas formas:

SIMPLE:                                      - la flecha representa la direccion del nodo siguiente
                               




   simple circular: