domingo, 8 de junio de 2014

RECURSIVIDAD



 RECURSIVIDAD.


Es una propiedad de las  funciones (metodos) de auto llamarse, son una alternativa  de los procesos iterativos.
 no es una estructura de datos, sino que es una técnica de programación que nos permite que un bloque de instrucciones se ejecute n veces.
UTILIDAD :
Cuando la solución de un problema se puede expresar de en términos  de menor complejidad.


 Ventajas

  • Menos lineas de código
  • Refleja el problema con mas simplicidad
  • produce un programa mas fácil de entender y depurar 

Desventajas
  • Tiempo de procesador
  • Espacio en memoria,consume memoria principal
conclusión
Se puede decir que la recursividad es una técnica de programación bastante útil,Una vez que uno se acostumbra a su uso, se comprueba que la recursión es una forma mucho más natural que la iteración de expresar un gran número de funciones y procedimientos.

domingo, 4 de mayo de 2014

01/04/2104


PILA EN JAVA


Una Pila en palabras sencillas es un lugar donde se almacenan datos, al igual que en un Array, pero una Pila tiene una filosofía de entrada y salida de datos, esta filosofía es la LIFO (Last In First Out, en español, ultimo en entrar, primero en salir). Esta estructura de datos tiene muchas aplicaciones debido a su simplicidad.  
Una pila al ser una lista puede almacenar en el campo de información cualquier tipo de valor (int, char, float, vector de caracteres, un objeto, etc)

UTILIDAD 

 las pila en general son muy útiles en cuanto a la  recuperación de datos en  una actividad no terminada o retroceder en  un proceso para terminar una actividad no completada

APLICACIÓN

  este tipo de estructura de dato  lineal  son aplicadas generalmente en procesos de llamados  a subprogramas en el Sistema Operativo; también se aplican en el proceso de evaluar expresiones artísticas igualmente en comprobar la pariedad de las expresiones es decir que los paréntesis estén abiertos y cerrados en un orden lógico y bien balanceados.

OPERACIONES 

Los métodos principales de una Pila son:
Vacia()
retorna verdad o falso si la Pila esta vacía, es decir que no tiene ningún elemento, retorna unboolean.

poner(int a)
adiciona el elemento a en la Pila.

quitar()
elimina el elemento de la cima de la pila.


 llena()
retorna cuantos elementos tenemos en la Pila.

cima()
retorna el elemento de la cima sin eliminarlo de la Pila.


Siguiendo la filosofía se adicionar elementos apilando uno debajo de otro.

Pilas apilar
poner(int 7)
Para eliminar un elemento, se extrae o desapila un elemento por la cima.

pilas desapilar
quitar()





otro método importante en la pila es vicia()  la cual indica si la pila contiene o no elementos 


 




 Indicando si es posible o no agregar nuevos elementos , nos encontramos con llena






También es importante saber que dentro de Java tenemos la clase Stack la cual  tiene todos los anteriores métodos ya señalados

CONCLUSIÓN:

la pila  se dedica al almacenamiento  y manipulación de datos , sin que importe el tipo de dato (a nivel conceptual) que sean.
 su funcionalidad es siempre la misma, independiente  de como se vaya a utilizar. esta funcinalidad  cumple con la filosofia lifo y es justamente lo que la define como una pila ; por eso las pila poseen un unico punto  de acceso y salida para sus elementos  y solo vemos el ultimo insertado .


 



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:




domingo, 16 de febrero de 2014

clase 12/02/ 2014

 EJERCICIO
 realizar el codigo


X x= new X();
x.setA(new z());
x.set(7);
x.getA().setE((new y());
x.getA().setF(3.5);
x.getA().getE().setC("c");
x.getA().getE().setD(true);

para cambiar a d pero sin utlizar la ruta de x

Y y
= x.getA().getE();
y= setD(false);


 CLASES AUTO REFERENCIALES (listas enlazadas)

-  los arreglos son estructuras de datos
-las estructuras estaticas son las que no se le puede modificar el tamaño despues ejecutarlas
- en java un int ocupa 4 byte de memoria


-Un vector no se puede dividir en partes por que sus elementos van de forma continua.
-las listas estaticas son arreglos


LISTAS DINAMICAS



x,getA() ; => 7 
x.getB().getA(); => 4
x.getB().getB().getA(); => 9 
______________________________

X y= x;
y.getA(); => 7,4,9 
y=y.getB();







clase 11/02/04

CLASES CON ATRIBUTOS DE CLASE

public classs A{
private B b;

public A(B b){
this.b=b;

}
pblic A(){
b= null;
}

public getB(){

return b;
 }
 public setB (Bb){
 this.b=b ; 
}
}

public class B{

private C c; 

public B(){

c= null;
}

public B (Cc){

this.c=c;
}

public void setC(Cc){
this.c=c;

}

public getC(){

return C;
}

}

public class C{

private int i;
public C(){

i=0;
}

public c (int i ) {

this.i= i ;
}

public void setI(int i) {

this.i=i;
}
public  int getI(){

return i;
}



A a= new A();
B b=new b();
a.setB(b);
C c= new C();
a.getB().getC().setI(7);
1010.3020.7090.1790


viernes, 7 de febrero de 2014

CONTINUACION DE LA CLASE DEL 04/02/2014 (05/02/2014)


Instruccion java

fraccionario F;
String S= "xyz";
Int V[]={1,2,3};
 int = 3;
F= 1/4; =o  ----> error de sintaxis
F= new fraccionario(1,4);

  • Todo lo que es primitivo se maneja como estático
  • Las variables  de clase también son llamadas variables de referencia 
  • Las variables de tipo primitivo se manejan en la parte de memoria estática
  • Los objetos se manejan en la parte dinámica de la memoria 
  • El operador new crea el objeto, define la dirección del objeto 
  •  Para utilizar el operador new se utiliza 2 sintaxis :
    • Nombre_Clase Nombre_Variable;
    • Nombre_Variable= new Nombre_Clase();
    • Nombre_Clase Nombre_Variable= new Nombre_Clase();
  • Cuando asignamos objetos , lo que realmente  estamos asignando  son las direcciones  de memoria  donde están definidos los objetos 
  • Para acceder a los componentes de un objeto debemos utilizar el operador punto(.)

Analice las siguientes instrucciones java y grafique variable y objeto en la memoria 

Fraccioanrio F1, F2, F3;
F1=new fracionario (1,2);
F2= new fracionario (2,3);
F3=F1;
F1=F2;
F2=F3;
F1.setNum(3);
F2.setDem(4);
F3.setNum(5);




















Intruccion java 

Fraccionario Fs[];
Fs= new Fraccioanrio [5];
Fs[1]= new Fraccionario(0,1);
Fs[1]. setNum(1);
Fs[1].setDen(2);




PRESENTACION Y REGLAS DE LA CLASE ! (04/02/2014)


Profesor : Juan Jose Puello Fuentes                
 Horario : los martes  de 6:45 a8:15 AM
              los miércoles  de 8:15 a 10:30 AM

  En el 1er y 2do corte se evalúa :   la asistencia puntual a 10%
                                                      El blog 15%
                                                      El laboratorio 10%
                                                      Quiz 10%
                                                      Trabajos de lecto-escritura 10%
                                                       El foro 5%
                                                       Examen parcial 40%

En el 3cer corte se evalúa:               Reflexion 10%
                                                       blog 15%
                                                       Quiz 10%
                                                        Exposición 15%
                                                        Trabajo 10%
                                                        Laboratorio 10%
                                                        Examen final  : puede valer : 50%
                                                                                                    40%
                                                                                                    30%


                                                     
INSTRUCCIÓN JAVA

Fraccionario f;
String S="xyz";
int V []= {1,2,3};


  • En java los arreglos son objetos
  • la comillas ("") también crean objetos 

  
 En esta clase  el profesor realizo su presentación y su sus reglas para las clase como también  un repaso sobre la declaración de objetos de una clase.