Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
COMPETENCIAS PREVIAS
Utilizar tcnicas de modelado para la
solucin de problemas.
Aplicar la sintaxis de un lenguaje
orientado a objetos.
Aplicar un lenguaje orientado a objetos
para la solucin de problemas.
Competencias especficas:
Identificar, seleccionar y aplicar
eficientemente tipos de datos abstractos,
mtodos de ordenamiento y bsqueda para
la optimizacin del rendimiento de
soluciones de problemas del mundo real.
POSTERIORES
Matemticas para
la computacin.
Fundamentos de
Programacin.
Estructuras de
Datos I
Programacin
Orientada a
Objetos
Desarrollar y optimizar el
Software de base.
Contenido
Bibliografa Bsica y
complementaria
1.- Cair.
Estructuras de datos
Ed. Mc Graw Hill, 2001.
3.- Thomas
Introduccin a la Programacin
Orientada a Objetos con Java.
Wu.Ed. Pearson
7.-Niklaw wirth
Algoritmos y Estructuras de datos
Ed. Prentice Hall
Sugerencias de evaluacin
de cada unidad
Introduccin
Simples
Estructurados
Dato Simple
Dato Estructurado
Estructuras de Datos
Almacenamien
to Contiguo
Lineales
Estructur
as de
Datos
Pilas,col
as,listas
No
lineales
rboles
Almacenamien
to No
Contiguo
Operaciones Bsicas en
Estructuras Lineales
1.
2.
3.
4.
5.
6.
Concepto de complejidad de
algoritmos
Concepto de complejidad de
algoritmos
Dado el nombre queremos conocer su numero de telfono.
Estructuras de control
simple
Alternativa doble
Alternativa mltiple
Estructuras de control
Alternativa simple:
si condicin, entonces:
[Modulo A]
[Final de la estructura condicional]
Alternativa doble:
si condicin, entonces:
[Modulo B]
[Fin de la estructura condicional]
Estructuras de control
Alternativa doble:
si condicion(1), entonces:
[Modulo A1]
si No Si condicion(2), entonces:
[Modulo A2]
si No Si condicion(M), entonces:
[Modulo AM]
si No:
[Modulo B]
[Final de la estructura condicional]
Estructuras de control
Repetir-Mientras
Repetir-Mientras condicin:
[Modulo]
[Fin del ciclo]
Complejidad
Por que ?
Legibilidad
Costo en mantenimiento
Se tienen que aportar criterios que midan
la eficiencia
(ordenacin o
Algoritmos
Qu es un algoritmo?
es un conjunto finito de instrucciones o pasos que sirven para ejecutar una tarea
o resolver un problema dado.
Algoritmos
Caractersticas de los algoritmos:
1.
Precisin:
2. Entrada:
3. Salida:
Anlisis de algoritmos
Introduccin
Anlisis de algoritmos
Introduccin:
Tasa de crecimiento
Anlisis de algoritmos
Introduccin:
Consideraciones de eficiencia
El tiempo
El espacio
La complejidad del espacio de un programa.Es la cantidad de memoria que se necesita para ejecutar hasta la
complecin (terminacin)
La complejidad del tiempo de un programa.Es la cantidad de tiempo de computadora que se necesita para
Ejecutar hasta la complecin (terminacin)
Anlisis de algoritmos
Introduccin
Anlisis de algoritmos
Introduccin
En la solucin 1, resulta muy costoso (por no decir imposible), implementar todos
los algoritmos para poder realizar la comparacin de los tiempos de ejecucin.
Factores que influyen en el tiempo de ejecucin:
La
Anlisis de algoritmos
Introduccin
busca
Operaciones
Tiempo Mseg
5 6 7 8 9 10
i=0
0<6 && v[0]=! 5
existe= 0<6
1
1
1
TA(n)=
Anlisis de algoritmos
Introduccin
busca
5 6 7 8 9 10
Operaciones
i=0
0<6 && vec[0]=! 9
1<6 && vec[1]=! 9
2<6 && vec[2]=! 9
3<6 && vec[3]=! 9
4<6 && vec[4]=!
existe= 4<6
Tiempo
Mseg
;
;
;
;
9
i++
i++
i++
i++
TA(n)=
1
2
2
2
2
1
1
11
Anlisis de Algoritmos
Introduccin
Un caso medio
Un caso pesimista
Un caso optimista
Anlisis de Algoritmos
Complejidad
O(1)
O(log n)
O(n2)
Suele ser habitual cuando se tratan pares de elementos de datos, como por
ejemplo un bucle anidado doble. Si N se duplica, el tiempo de ejecucin
aumenta cuatro veces.
Anlisis de Algoritmos
Logaritmo
Logaritmo de un numero: Es el exponente a que hay que elevar otro nmero llamado base
para obtener el numero dado
Base: cualquier numero positivo
5=1
5=5
5=25
5=125
Siendo la base el 5 el logaritmo de
Log 1 es 0 , y cero es el exponente al que hay que elevar la base 5
Log 5 es 1
Log 25 es 2
Anlisis de Algoritmos
Aritmtica en notacin O
Para facilitar el clculo de la complejidad de un algoritmo es necesario
desarrollar aritmtica en notacin O, de tal manera que sea posible dividir el
algoritmo y, a partir del estudio de sus partes, establecer el clculo global.
Teorema 1:
Si TA(n) es O( k f(n) )
TA(n) es O( f(n) )
Anlisis de Algoritmos
Aritmtica en notacin O
Teorema 2:
Si A1 y A2 son segmentos de un algoritmo, tales que TA1(n) es O(f1(n)) y
TA2(n) es O(f2(n)), el tiempo empleado para ejecutarse A1 seguido
de A2 es O(max(f1(n), f2(n))).
Esto quiere decir que la complejidad del programa resultante es igual a la
complejidad del bloque ms costoso.
Ejemplo:
a=1;
b=1;
c=1;
TA(n) es O(max(1,1,1))
O(1)
Anlisis de Algoritmos
Aritmtica en notacin O
Teorema 3
Sea A un algoritmo que se forma:
for( i=0 ; i<n ; i++)
A1
A
A2
Anlisis de Algoritmos
Aritmtica en notacin O
Donde: en los bucles con contador explcito, podemos distinguir dos casos,
que el tamao N forme parte de los lmites o que no. Si el bucle se realiza un
nmero fijo de veces, independiente de N, entonces la repeticin slo
introduce una constante multiplicativa que puede absorberse.
K= constante
for (int i= 0; i < K; i++) { algo_de_O(1) }
K*O(1) = O(1)
a[0]=0;a[1]=0;
Complejidad del
programa O(1)
a[2]=0;a[3]=0;
A[4]=0;
Anlisis de Algoritmos
Aritmtica en notacin O
Si el tamao N aparece como lmite de iteraciones ...
for (int i= 0; i < N; i++) { algo_de_O(1) }
N * O(1) = O(n)
algo_de_O(1)
algo_de_O(1)
}
}
}
}
N * N * O(1) =
O(n2)
N * M * O(1) =
O(n*m)
Anlisis de Algoritmos
Aritmtica en notacin O
El caso peor es
cuando j se ejecuta
N veces
A 4 iteraciones
Anlisis de Algoritmos
Aritmtica en notacin O
Iteraccion1 c = 2*1 = 2
Iteraccion2 c = 2*2 = 4
Iteraccion3 c = 2*4 = 8
Iteraccion4 c = 2*8 =
16
El problema se reduce a encontrar una funcin que
acote el nmero de iteraciones del ciclo, ya que
nunca va entrar n veces al ciclo.
Log2 (N)
BASE =2
LOG 4 = 16
Anlisis de Algoritmos
Aritmtica en notacin O
if
El tiempo de ejecucin del if se puede acotar con el tiempo de evaluacin de
la condicin y el tiempo de ejecucin ms demorado (de la parte cierta o
parte falsa) de la estructura condicional.
If (n<0)
return 0;
else
return 1;
La condicin n<0 es de
O(1), porque toma un
tiempo constante ejecutarla,
de igual forma sucede con
los return ( O(1) ).
O(max(1,1))=O(1)
Anlisis de Algoritmos
Tiempo de ejecucin
Calcular la complejidad:
int Buscar(int [] a, int c)
{
int j;
O(1)
j=0;
WHILE (j < n && a[j]< c)
O(1)
{
j=j+1;
}
if ( j < n )
O(1)
O(1)
n*O(1)= O(n)
O(max(1,1,1))= O(1)
O(1)
return j;
else
return
-1;
TA(n)=O(max(1,n,1)=O(n)
}
Anlisis de Algoritmos
Tiempo de ejecucin, calculando el numer de operaciones
int Buscar(int [] a, int c)
{
int j;
j=0;
WHILE (a[j]< c && j < n)
{
j=j+1;
}
if ( a[j]==c )
return j;
else
return -1;
}
(* 1 *)
(* 2 *)
(* 3 *)
(* 5 *)
(* 6 *)
(* 7 *)
En la lnea (2) se efecta la condicin del bucle, con un total de 4 OE (dos comparaciones, un
acceso al vector, y un &&).
La lnea (3) est compuesta por un incremento y una asignacin (2 OE).
La lnea (5) est formada por una condicin y un acceso al vector (2 OE).
La lnea (6) contiene un RETURN (1 OE) si la condicin se cumple.
La lnea (7) contiene un RETURN (1 OE), cuando la condicin del IF anterior es falsa.
Anlisis de Algoritmos
Tiempo de ejecucin
En el caso peor:
Cada iteracin del bucle est compuesta por las lneas (2) y (3), junto
con una ejecucin adicional de la lnea (2) que es la que ocasiona la salida
del bucle. Por tanto el tiempo de ejecucin es:
adicional
n
Anlisis de Algoritmos
Tiempo de ejecucin: calcular la complejidad
directa y con operaciones OE
for( i=0; i<n ; i++)
for( j=0; j<n ; j++)
m3[i][j]=m1[i][j]+m2[i][j];
O(1)
N*O(1)=O(n)
N*O(n)=O(n2)
i=1
J=1
Anlisis de Algoritmos
Tiempo de ejecucin
El ciclo i en el
peor de los casos
recorre todos los
elementos
O(1)
O(1)
O(max(1,1))=O(1)
}
return menor;
}
n
N*O(1)=O(n)
Anlisis de Algoritmos
Tiempo de ejecucin
void ordenar(int vec[], int N)
{ int i, temp, pos;
for(i=0 ; i< N-1 ; i++)
{ pos=PosMenor(vec,i,N); O(n)
temp=vec[i];
O(1)
vec[i]=vec[j];
O(1)
vec[j]=temp;
O(1)
2
O(max(n,1,1,1)) = O(n) N*O(n)=O(n )
}
Llamada
posmenor
}
n
i=1
i=1
1+4n+n+7n2+7n+5n+4
= 7n2+17n+5
=O(n2)
Anlisis de Algoritmos
Tiempo de ejecucin
Calcular la complejidad del siguiente mtodo ( n es un entero positivo).
void misterio (int N)
{ int k,i;
i=1;
while (k<=N)
{ K=i;
while (k <=N)
k++;
k=1;
while (k<=i)
k++;
i++
}
}
Anlisis de Algoritmos
Tiempo de ejecucin
Calcular la complejidad del siguiente mtodo ( n es un entero positivo).
void misterio (int N)
{ int k,i;
i=1;
O(1)
while (k<=N)
n
O(1)
{ K=i;
while (k <=N)
k++;
O(1)
while (k<=i)
k++;
i++
}
}
n*O(1) = O(n)
O(1)
k=1;
n
O(1)
n*O(n) =
O(max(1
O(n2)
,n2))=O(
n*O(1) = O(n)
O(1)
O(max(1,n,,n,1))=O(n)
n2)
Anlisis de Algoritmos
Tiempo de ejecucin
Calcular la complejidad del siguiente mtodo ( n es un entero positivo).
void misterio (int N)
{ int k,i,t;
i=1;
while (i<=N-1)
{ K=I+1;
while (k<=N)
{ t=1;
while (t<=k)
t++;
k++;
}
i++;
}
}
Anlisis de Algoritmos
Tiempo de ejecucin
Calcular la complejidad del siguiente mtodo ( n es un entero positivo).
void misterio (int N)
{ int k,i,t;
i=1;
O(1)
while (i<=N-1)
{ K=I+1;
while (k<=N)
{ t=1;
while (t<=k)
t++;
k++;
O(1)
n
N*O(N)=O(N2)
o(1)
n
o(1)
o(1)
}
i++;
}
}
O(N3)
O(1)
N*O(1)=O(N)
Anlisis de Algoritmos
Complejidad en espacio
Anlisis de Algoritmos
Seleccin de un algoritmo
Factores que se deben tener en cuenta para la seleccin de un algoritmo:
Anlisis de Algoritmos
Seleccin de un algoritmo
Memoria
Stack (Pila)
Programas
Datos
Memoria RAM
Video
Heap
(montn)
Buffer
Memoria
Memoria esttica
Para que un objeto pueda ser almacenado en memoria esttica su tamao
(nmero de bytes necesarios para su almacenamiento) ha de ser conocido en
tiempo de compilacin.
La tcnica de asignacin de memoria esttica es sencilla:
Memoria
D1 d2
D3 d4
D5 d6
D7 d8
D9 d10
1 2
3 4
5 6
7 8
9 10
1+3*2= 1+6= 7
Memoria
Memoria dinmica
Es un espacio de almacenamiento que se solicita en tiempo de ejecucin.
El medio para manejar la memoria que otorga el sistema operativo, es el
puntero, puesto que no podemos saber en tiempo de compilacin dnde
nos dar huecos el sistema operativo (en la memoria de nuestro PC).
Int [] v=new int[5];
Direccin
Memoria
1+3*4=13
Memoria
La definicin anterior se dice que es un tipo estructurado (ya que puede
representar a un conjunto de datos), pero cada uno de los elementos solo
puede representar a un solo dato (tipo simple).
Qu hacer si necesitamos que los elementos del arreglo representen datos
estructurados?
Clave
Edad
Estatur
a
Definir
Clave
Edad
Estatur
a
Clave
Edad
Estatur
a
class dato
{ public int clave;
public int edad;
public float estatura;
}
Clave
Edad
Estatur
a
Memoria
Definir el arreglo
Direccin
Memoria
null
null
null
null
null
Direccin
Memoria
v[i]=new dato();
Clave
Edad
Estatura
Clave
Edad
Estatura
Clave
Edad
Estatura
Clave
Edad
Estatura
Clave
Edad
Estatura
Memoria
Direccin
Memoria
{ v[i].clave=i+1;
v[i].edad=i*10;
v[i].estatura=i+0.5;
}
Clave=1
Edad=0
Estatura=0.5
Clave=4
Edad=30
Estatura=3.5
Clave=3
Edad=20
Estatura=2.5
Clave=5
Edad=40
Estatura=4.5
Clave=2
Edad=10
Estatura=1.5
PILAS
Estructura de datos lineal donde los elementos
pueden ser aadidos o removidos solo por un
extremo.
Esta estructura tiene una filosofia LIFO (last-in,
first-out), ultimo en entrar, primero en salir
Ejemplos:
Pila
de platos.
Pila de monedas.
Pila de discos.
REPRESENTACIN DE PILAS:
Usando arreglos: Define un arreglo de una
dimensin (vector) donde se almacenan los
elementos.
0
5
Ejemplo:
Inicio:
Insertar
Insertar
Insertar
A:
B:
C:
Eliminar
C
A
Tope
tope
Nul
l
Tope
tope
Tope
tope
Tope
Tope
tope
tope
pila
xxx
yyy
Cima
2
3
zzz
3
6
maxpila
7
8
Insertar(Pila,X);
Insertar(Pila,X);
Eliminar(Pila,X);
Insertar(Pila,X);
Eliminar(Pila,X);
Eliminar(Pila,X);
Eliminar(Pila,X);
Insertar(Pila,X);
Insertar(Pila,X);
Eliminar(Pila,X);
Insertar(Pila,X);
Si tope igual a -1
Entonces regresar band<- verdadero
Si no regresar band <- falso
Ejercicio
Hacer
Realizar
Implementacin usando un
Vector
de la clase
return res;
Pilas_Mias(int maximo){
}
max=maximo;
pila=new Object[max];
public boolean Insertar_pila(Object
}
dato)
{
public void borrarpila() {
boolean res=false;
tope=-1;
if(!Pila_llena()) {
}
tope++;
pila[tope]=dato;
private boolean Pila_llena()
{
res=true;
boolean res=false;
}
if(tope==(max-1)) {
return res;
res= true;
}
}
else {
res= false; }
return res;
}
pila1.Insertar_pila("hola");
pila1.Insertar_pila(333);
pila1.Insertar_pila(pepe");
pila1.Insertar_pila(444);
pila1.Mostrar();
-1
pila1.Insertar_pila(ana);
pila1.retirar_pila();
pila1.Mostrar();
//pila1.borrarpila();
retirar_pila();
pila1.Mostrar();
pep
e
333
hola
pila1.Mostrar();
Max=5
T2
333
hola
hol
a
T0
T1
hola
T2
444
ana
444
444
pep
e
333
hola
pep
e
333
hola
pep
e
333
hola
T3
pila1.retirar_pila();
pila1.Insertar_pila(nuevo");
pep
e
333
T3
T4
nuevo
333
hola
333
hola
T1
T2
tope
c
b
a
pila
Listas enlazadas (memoria
dinmica)
Se almacenan los elementos como
nodos y el tamao se ajusta
exactamente a los elementos de
la pila
tope
c
b
pila
a
l
i
p
Si la pila no esta vaca, retirar carcter por carcter de la pila para que
quede invertida
alip
System.out.println();
pila1.Mostrar();
System.out.println("--Invertida--");
String Res=pila1.retirar_pila().toString();
while(Res.compareTo("no se pudo retirar") != 0) //mientras este retirando
{
System.out.println(Res);
Res=pila1.retirar_pila().toString();
}
System.out.println();
}
}
Ejercicio
Ejemplo de palindromo
original
ANA
Invertida
ANA
ANA es un palndromo
PALINDROMO
System.out.println();
pila1.MostrarOri();
PALINDROMO
String Res=pila1.retirar_pila().toString();
pali=pali+Res;
while(Res.compareTo("no se pudo retirar")!=0)
{
Res=pila1.retirar_pila().toString();
if(Res.compareTo("no se pudo retirar")!=0)
{
pali=pali+Res;
}
}
System.out.println();
if (cadena.compareTo(pali)==0)
{System.out.println("la cadena SI es un palindromo => "+pali + " = "+ cadena);}
else
{System.out.println("la cadena NO es un palindromo => "+pali + " = "+ cadena);}
}
}
Aplicaciones de Pilas
Evaluacin de parntesis en el analisis sintctico.
Ejemplo:
(A+B))
(A+B)
((A+B)
([A+B])
(([[A+B]]))
Condicion Para que los parentesis esten correctos es:
1. Que la pila este vaca
2. Que no quede ningn parntesis que cierre pendiente
Ejemplo con las operaciones anteriores
[
(
(
[
(
[
(
2
)
(
[
(
[
(
-1
if(Caracter.compareTo(")")==0 || Caracter.compareTo("]")==0)
{
Ret=pila_parentesis.retirar_pila().toString();
System.out.println("Retirar => " + Ret);
if (Ret.compareTo("no se pudo retirar")==0)
{
SI_ES=false;
}
}
}
Ret=pila_parentesis.retirar_pila().toString();
System.out.println("Pila " + Ret);
// SI_ES=TRUE Y LA PILA ESTA VACIA
if(SI_ES && Ret.compareTo("no se pudo retirar")==0)
{
System.out.println("Parentesis correctos");
}
else
{
System.out.println("Parentesis incorrectos");
}
}
}
TAREA
Modificar el programa
Parentesis_Correctos.java para verificar
si los parntesis estn correctos
Aplicaciones de Pilas
EXPRESIONES ARITMETICAS:
Una expresin aritmtica contiene constantes, variables y
operaciones con distintos niveles de precedencia.
Una expresin aritmtica esta formada por operandos y
operadores.
R=X*Y (A*B)
Las expresiones aritmticas pueden ser representadas en 3
notaciones distintas.
PRESEDENCIA OPERADORES :
()
^
* /
+,-
parntesis
potencia
multiplicacin, divisin
suma, resta
NOTACIONES:
NOTACION INFIJA:
es la forma habitual de escribir operaciones
aritmticas es la de situar el operador entre sus dos
operandos. El operador se evala dentro de los
Operandos.
Los operadores aparecen en medio de los operandos.
A + B, A 1, E/F, A * C , A + B + C
NOTACION PREFIJA: (polaca)
El operador aparece antes de los operandos.
+ AB, - A1, /EF, *AC, ++ABC, +- ABC
NOTACIONES:
NOTACION POSTFIJA: (polaca)
El operador aparece al final de los operandos.
AB+, A1-, EF/, AC*, AB^, AB+C+, AB+C-
De infija a prefija
A*B/(A+C) (infija) ->
A*B/+AC
->
*AB/+AC
->
/*AB+AC (prefija)
A*B/A+C
->
*AB/A+C
->
/*ABA+C
-> +/*ABAC
(A-B)C+D
->
-ABC+D ->
-ABC+D
-> +-ABCD
De infija a postfija
A*B/(A+C) (infija) ->
A*B/AC+
-> AB*/AC+
->
AB*AC+/
A*B/A+C
->
AB*/A+C
->
AB*A/+C
-> AB*A/C+
(A-B)C+D
->
AB-C+D ->
AB-C+D
-> AB-CD+
(postfija)
Conversin a posfijo
Los operadores se meten a la pila siempre que esta este vaca, o bien
siempre que tengan mayor prioridad que el operador cima de la pila
Expresin en infija:
Simbolo
A
+
(
B
*
C
(
D
/
E
^
F
)
*
G
)
*
H
PILA
+
+(
+(
+(*
+(*
+(+(-(
+(-(
+(-(/
+(-(/
+(-(/^
+(-(/^
+(+(-*
+(-*
+
+*
+*
A+(B*C-(D/E^F)*G)*H
Expresion P
A
A
A
AB
AB
ABC
ABC*
ABC*
ABC*D
ABC*D
ABC*DE
ABC*DE
ABC*DEF
ABC*DEF^/
ABC*DEF^/
ABC*DEF^/G
ABC*DEF^/G*ABC*DEF^/G*ABC*DEF^/G*-H
ABC*DEF^/G*-H*+
Ejemplo
Expresin
A* (B+C-(D/E F)-G)-H
AB
ABC
+
(
*
(
*
ABC+D
ABC+DE
/
(
(
*
Expresin
ABC+DEF
A* (B+C-(D/E F)-G)-H
/
(
(
*
Y la expresin:
ABC+DEF /
ABC+DEF /Carcter a la pila y se extrae a su vez
ABC+DEF /-G
Carcter G a la expresion; carcter ) son
extraidos de la pila los operadores hasta un ( la pila queda:
ABC+DEF /-G-*
Carcter -, se saca de la pila * y se mete
ABC+DEF /-G-*H Carcter H se lleva a la expresion
(
*
a*(b+c-(a+b/c)-a)-b
Ejemplos
(x+z)*w/ty-v
+
)
*
/
+
-
/
-
*
-
Solucion 1 ->
)
*
-
)
*
-
vytw/zx+*-
*
-
Ejemplos
(A+B*C)/D*K1
Solucion 1 ->
1KD*CB*A+/
Solucion 2 ->
/+A*BC*DK1
Expresin en infija:
Simbolo
B
)
A
)
C
/
B
+
A
(
C
+
B
(
*
A
A*(B+C-(A+B/C)-A)-B
PILA
-
)
)
))-)
-)-)
-)-)/
-)-)/
-)-)+
-)-)+
-)-)-)-)+
-)+
-*
-*
-
Expresion P
B
B
B
BA
BA
BA
BAC
BAC
BAC B
BAC B /
BAC B /A
BAC B /A+
BAC B /A+ BAC B /A+ - C
BAC B /A+ - C BAC B /A+ - C - B
BAC B /A+ - C - B +
BAC B /A+ - C - B +
BAC B /A+ - C - B +A
BAC B /A+ - C - B +A* -
Infija
=> 5*(6+2)-12/4
PILA
5
56
562
58
40
40 12
40 12 4
40 3
37
Infija
=> 5*(6+2)-12/4
Smbolo
5
*
(
6
+
2
)
12
/
4
PILA1
5
5
5
56
56
562
58
40
40 12
40 12
40 12 4
40 3
37
PILA2
*
*(
*(+
*(+
*(+
*
-/
-/
-
Tarea: Calculadora
Elaborar un programa en java para hacer la
conversin de infija a posfija (CALCULADORA)
Ejemplo:
Dame expresion a convertir => a+b
ab+
Post
Pref
Colas
COLAS
Definicion. Es una lista lineal de elementos en la que
las operaciones de insertar y eliminar se realizan en
diferentes extremos de la cola.
Trabajan con filosofa FIFO ( First In - First out), el
primer elemento en entrar es el primer elemento en
salir.
Ejemplos:
Cola
P
(PRIMERO)
U
(LTIMO)
TIPOS DE COLAS:
Operaciones:
1.- Insertar A
Estado de la cola:
Inicio: Cola
Vaca
A
2.- Insertar B
3.- Insertar C
4.Elemento
Remover
5.- Insertar D
6.- Remover
Elemento
Frente
2
S
3
D
4
Z
Final
Final
Al remover un
elemento:
Frent
e
B
Frent
e
Insertar elemento
D:
Final
C
Final
C
Insertar elemento E:
Frent
e
B
Final
C
E
Final
Insertar elemento F:
Frent
e
B
F
Insertar elemento G:
Error: Cola llena!!!!
Representacin de colas:
Usando memoria esttica: arreglos con tamao
fijo.
Final
Frent
e
B
F
D
2
E
3
Final
Frente
Cola simple
Es una lista lineal de elementos en la que las
operaciones de insertar y eliminar se realizan en
diferentes extremos de la cola. Para lo cual hace uso de
dos indices frente y final.
Este tipo de cola presenta desaprovechamiento de
memoria al momento que se retiran elementos de la cola
ya que esa localidad queda libre; para evitar este
desaprovechamiento de memoria
tenemos dos
soluciones:
1.- Mover todos los elementos de la cola una posicin
cada vez que se quiere retirar un elemento de la cola
2.- Cuando final =max-1 y frente >0 mover todos los
elementos.
Insertar_Cola(1);
Insertar_Cola(2);
Insertar_Cola(3);
Insertar_Cola(4);
Insertar_Cola(5);
retirar_Cola();
retirar_Cola();
Insertar_Cola(7);
Frent
e
Final
1
5
Frent
e
3
Error no se puede
final esta en max-1
Final
4
Ver ejemplo
Cola_Sencilla1
Insertar_Cola(1);
Insertar_Cola(2);
Insertar_Cola(3);
Insertar_Cola(4);
retirar_Cola();
retirar_Cola();
Frent
e
Final
3
Final
Frent
e
Final
Frent
e
Colas Circulares
Es una variacin de las colas sencillas para
hacer un uso ms eficiente de la memoria
disponible, se trata a la estructura de cola
de forma circular. Es decir el elemento
anterior al primero es el ltimo
COLA CIRCULAR
COLA
2
3
4
P=0
U=0
COLAS
2) Se inserta A,B,C,D,E
P=1
U=5
COLA
2
3
4
3) Eliminar A
P=2
U=5
4) Insertar F
P=2
P=2
U=5
U=1
U
COLAS
2
1
P
B
INSERTAR F
C
E
5
4
U
SI U+1 = P
COLA CIRCULAR
LLENA
2
1
B
3
F
C
E
5
D
4
COLAS
OTRO EJEMPLO: N= 5
1) Se inserta A,B,C,D,E
P=1
U=5
COLA
2
3
4
2) Se inserta F
NO SE PUEDE INSERTAR F PORQUE LA
COLA CIRCULAR LLENA, U=N y P=1.
SRR
COLAS
Cola Circular
Es una representacin
lgica de la cola en
un arreglo.
El frente y final son
movibles.
Cuando el frente o final
llegan al extremo se
regresan a la primera
posicin del arreglo.
Frent
e
Cola
inicial
Final
Frent Final
e
Remover
C
Frent
e
Insertar E
Final
C
E
Final
Insertar F
F
E
Frent
e
C
ColaCirc_llena()
ColaCirc_vacia()
InsColaCirc(Object dato)
RetColaCirc()
BICOLA
Una bicola:
es un conjunto de elementos en el cual se
pueden aadir o quitar elementos de cualquier
extremo de la misma.
Los dos extremos de una bicola los llamaremos
izquierdo y derecho
Representacion esttica
Se mantienen los elementos de la bicola
en un arreglo circular.
Se utilizan dos variables indice Izquierdo y
Derecho.
Final: 4
luz
agua
ri
Final: 4
sql
luz
agua
ri
sql
luz
agua
Problema:
Colas en Java
Java contiene la definicin de interfaces y
clases para el manejo de colas.
Las colas son una coleccin de elementos
diseadas para almacenar elementos que
esperan ser procesados.
Java contiene una interface parametrizada
Queue<E> y varias clases que que la
implementan, entre ellas PriorityQueue<E>
Colas en Java
public interface Queue<E> extends
Collection<E> {
E element();
boolean offer(E o);
E peek();
E poll();
E remove();
}
Method Summary
E element()
Retrieves, but does not remove, the head of this queue, it throws an exception if this queue is empty..
boo offer(Eo)
lean
Inserts the specified element into this queue, if possible.
E
peek()
Retrieves, but does not remove, the head of this queue, returning null if this queue is
empty.
E
poll()
Retrieves and removes the head of this queue, or null if this queue is empty.
E remove()
Retrieves and removes the head of this queue.
Type Parameters:
E - the type of elements held in this collection
Constructor Summary
PriorityQueue()
Creates a PriorityQueue with the default initial capacity (11) that orders its elements according to
their natural ordering (using Comparable).
PriorityQueue(Collection<? extends E>c)
Creates a PriorityQueue with the specified initial capacity that orders its elements according to
their natural ordering (using Comparable).
PriorityQueue(intinitialCapacity, Comparator<? super E>comparator)
Creates a PriorityQueue with the specified initial capacity that orders its elements according to the
specified comparator.
PriorityQueue(PriorityQueue<? extends E>c)
Method Summary
boolean
void
Comparat
or<?
super E>
Iterator<E>
boolean
add(Eo)
Adds the specified element to this queue.
clear()
Removes all elements from the priority queue.
comparator()
Returns the comparator used to order this collection, or null if this collection is sorted
according to its elements natural ordering (using Comparable).
iterator()
Returns an iterator over the elements in this queue.
offer(Eo)
Inserts the specified element into this priority queue.
peek()
Retrieves, but does not remove, the head of this queue, returning null if this queue is empty.
poll()
Retrieves and removes the head of this queue, or null if this queue is empty.
boolean
int
remove(Objecto)
Removes a single instance of the specified element from this queue, if it is present.
size()
Returns the number of elements in this collection.
LISTAS ENLAZADAS
Es una coleccin lineal de elementos llamados nodos
donde el orden de los mismos se establece mediante
punteros y existe un puntero especial llamado INICIO para
localizar al primer elemento.
Un nodo se divide en 2 partes:
Informacin: Contiene la info del elemento.
Enlace: Contiene la direccin del sig. Nodo de la lista.
Ejemplo:
*Lista enlazada de 0 elementos
Inicio
Inicio
info enlac
e
* Lista enlazada de 4
elementos
Nodo
Almacenamiento de datos:
Arreglos: La relacin lineal esta implcita en la
relacin fsica de los elementos. Desventaja:
Almacenamiento esttico y tamao fijo.
2. Elementos
enlazados: Agrega a cada
elemento un campo de enlace, no requieren
almacenamiento contiguo en memoria, se
pueden aadir y borrar elementos fcilmente.
* El valor default del puntero es nulo.
1.
LISTAS LIGADAS
Es recomendable usarlas en aplicaciones que tienen
las siguientes caractersticas:
1. Cuando no se conozca la cantidad de memoria que
se vaya a necesitar en el momento de escribir el
programa.
2. Se requiere realizar con mucha
operaciones de INSERTAR y de ELIMINAR.
frecuencia
LISTAS ENCADENADAS(SIMPLES):
Es un conjunto variable de elementos, donde el orden de
los mismos se establece mediante apuntadores.
Cada elemento se divide en dos partes:
P=Principio
(cabeza)
F=Fin
Puntero Principio: Contiene
la direccin de la posicin del
elemento inicial de la lista.
Contiene la Informacin
del elemento
2) Insertar A
INSERCIN AL PRINCIPIO
A
P
Apunta a la cabeza
de la lista
Apunta al ltimo
de la lista
3) Insertar B,D
INSERCIN AL FINAL
B
A
P
D
F
D
F
4) Insertar C
INSERCIN EN MEDIO
B
F
C
D
F
5) Eliminar la A
A
ELIMINAR AL PRINCIPIO
B
D
F
2.
Inicio
Aux
Inicio
Nota: Si se borra Aux se pierde el fin de la
Lista
Aux
Ejemplo: Alumnos
Crear
01 luis ing 23
02 marta bio 20
Mostrar
lista
los elementos de la
Tarea:
Ejercicio
Implementar una pila usando una lista
ligada.
La pila contiene nmeros enteros.
Que elementos (datos) se requieren?
Que mtodos se implementan?
tope
10
Ejercicio
Implementar una cola usando una lista
ligada.
La cola contiene articulos a comprar.
Que elementos (datos) se requieren?
Que mtodos se implementan?
frente
Galletas
Jamn
Leche
Pan
final
Continuar Ejemplo:
Lista sencilla
Alumnos.java
borrar_nodo(NC)
llena_lista(NC,Nom,Ca,E)
mostrar()
buscar(nc)
Circulares:
Es una lista enlazada con cabecera,
donde el ltimo nodo contiene un
apuntador hacia la cabecera.
Inicio
Nodo
cabecera
LISTAS CIRCULARES:
Son aquellas en las que su ltimo
elemento contiene un puntero con la
direccin del primer elemento de la lista.
P=Principio
(cabeza)
F=Fin
Puntero Principio: Contiene
la direccin de la posicin del
elemento inicial de la lista.
Contiene la Informacin
del elemento
Alumnos2.java
llena_lista
(NC,Nom,Ca,E)
borrar_nodo(NC)
Recorrido(inicio,fin)
buscar(nc)
(insertar al pincipio)
3) Insertar el 7,9
(Insertar al final)
4) Insertar el 8
(insercin en el medio)
5) Insertar el 4
(Insertar al principio)
6) Eliminar el 7
(eliminacin en el medio)
6) Eliminar el 9
(eliminacin al final)
LISTAS DOBLES:
LISTAS DOBLES
Una lista doble una estructura lineal de elementos
llamados nodos los cuales contienen dos enlaces: uno al
elemento anterior y otro al elemento siguiente de la lista.
El primer nodo de la lista contiene nulo en su enlace al
elemento anterior y el ltimo nodo de la lista contiene nulo
en su enlace al elemento siguiente.
Estructura del
Nodo:
Info
Anterior
Siguient
e
Estructura del
Nodo:
Info
Anterior
OPERACIONES:
-VACIA
-INSERTAR
-REMOVER
-BUSCAR
Siguient
e
Ejemplo:
Inicio
Lista Vaca
Lista de un solo
elemento
Inicio
Anterior Info
Siguiente
Inicio
C
Lista de
tres
elementos
LD =Apunta al
siguiente
Contiene la Informacin
del elemento
1) Inicialmente vaca
P = NULL
F = NULL
2) Insertar A
INSERCIN AL PRINCIPIO
A
P
Apunta a la cabeza
F
Apunta al ltimo
de la lista
de la lista
INSERCIN AL FINAL
3) Insertar B,D
P
D
F
4) Insertar C
INSERCIN EN EL MEDIO
B
C
Se realiza una bsqueda primero para
encontrar la C y luego se procede a
eliminarla.
nodo
Inicio
nodo.ligader.ligaizq
Inicio
es:
Fin
B
es:
nodo
Fin
5) Eliminar la A
P
ELIMINAR AL PRINCIPIO
B
if (res)
{
if(aux==fin)
{
fin=null;
aux=null;
}
aux=null; // borro
elemento
}}
Agregue Unidades
Asigne Carpeta(s) a las unidades
Asigne Archivos a cada Carpeta
Tener
en cuenta que:
Estructura de Datos
Unidad 4. Recursividad
Recursion
de Fibonacci
Torres de Hanoi
Algoritmos de Ordenamiento de datos
Etc.
Ejemplo:
public void A()
{
----------A();
----------}
Ejemplo:
}
public static void proceso2(){
System.out.println(proceso2);
}
public static void main(String[] args){
proceso1();
proceso2();
}
}
Cual es la
salida de
este
programa?
Procedimientos recursivos
Definir un expresin en la gramatica de un
lenguaje de programacin
Mostrar todos los miembros de un familia
representados en un arbol genealgico
Etc.
Implementcin de l recursin
Ejemplo:
Class SumaEnteros
{ //sum de enteros recursiva
static int suma(int n)
{
if (n==1)
return 1;
else
return n+suma(n-1);
suma(1)
suma(2)
suma(3)
suma(4)
suma(5)
main()
Pila de registros de
activacin de los
mtodos
}
public static void main(String[] args)
{
System.out.println(Suma de los primeros 5 numeros enteros + suma(5));
}
Ejemplo de recursividad:
Ejemplo:
3!= 3 * 2 * 1
4!= 4 * 3 * 2 * 1
4!= 4 * 3!
N!= n * n-1 * n-2 * * 3 * 2 * 1
Res = 1
Res = 1*1 = 1
Res = 1*2 = 2
Res = 2*3 = 6
Res = 6*4 = 24
Factorial1(4)
= 4*factorial1(3) = 24
Factorial1(3)
= 3*factorial1(2) = 6
Factorial1(2)
= 2*factorial1(1) = 2
Factorial1(1)
= 1*factorial1(0) = 1
Factorial1(0)
=1
Mtodo fibonacci
La secuencia de fibonacci se define:
n f
n f
0=0 5=5
1=1 6=8
2=1 7=13
3=2 8=21
4=3
Se inicia con F0=0 y F1=1. El siguiente nmero se calcla
sumando los dos anteriores. Por ejemplo:
Mtodo fibonacci
public static int fibonacci(int n)
{
if((n==0) ||(n==1))
return n;
else
return fibonacci(n-1)+fibonacci(n-2);
}
Tarea
x=2 y=3 = 8
Potencia(x,y)
2*2*2=8
Torre de Hanoi
1.
2.
3.
4.
Elementos:
Tres
postes
N discos de diferentes tamaos
Reglas:
Mover
Poste A
Poste B
Poste C
1
2
3
2
3
1
2
3
4 discos
rboles
Introduccin
rboles
rboles
Ejemplo de un rbol
Raz
Nodos Intermedios, ramas
No terminales
MiEmpresa
Ventas
Produccin
I+D
Hojas o Terminales
ES
Europa
Internacional
Asia
Porttiles Sobremesa
Amrica
3.
4.
5.
Propiedades (cont..)
6.
7.
8.
9.
Ejemplo de conceptos de
rboles
Raz
Hijos
Padres
B
Hermanos
Hojas
D
I,E,J,K,G,L
Nodos Intermedios
Grados C 2
rbol Binario
A
B
A
B
C
D
C
E
A
B
A
C
B
E
E
C
A
E
B
D
E
C
Donde h representa
la altura del rbol
Construir un ABB
31240
1
3
2
Inorden
Preorden
Postorden
C
A
D
B
E
F
Preorden:
(raiz, izq, der)
Inorden:
(Izq, raiz, der)
Postorden:
(Izq, der, raiz)
C,A,B,D,E,F,I,H
H
A,B,C,D,E,F,H,I
B,A,H,I,F,E,D,C
F,K,C,E,M,B,D
Ejemplos de Recorridos
Inorden(nodo)
Preorden (nodo)
Postorden (nodo)
Recorridos (Cdigo)
Inorden (izq,raiz,der)
public static void inorden(NodoArbol nodo)
{
if (nodo!=null)
{
inorden(nodo.LI);
System.out.println(nodo.claveart);
inorden(nodo.LD);
}
}
Resultado =>A,B,C,D,E,F,H,I
Recorridos (Cdigo)
Preorden (raiz,izq,der)
public static void preorden(NodoArbol nodo)
{
if (nodo!=null)
{
System.out.println(nodo.claveart);
preorden(nodo.LI);
preorden(nodo.LD);
}
}
Resultado => C,A,B,D,E,F,I,H
Recorridos (Cdigo)
Postorden (izq,der,raiz)
public static void postorden(NodoArbol nodo)
{
if (nodo!=null)
{
preorden(nodo.LI);
preorden(nodo.LD);
System.out.println(nodo.claveart);
}
}
B,A,H,I,F,E,D,C
va recorriendo el rbol
Si el nodo actual no es el buscado se decide
si hay que buscar por a la derecha o la
izquierda
El algoritmo puede llegar a encontrar el nodo
o llegar al rbol vaco
Puede desarrollarse:
Como algoritmo recursivo del nodo del rbol
Como algoritmo iterativo del rbol
Busca(dato,nodo)
//BUSCAR UN ELEMNTO EN EL ARBOL
System.out.println("DATO A BUSCAR ");
String k=Leer.dato();
boolean encontro=busca(K,Raiz);
if (encontro)
{
System.out.println("El elemento SI se encuentra en el arbol ");
}
else
{
System.out.println("El elemento NO se encuentra en el arbol ");
}
Insertar elementos
Insertar 45
45
Insertar 23
23
Insertar 2
65
Insertar 7
2
52
38
96
Insertar 65
Insertar 38
Insertar 96
48
Insertar 52
Insertar 48
class NodoArbol
{
public String claveart;
public String descripcion;
public float precio;
public NodoArbol LI;
public NodoArbol LD;
}
"",
"",
"",
"",
"",
1,Raiz);
1,Raiz);
1,Raiz);
1,Raiz);
1,Raiz);
Borrado en ABB
Funcionamiento:
Ejemplos de Borrado
El
Borrar 8
Sustituir por 6
menor de su subrbol
derecho
El mayor de su subrbol
izquierdo
Sustituir por 12
Ejemplos de Borrado
Borrar 1
Borrar 20
Borrar 5
Borrar 1
Borrar 20
Borrar 5
El
menor de su subrbol
derecho
El mayor de su subrbol
Tarea:
Implementar los mtodos vistos
Insercin,
Algoritmos de Ordenamiento
Intercalacin directa.
Mezcla natural.
Radix.
Burbuja.
Quicksort.
ShellSort.
Secuencial.
Binaria.
Hash.
Bsqueda externa.
Secuencial.
Binaria.
Continua
grafos!