ARBOLES

Es una estructura de datos no lineal que permite organizar datos de una manera jerarquica es decir de mayor a menor.

Clasificación

Binarios 

Ejemplo de arboles binarios 

Que son los arboles binarios 

Un arbol binario es una estructura de datos en la cual cada nodo tiene un hijo izquierdo y otro derecho.

Tipos de arboles binarios

Completos:

Se define un árbol binario completo como un arbol el que todos sus nodos, excepto los 

de último nivel, tienen dos hijos; el subárbol izquierdo y el subárbol derecho

Balanceados:La diferencia en altura para todos los arboles es de ceros o unos.

Degenerados: Todos los nodos tiene un decendiente menos la hoja

Lleno: es cuando todos los niveles tienen un máximo de nodos 2^h-1; donde h = Altura del árbol. Por ejemplo:

 Actividades que se realizan para recorrer un árbol binario:

1- Visitar raíz

2- Recorrer subárbol izquierdo

3- Recorrer subárbol derecho y a continuación les presentare los recorridos existentes mas utilizados:

- Pre Orden == 1, 2, 3. 2

- InOrden == 2, 1, 3. 3

- Pos Orden == 2, 3, 1.

Opinion: Los arboles son estructuras de datos no lineales que tambien permiten organizar datos dentro del programa son bastante utulizan utilizan frecuentemente para representar conjuntos de datos cuyos elementos se identifican por una clave única. 

RECURSIVIDAD

Es una propiedad de métodos y funciones para auto llamarse. Son una alternativa para procesos iterativos (for,while,do while).

Utilidad: cuando el proceso iterativo es muy complejo.
Aplicación: Recorrido de arboles.

Recursividad vs iteracion
ventajas y desventajas
Implementacion: El sistema operativo usa el mismo principio de llamado de sub programas  (pilas)

n!=nx(n-1)!
5!= 5*4i/24 120
4!=4*3!/6
3!=3*2!/2
2!=2*1!/1
1!=1*0!/1
0!=1
La recursividad se caracteriza por ser un metodo, tener un ciclo de control y utilizar el mismo metodo en el metodo por Ej:

Opinion:
en mi opinion a cerca de este tema es que es muy utilizado en procesos iterativos bastante complejos y tiende a consumir bastante recurso en memoria por ende sera mejor utilizar en caso de que sea necesario.

Colas
¿Que es una cola?
La cola en estructura de datos, es una regla que restringue las operaciones en las estructuras lineales como lo son los arreglos o listas enlazadas). Tiene una estructura FIFO (First in first out), es decir el primero en entrar es en primero en salir. 
Funcioamiento de una cola 
1.

2.

3.

4.

5.

¿Como se implementa?

- Arreglos

- Nodos/Listas (Simples y Dobles), entre otras.

Las colas, como otras estructuras contienen operaciones basicas, que al igual que las pilas son:

poner y quitar. Y auxiliares como: vacia y llena.

Metodos: Teniendo en cuenta que se implemente en un vector y este esta creado... Los metodos son:

Poner{ fin++; V[fin] = dato;

Quitar{ dato = V[frente]; frente++;

Pilas 
¿Que es una pila?
Es una regla que se aplica a una estructura lineal simple (vector, lista) obligar que las operaciones se comporten de tal manera que el ultimo elemento en poner es el primero en quitar (LIFO VEPF.

-Utilidad

• Retroceder un proceso
• Regresar total o paralelamente al punto de partida

-Aplicaciones 

• Sistema operativo; llamada a subprogramas.
• Compiladores; evaluacion de expresiones aritmeticas.

-Operaciones 

• Poner
• Quitar
• Cima
• Vacia
• Llena

-Implementacion 

1.Vectores

Tope 1= el indice donde esta el ultimo elemento 

Max 5= cantidad que soporta el vector 

-Operaciones 

• Poner -Poner ,Tope ++; v {tope}=dato 
• Quitar-dato =v{tope}; Tope --;
• Cima { dato=v tope;
• Vacia {tope==-1;
• Llena {tope== max-1;

-Aplicaciones de pila 

Expresiones 

Infijas a+b+c---> Normalmente conocidas 

Prefijas +a*bc--->Operadores antes de operandos 

Posfijas: abc*+---> Operadores despues de operandos 

Infijos 

(a+b)* c´(1/2)

a+b*c´1/2

Prefijas

 (a+b)*c´(1/2)

+ab*c´/12

+ab*´c/12

*ab´c/12

Posfijas 

(a+b) *c´(1/2)

ab+*c´12/

ab+*c12/

ab+c12/´*

Operaciones entre listas enlazadas

Incercion al inicio 

Metodo: p = new Nodo (x, p); Donde p es la bariable que apunta al nodo, x el dato a ingresar y p la direccion en caso de que la direccion sea null, debe colocarse de esta manera: p = new Nodo (x, null);

Ejemplo insercion al inicio doble

Nota: primero se valida si p es diferente a null, siendo asi se procede a cambiar la direccion anterior, y se agrega un nuevo nodo. Luego, dejamos a p apuntando a ese nuevo nodo creado. Sino se cumple tal condicion signica que p si esta null por lo tanto se crea un nuevo nodo.

Ejemplo insercion al final

Nota: se valida si p es diferente a null y siendo asi, se procede a cambiar la direccion siguiente de q, asignandole un nuevo... Por lo tanto q quedaria apuntando a ese nuevo nodo, sino se cumple esta condicion se crea un nuevo nodo.

Ejemplo insercion al final doble

Nota: se validad si p es diferente a null, siendo asi, se procede a cambiar la direccion anterior al primer nodo que apunta, asignandole a este un uevo nodo, luego se procede a pasar la direccion del nuevo nodo a p. En caso de que no se cumpla la condicion se crea un nuevo nodo.

Ejemplo Codigo Buscar

Ejemplo insercion antes de

Operaciones entre listas enlazadas

Operaciones entre listas enlazadas

Estas listas enlazadas, como todo contiene unas operaciones basicas, las cuales son:
- Insertar y eliminar que se compone por:
* Insercion al inicio, al final, antes de y despues de.
- Buscar que se compone de:
* Consultar, modificar, eliminar.
- Ordenar

if (p!=null){
p.setAnt (new nodoDoble(d,null,p));
p=p.getAnt();

} else{

P=new nodoDoble(d,null,null);

}

Simple

Si (P!=null){
q.setsig (new nodo (d,null));
q=q.setsig();
}else{
p=q newNodo (d,null);

Tipos de listas enlazadas

Tipos de listas enlazadas 

base de listas: objeto nodo

tipo simple

Variables                                    Objetos 

X 1010                                         1010

                                                      nodo   

y 2020                                          dato 7

                                                     sig 2020

                                                    2020

                                                     nodo

                                                     dato 4

                                                     sig 3030

                                                     3030

                                                      nodo

                                                      dato 4

                                                      sig 2010

                              

Listas enlazadas

Listas enlazadas 

En esta clase el profesor hizo ejercicios de listas enlazadas a continuacion los ejercicios resueltos 

Xx =null

Xy =null

int d;

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

if (x==null){

X=Y =neww x();

}else{

y.setB(new x());

y=y.getB();

}

leer.entero(d);

y.setA (d);

Memoria

Variables

X 

d

i

Y

Objetos 

1010

   X

a 7

b 1020

1020

   x

a 3

b 1050

1050

   x

a 4

b null

Y=X
while(Y!=null){
s.o.p(Y.getA()); ------>7,3,4
Y=y.getB();

Listas estaticas y arreglos

Listas estáticas (arreglos)
Clases autorreferenciadas (listas enlazadas)
En esta clase el docente dio una introducción a lo que son listas enlazadas también nos enseño lo referente a nodos simples dobles y múltiples a continuación lo dado en clase
                                                      1010 1014 1018 1026 1030
V 1010                                           3      7       9       4        5       cada dato y su dirección en memoria
v {3} =4                                         2010
1010+3*4= 1022                           8
           int/bytes
X 1010
V 2070
Y 3010

V{5}=8
1010+5*4=1030                          

Tipos de memoria

Tipos de memorias
En esta clase el profesor siguió explicando todo sobre memorias e hizo mas ejemplos sobre estas
aqui los anotado en clase.

X 3020                                   3080        metodos
                                                X            set A ()
                                              a 6090       get A ()

                                              b 7            set B ()

                                                              get B ()

  

Y                                           6090

                                                Z       set E ()

                                              e 4050  get E ()

                                              f 3.5    set F ()

                                                         get F ()

Z                                            Y 

                                              c C;

                                              d true

Xx=new x ();

x.set A (new z ();

x.setB (7);

x.getA ().setE (new y ());

x.getA().setF (3.5)

x.getA().getE().set C ("c");
x.getA().getE().setD (true);
Yy=x.getA().getA().getE();
y.setD(False)

     

                                                                                                

Memoria estatica y dinamica

Memoria estática y dinámica
en esta clase el profesor explico como funcionaban estos dos tipos de memorias también puso ejemplos y mando a estudiantes a que los realizaran en el tablero a continuación lo dado y apuntado en dicha clase.

Memoria estática                                 memoria dinámica
f1 2020                                                   1,2
f2 1010                                                   2,3
f3 1010                                               fraccionario 1010
                                                                 5
                                                                 4
                                                              3 2020<--------- Dirección en memoria
                                                              3
                                                         
int i= null;
instrucciones java                                        Memoria
fraccionario fs [];                                             Estatica                      dinamica     
fs= new fraccionario  [5];                                       fs 1010                           1010
fs [1].setNum(1);                                                                                           0 dir 
fs[1]. setDem (2);                                                                                          1 dir
                                                                                                                       2 dir 
                                                                                                                       3 dir 
                                                                                                                       4 dir   

Instrucciones Java

Instrucciones java y memoria estática y dinámica.
En esta clase el profesor hizo un breve diagnostico de como están los estudiantes en cuanto al analizáis de las instrucciones  sobre todo de identificar que partes de los códigos se guardan e memoria dinámica y memoria estática, también propuso un ejercicio de aplicación para que lo realizáramos en clase.
int i;                                                                     i 3                 1010 XYZ
fraccionario f;                                                      f 5060            3040 1,2,3
string s = "xyz"                                                     s 1010           5060 fraccionario 4;
int v { } = {1,2,3}; 
i=3;
f=1/4;= 0<-------------- Error de sintaxis 

F= new fraccionario (1,4);
     gestion dinamica 
     de memoria; aplicacion de objetos devuelve direccion de objetos 
fraccionario f2=f
f.setnum (3)
f.setnum (2)

Actividad
Analize las instrucciones java y grafique las variables de objetos en la memoria
fraccionario f1,f2,f3;
f1=new fraccionario (1,2);
f2=new fracionario (2,3);
f3=f1;
f1=f2;
f2=f3;
f1.setNum (3);
f2.setDem (4);
f3.setNum (5);

Introduccion Clase

En esta clase nos presentamos a nuestros compañeros el docente presento el programa, nos mostró las reglas que porcentaje tenia cada actividad del primer segundo y tercer corte. hubo una breve presentación del curso estructura de datos y analizáis de algoritmos.