Estructura de Datos I (Ingenieria)

Estructura de Datos
Objetivo general del Curso:

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.
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.
Relacin con otras asignaturas del plan de estudio:

AS I G N AT U R AS
ANTERIORES
Fundamentos de
Programacin.
Programacin Orientada a
Objetos.
Matemticas para
la computacin.
POSTERIORES
Matemticas para
la computacin.
Fundamentos de
Programacin.
Estructuras de
Datos I
Programacin
Orientada a
Objetos
Aportacin de la asignatura al perfil del

egresado:
Proporciona el conocimiento terico prctico para
la utilizacin de las estructuras de datos en un
programa.
Desarrollar y optimizar el
Software de base.
Contenido
Unidad 1. Anlisis de algoritmos.

Unidad 2. Manejo de memoria.
Unidad 3. Estructuras lineales
esttica y dinmicas (pilas,colas,listas
enlazadas).
Unidad 4. Recursividad.
Unidad 5. Estructuras no lineales
estticas y dinmicas (arboles).
Unidad 6. Ordenacin interna
Unidad 7. Ordenacin externa.
Unidad 8. Mtodos de bsqueda.
Bibliografa Bsica y
complementaria
1.- Cair.
Estructuras de datos
Ed. Mc Graw Hill, 2001.
5.- Knuth Donald E.

Fundamental algoritmos Vol. I
Ed. Addison-Wesley P.C
2.- Mark Allen Weiss Mark

Estructuras de datos en Java
Ed. Pearson.
6.- Robert L. Krue

Estructura de datos y diseo de
programas
Ed. Prentice Hall
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
4.- Seymour Lipschutz

Estructura de Datos
Ed. Serie Schaum
Mc. Grau Hill
Sugerencias de evaluacin
Evaluacin Escrita 80%

Examen
de cada unidad
Elaboracin de Programas 20%

Trabajos
de investigacin/ participacin en clase
Introduccin
Los datos en una computadora se clasifican en:
Simples
Estructurados
Dato Simple
Dato Estructurado
Estructura de Datos: Es una coleccin de datos

organizados de un modo particular.
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.
Recorrido: Procesa c/elemento de la estructura.
2.
Bsqueda: Recupera la posicin de un elemento

especfico.
3.
Insercin: Adiciona un nuevo elemento a la

estructura.
4.
Borrado: Elimina un elemento de la estructura.
5.
Ordenacin: Ordena los elementos de la estructura

de acuerdo a los valores que contiene.
6.
Mezcla: Combina 2 estructuras en una sola.
Unidad 1: Anlisis de algoritmos
Concepto de complejidad de
algoritmos
Algoritmo: Es una secuencia de operaciones o

pasos perfectamente definidos que conducen a
la solucin de un problema
Complejidad de un algoritmo: es la funcin

que da la eficiencia de un algoritmo (tiempo de
respuesta)
Concepto de complejidad de
algoritmos
Dado el nombre queremos conocer su numero de telfono.
Bsqueda secuencial: Recorre cada elemento, uno a

uno, hasta encontrar el nombre buscado y su telfono
Bsqueda binaria: compara el nombre buscado con el

que se encuentra en la mitad de la lista. Divide la lista en
dos partes y determina en cual de las dos se encuentra
el nombre buscado
Es evidente que entre menos comparaciones se realicen

menos tiempo de ejecucin tendr el algoritmo
Estructuras de control
Lgica Selectiva: Utiliza un conjunto de

condiciones que implica la ejecucin de
alguna alternativa entre varias. Este tipo
de estructuras reciben el nombre de
estructura condicionadas
Alternativa
simple
Alternativa doble
Alternativa mltiple
Alternativa simple:
si condicin, entonces:
[Modulo A]
[Final de la estructura condicional]
Alternativa doble:
si condicin, entonces:
[Modulo B]
[Fin de la estructura condicional]
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]
Lgica iterativa (flujo repetitivo): ciclos

Ciclo
Repetir-Mientras
Repetir-Mientras condicin:
[Modulo]
[Fin del ciclo]
Complejidad
Analizar algoritmos es la tarea mas

costosa en el diseo de los algoritmos.
Por que ?
Legibilidad
Costo en mantenimiento
Se tienen que aportar criterios que midan
la eficiencia
Factores que miden la eficiencia de

un algoritmo
Por el tiempo de ejecucin

bsqueda)
Por el espacio (memoria)
(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:
los pasos se enuncian con precisin.

el algoritmo recibe una entrada de datos
el algoritmo produce una salida de informacin
Anlisis de algoritmos
Introduccin
Es difcil determinar la cantidad exacta de ejecucin de un

algoritmo ya que esto depende de:
Como se codifico el programa
Que computadora se utilizara
Que datos debe utilizar el programa
Introduccin:
Tasa de crecimiento
A medida que crece un elemento del programa, generalmente

crece el tiempo de ejecucin del mismo.
Esto es que el tiempo de ejecucin varia segn el tamao de la
entrada.
Observando estas variaciones se puede determinar la tasa de
crecimiento del programa.
Tasa de crecimiento:
Es una medida importante de la eficiencia de un programa ya
que predice cuanto tiempo se requerir para entradas muy
grandes de un determinado problema.
Introduccin:
Consideraciones de eficiencia
Para determinar la eficiencia de un programa debemos de considerar:
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)
Introduccin
En ocasiones pueden existir varios algoritmos para resolver una aplicacin

particular (A1, A2, ,An).
Cmo decidir cul de los algoritmos es mejor (tiempo de ejecucin y espacio
de memoria)?
Solucin 1 (a posteriori, medida experimental). La solucin ms sencilla
parece ser implementar los algoritmos en algn lenguaje de programacin y
medir el tiempo de ejecucin que cada uno de ellos requiere para resolver el
problema.
Solucin 2 (a priori, medida terica). Estableciendo una medida de calidad de
los algoritmos, que nos permita compararlos sin necesidad de
implementarlos.
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
velocidad de operacin de la computadora en que se ejecuta. Es diferente

ejecutar el programa en un micro 80386, que en un pentium de 1.83 Ghz.
El
compilador utilizado (calidad del cdigo generado). Cada compilador

utiliza diferentes estrategias de optimizacin, siendo algunas ms efectivas
que otras.
La
estructura del algoritmo para resolver el problema.
Introduccin
En la solucin 2, lo ideal, al hacer la evaluacin de la eficiencia del

algoritmo, sera encontrar una funcin matemtica que describiera de
manera exacta el tiempo que dura el algoritmo al ejecutarse, con una
entrada de n datos - TA(n)
En muchos casos, el clculo de la funcin matemtica no se puede realizar,
ya que depende de la calidad o contenido de la entrada, se ilustra a
continuacin:
for (int i=0; i < N && V[i]!=busca; i++);
existe=i<N
V
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)=
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
Esto implica que, por ms que se conozca el tamao de los datos de

entrada, es imposible (para muchos problemas) determinar el tiempo de
ejecucin para cada una de las posibles entradas.
Anlisis de Algoritmos
Introduccin
Usualmente el anlisis de un algoritmo incluye:
Un caso medio
Un caso pesimista
Un caso optimista
que tan cerca al caso promedio trabaja el algoritmo,

Notacin (theta)
peor caso Notacin O (big-oh)
mejor caso Notacin (big-omega)
Nosotros trabajaremos con el TA(n) en el peor de los casos (O), ya que es

mucho ms fcil definir cul es el peor de los casos, que considerarlos todos o
incluso que considerar el caso promedio.
TA(n)=tiempo que se demora el algoritmo A, en el peor de los casos, para
encontrar una solucin a un problema de tamao n.
Complejidad
O(n) es mas eficiente que el O(n2)
O(log n) es mas rpido que O(n log n) y

a su vez es mas rpido que O(n2)
O(1)
O(log n)
O(n2)
Significa que la mayora de las instrucciones se ejecutan una vez o muy

pocas
El programa es ms lento cuanto ms crezca N,
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.
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
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) )
Este teorema expresa una de las bases del anlisis de algoritmos: lo

importante no es el valor exacto de la funcin que ocota el tiempo, sino su
forma. Esto permite eliminar todos los Factores constantes de la funcin cota.
Ejemplo: un algoritmo que es O(2n) tambin es O(n)
un algoritmo que es O(6n2+2) tambin es O(n2)
un algoritmo que es O(5+3n+2) tambin es O(n)
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;
Una asignacin que no

tiene
llamadas
a
funciones se ejecuta en
un tiempo constante, sin
depender del nmero de
datos del problema.
TA(n) es O(max(1,1,1))
O(1)
Teorema 3
Sea A un algoritmo que se forma:
for( i=0 ; i<n ; i++)
A1
for( j=0 ; j<n ; j++)

cont++;
A
A2
Tal que TA2 es O(f2(n)) y TA1 es O(f1(n)),
el tiempo de ejecucin del programa
Completo TA(n)=TA1(n) * TA2(n) es O(f1(n) * O(f2(n))
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) }
for(i=0; i<5 ; i++)

a[i]=0;
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;
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)
El tiempo de ejecucin va a depender, del tamao del N.

Ciclos anidados
for (int i= 0; i < N; i++) {
for (int i= 0; i < N; i++) {

for (int j= 0; j < M; j++) {
for (int j= 0; j < N; j++) {
algo_de_O(1)
algo_de_O(1)
}
}
}
}
N * N * O(1) =
O(n2)
N * M * O(1) =
O(n*m)
for (int i= 0; i < N; i++) {
El caso peor es
cuando j se ejecuta
N veces
for (int j= 0; j < i; j++) {

algo_de_O(1)
}
}
el bucle exterior se realiza N veces, mientras que el interior se realiza
1, 2, 3, ... N veces respectivamente. En total,
O(n2)
A 4 iteraciones
Iteraccion1 c = 2*1 = 2
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.
Bucles con la variable de control no lineal (while)

c= 1;
while (c < N) {
algo_de_O(1)
c= 2*c;
}
Pero dado que en cada iteracin se reduce 2*c, es

mejor como cota del nmero de iteraciones una
funcin 2k.
El valor inicial de c es 1. Al final del ciclo c tiene el
valor de 2k donde k es el nmero de iteraciones
El nmero de iteraciones es tal que 2k <= N => k

Y por tanto la complejidad del bucle es O(log n)
Log2 (N)
BASE =2
LOG 4 = 16
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)
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)
}
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 *)
Para determinar el tiempo de

ejecucin, calcularemos primero
el nmero de operaciones
elementales
(OE)
que
se
realizan:
En la lnea (1) se ejecuta 1 OE (una
asignacin).
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.
Tiempo de ejecucin
En el caso peor:
se efecta la lnea (1),
el bucle se repite n veces hasta que se cumple la segunda condicin,
despus se efecta la condicin de la lnea (5) y el mtodo acaba al

ejecutarse la lnea (7).
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
T(n) = 1+ (( (4 + 2) +4 ) +2 + 1 = 1+4n+2n+4+2+1 =6n+8=O(n)

i=1
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)
En la lnea 1 se ejecuta 4 OE, una inicializacin, una comparacin y un incremento

En la lnea 2 se ejecuta 4 OE, una inicializacin, una comparacin y un incremento
En la lnea 3 se ejecuta 4 OE
Inicializacin
i=1
J=1
T(n) =1+ (3 + 1+ (3+4 ))= 1+ (3 + 1+7n) = 1+ 4n +7n2 = O(n2)

i=1
Tiempo de ejecucin
int PosMenor(int vec[ ], int desde, int N) {

int i,menor=desde;
El ciclo i en el
peor de los casos
recorre todos los
elementos
for(i=desde+1 ; i<N; i++) {

if(vec[i]<vec[menor])
menor=i;
O(1)
O(1)
O(max(1,1))=O(1)
}
return menor;
}
n
TA(n)=1+2+(3+3+1)+3+1 = 7n+7 = O(n)

i=1
N*O(1)=O(n)
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
TA(n)=1+(4+ 1+(1+2+ (3+3+1)+3+1) + 5)+4= TA(n)=1+ (4+1+( 7n + 7)+5)+4=

i=1
i=1
i=1
1+4n+n+7n2+7n+5n+4
= 7n2+17n+5
=O(n2)
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++
}
}
Tiempo de ejecucin
{ 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)
Tiempo de ejecucin
{ int k,i,t;
i=1;
while (i<=N-1)
{ K=I+1;
while (k<=N)
{ t=1;
while (t<=k)
t++;
k++;
}
i++;
}
}
Tiempo de ejecucin
{ 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)
Complejidad en espacio
El clculo de la complejidad en espacio de un algoritmo es un proceso sencillo

que se realiza mediante el estudio de las estructuras de datos y su relacin con
el tamao del problema.
Decir que un programa es de O(n) en espacio significa que sus requerimientos
de memoria aumentan proporcionalmente con el tamao del problema.
Ejemplo: int v []=new int[N];
Para un programa con complejidad O(n2) en espacio, la cantidad de
memoria que se necesita para almacenar lo datos crece con el cuadrado del
tamao del problema.
Ejemplo: int v []=new int[N*N];
Seleccin de un algoritmo
Factores que se deben tener en cuenta para la seleccin de un algoritmo:
La complejidad en tiempo del algoritmo

Es una primera medida de calidad, y establece su comportamiento cuando el
nmero de datos a procesar es muy grande.
La complejidad en espacio del algoritmo

Es una medida de la cantidad de espacio que necesita el algoritmo para
representar la informacin. Slo cuando esa complejidad resulta razonable es
posible utilizar este algoritmo con seguridad. Si las necesidades de memoria
crecen desmesuradamente con respecto al tamao del problema, el rango de
utilidad del algoritmo es bajo y se debe descartar.
Seleccin de un algoritmo
El valor de la constante asociada con la funcin de complejidad

Si hay dos algoritmos A1 y A2 de complejidad O(f(n)), el estudio de la funcin
cota debe de hacerse de una manera ms profunda y precisa en ambos casos,
para tratar de establecer la que tanga menos constantes.
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:
A partir de una posicin asignada, se aloja el objeto X.
La asignacin de memoria se realiza en tiempo de compilacin y debe

ser contigua.
En el lenguaje pascal una definicin sera: v: array [0..4] of integer;

Cuntos bytes contiguos requiere para representar el arreglo?
10 bytes contiguos. Esto es debido a que cada entero se representa en 2 bytes.
Memoria
D1 d2
D3 d4
D5 d6
D7 d8
D9 d10
1 2
3 4
5 6
7 8
9 10
Bytes por elemenrto

Direccin de memoria
v=900; es un error. Debe especificarse un elemento del arreglo

V[3]=900; en el cuarto elemento del arreglo se asigna el 900.
Cmo realiza la asignacin en la localidad de memoria correcta?
Direccin inicio del arreglo + Sub*Byte
Para sub=3, DI + 3 * 2 =
1+3*2= 1+6= 7
Observe que el tercer elemento del arreglo inicia en la direccin 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];
Java solicita el rea de memoria del vector en

tiempo de ejecucin, haciendo uso de la memoria
HEAP (montn).
Direccin
Memoria
V[3]=18; realiza la misma formula que en la estticos
Requiere de 24 bytes contiguos. 20

para
representar
los
cinco
elementos y asigna un elemento de
control donde almacena el nmero
de elementos del arreglo. Un tipo int
en java requiere de 4 bytes
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
una clase que contenga los atributos que deseamos
class dato
{ public int clave;
public int edad;
public float estatura;
}
Clave
Edad
Estatur
a
Memoria
Definir el arreglo
Direccin
Memoria
dato [ ] v = new dato[5]
null
null
null
null
null
Crear a cada elemento un objeto donde estarn los datos

for( int i=0 ; i<5 ; i++)
Direccin
Memoria
v[i]=new dato();
Clave
Edad
Estatura
Clave
Edad
Estatura
Clave
Edad
Estatura
Clave
Edad
Estatura
Clave
Edad
Estatura
Memoria
for( i=0 ; i<5 ; i++)
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.
OPERACIONES BASICAS CON

PILAS
-PUSH (insertar).- Agrega un elementos a la pila en el
extremo llamado tope.
-POP (remover).- Remueve el elemento de la pila que
se encuentra en el extremo llamado tope.
-VACIA.- Indica si la pila contiene o no contiene
elementos.
-LLENA.- Indica si es posible o no agregar nuevos
elementos a la pila.
REPRESENTACIN DE PILAS:
Usando arreglos: Define un arreglo de una
dimensin (vector) donde se almacenan los
elementos.
0
5
TOPE: Apunta hacia el elemento que se

encuentra en el extremo de la pila.
(inicialmente es null).
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
Si queremos insertar un dato en la pila METER(pila, WWW),

que pasos tenemos que seguir?
Si queremos sacar un dato en la pila SACAR(pila, ITEM), que
pasos tenemos que seguir?
Realizar el siguiente Ejercicio

Dibuje los distintos estados de una estructura tipo pila si se llevan
a cabo las siguientes operaciones. Muestre como va quedando
la pila y el puntero al tope de la misma. Considere que la pila
esta inicialmente vacia (Tope=0):
a)
b)
c)
d)
e)
f)
g)
h)
i)
j)
k)
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);
Responda las siguientes preguntas:

Con cuantos elementos quedo la pila?
Hubo algun caso de error? Explique
Mtodos bsicos para implementar

la pila son:
Pila_llena()
Devuelve verdadero si la pila esta llena
Pila_vacia();
Devuelve verdadero si la pila esta vacia
Insertar_push (int elem);
Agrega el elemento a la pila
Retirar_pop();
Elimina el elemento que esta en la cima de la pila
Interface para una pila de enteros:

interface IPila {
public boolean pila_llena();
public boolean pila_vacia();
public void insertar_push (int elem);
public int retirar_pop();
}
Algoritmo para la operacin para

verificar si la pila esta vacia
Pila_vacia()
1.
Si tope igual a -1
Entonces regresar band<- verdadero
Si no regresar band <- falso
2. {fin del condicional del paso 1}
Hacer el algoritmo para verificar si la

pila esta llena
Ejercicio
Hacer
el mtodo para el algoritmo

pila_vacia
Realizar
el mtodo para pila_llena
Algoritmo para insertar un

elemento de la pila
insertar_push (int elem);
Verificar si la si la esta llena
Si la pila esta llena; enviar mensaje
de que esta llena
Si no
se prepara a insertar,
incrementando el tope de la
pila
se inserta el elemento en la
pila
public void push (int elem)

{
if (this.llena())
ERROR
else{
tope ++;
pila [ tope ] = elem;
}
}
Hacer el algoritmo para insertar un

elemento a la pila
{fin del condicional}
Algoritmo para retirar un elemento

de la pila
Retirar_pop (int elem);
Verificar si la pila esta vacia
Si esta vacia; enviar mensaje de que
esta llena
Si no
se respalda el elemento a eliminar
se decrementa el tope de la pila
se regresa el valor eliminado de la
pila
{fin del condicional}
public int pop()

{
if (this.vacia())
ERROR
else{
int x = pila[tope];
tope --;
return x;
}
}
Hacer el algoritmo para retirar un

elemento a la pila
Implementacin usando un arreglo:

class Pila {
int tope = -1;
private int [] pila = new int [10];
final int max = 9;
public boolean llena(){
return ( tope == max);
}
public void push (int elem){
if (this.llena())
ERROR
else{
tope ++;
pila [ tope ] = elem;
}
}
public boolean vacia(){

return (tope == -1);
}
public int pop(){
if (this.vacia())
ERROR
else{
int x = pila[tope];
tope --;
return x;
}
}
}
Implementacin usando un
Vector
public class Stack {

private Vector items;
public Stack() {
items = new Vector(10);
}
public Object push(Object item){
items.addElement(item);
return item;
}
public synchronized Object pop(){
int len = items.size();
Object obj = null;
if (len == 0) throw new EmptryStackException();
obj = items.elementAt(len-1);
items.removeElementAt(len 1);
return obj;
}
public boolean isEmpty() {
if (items.size == 0) return true;
else return false;
}
}
class Pilas_Mias Ejemplo de la implementacin

{
pila
private boolean Pila_vacia() {
private Object pila[];
boolean res=false;
private int tope=-1;
if(tope==-1)
private Object dato;
res=true;
private int max=0;
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;
}
public Object retirar_pila()

{
Object res;
if(!Pila_vacia())
{
res=pila[tope];
tope--;
}
else
{
System.out.println("pila vacia ");
res="no se pudo retirar";
}
return res;
}
public void Mostrar()
{
for(int i=tope; i>=0;i--)
{
System.out.println(pila[i]);
}
}
}
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
La pila puede representarse por

medio de:
Max = 5
Arreglos (memoria esttica)

Una vez definido el tamao del
arreglo no se cambia su tamao
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
Invertir una cadena de caracteres

utilizando una pila
Tenemos de entrada una cadena de caracteres => ana
Si la pila no esta llena, Almacenar carcter por carcter en la pila
a
l
i
p
Si la pila no esta vaca, retirar carcter por carcter de la pila para que
quede invertida
Cadena invertida =>
alip
Ejemplo invertir cadena

import java.io.*;
import java.util.*;
public class Invertir_cadena
{
public static void main(String args[]) throws IOException {
String cadena;
BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
System.out.print("Teclea una cadena ==> ");
cadena=stdin.readLine();
System.out.println();
Pilas_Mias pila1=new Pilas_Mias(5);
boolean Resins;
System.out.println("--Original--");
for(int i=0; i<cadena.length();i++)
{
Resins=pila1.Insertar_pila(new String (cadena.substring(i,i+1)));
if(!Resins)
{System.out.println("pila llena no se inserto el elemento "+cadena.substring(i,i+1));}
}
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();
}
}
}
Ejercicio
Modificar el programa anterior para dada una cadena,

verificar si esa cadena en un palndromo (invertido es
igual).
Ejemplo de palindromo
original
ANA
Invertida
ANA
ANA es un palndromo
public class palindromo

{
public static void main(String args[]) throws IOException
{
String cadena;
String pali="";
PALINDROMO
System.out.print("Teclea una cadena ==> ");

cadena=stdin.readLine();
Pilas_Mias pila1=new Pilas_Mias (cadena.length());
boolean Resins;
System.out.println("--Original--");
for(int i=0; i<cadena.length();i++)
{
Resins=pila1.Insertar_pila(new String (cadena.substring(i,i+1)));
if(!Resins)
{
System.out.println("pila llena no se inserto el elemento "+cadena.substring(i,i+1));
}
}
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;
}
}
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);}
}
}
De acuerdo al siguiente algoritmo,

realizar el programa en java
Algoritmo palindromo2
Var
inicio
Leer palabra
Desde i:=1 hasta largo (palabra)
insertar_pila(palabra[i])
Fin_Desde
Desde i:=1 hasta largo (palabra)
Si palabra[i]!=ret_pila(Dato)
salir
Fin_Si
Fin_Desde
Si pila_vacia entonces
imprime (si es palindromo)
De lo contrario
imprime(no es palindromo)
Fin _Si
public class palindromo2

{
{
String palabra;
System.out.print("Teclea una palabra ==> ");
palabra=stdin.readLine();
Pilas_Mias pila1=new Pilas_Mias(palabra.length());
for(int i=0; i<palabra.length();i++)
{
pila1.Insertar_pila(new String (palabra.substring(i,i+1)));
}
for(int i=0; i<palabra.length();i++)
{
if(palabra.substring(i,i+1).compareTo(pila1.retirar_pila().toString())!=0)
break;
}
if(pila1.retirar_pila().toString().compareTo("no se pudo retirar")==0)
System.out.println("La palabra SI es palindromo");
else
System.out.println("La palabra NO es palindromo");
}
}
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
Evaluar los parentesis

Expresion = ([(A+B)*(C+D)])
(
[
(
(
[
(
[
(
2
)
(
[
(
[
(
-1
public class Parentesis_Correctos

{
{
Pilas_Mias pila_parentesis=new Pilas_Mias(50);
String Expresion="";
String Caracter="";
boolean SI_ES=true;
String Ret="";
System.out.print("Escribe la expresion a evaluar ==> ");
Expresion=stdin.readLine();
for(int i=0; i<Expresion.length();i++)
{
Caracter=Expresion.substring(i,i+1);
if(Caracter.compareTo("(")==0 || Caracter.compareTo("[")==0)
{
pila_parentesis.Insertar_pila(new String (Caracter));
System.out.println("Insertar => " + Caracter);
}
else
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");
}
}
}
Resultados Correcto e incorrecto
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
Nivel mayor prioridad
Nivel menor prioridad
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-
Reglas para convertir de infija a

posfija o prefija
La ventaja de utilizar expresiones en notacin polaca

(posfija o prefija) radica en que no son necesarios los
parntesis para indicar el orden de operacin, ya que
esto queda establecido por la ubicacin de los
operadores de ms alta prioridad se ejecuta primero.
Si hubiera en una expresin 2 o mas operadores de

igual precedencia, se procesa de izquierda a derecha.
Las expresiones con parntesis se ejecutan primero
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
La transformacin inicia utilizando una pila en la que se almacenan los

operadores y los parntesis
La expresin se va leyendo carcter a carcter, los operandos pasan

directamente a formar parte de la expresin en 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
Si la prioridad es menor o igual se saca el elemento cima de la pila y se

vuelve a hacer la comparacin con el nuevo elemento cima
Los parntesis izquierdos siempre se meten en la pila con la mnima

prioridad. Cuando se lee un parntesis derecho, hay que sacar todos
los operadores de la pila pasando a formar parte de la expresin
postfija, hasta llegar a un parntesis izquierdo, el cual se elimina ya que
los parntesis no forman parte de la expresin
El algoritmo termina cuando no hay mas items de la expresin y la pila

esta vaca
Transformacin de expresiones infijas en

expresiones postfijas
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
Carcter A a la expresin; carcter * a la pila
AB
Carcter ( a la pila; carcter B a la expresin
ABC
Carcter + a la pila; carcter C a la expresin
+
(
*
El nuevo carcter leido es - , que tiene la misma prioridad que el

elemento cima de la pila + ; en consecuencia el estado de la pila es :
Y la expresion es:
ABC+
(
*
ABC+D
Carcter ( a la pila; carcter D a la expresin
ABC+DE
Carcter / a la pila; carcter E a la expresin
/
(
(
*
Expresin
ABC+DEF
A* (B+C-(D/E F)-G)-H
Carcter a la pila; carcter F a la expresion
Carcter ) provoca vaciar la pila hasta un (

La pila en este momento contiene
El nuevo estado de la pila es
/
(
(
*
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
(
*
Fin de entrada, se vacia la pila: ABC+DEF /-G-*H -
REGLAS PARA CONVERTIR EXPRESION INFIJA A

POSTFIJA
Se crea un string resultado donde se almacena la expresion postfija.

1.- Los operandos se agregan directamente al resultado
2.- Un parntesis izquierdo se mete a la pila y tiene prioridad o
precedencia cero (0).
3.- Un parntesis derecho saca los elementos de la pila y los agraga al
resultado hasta sacar un parntesis izquierdo.
4.- Los operadores se insertan en la pila si:
a) La pila esta vaca.
b) El operador en el tope de la pila tiene menor precedencia.
c) Si el operador en el tope tiene mayor precedencia se saca y
agrega al resultado (repetir esta operacion hasta encontrar un
operador con menor precedencia o la pila quede vacia).
5.- Cuando se termina de procesar la cadena que contiene la
expresin infija se vaca la pila pasando los elementos al
resultado.
Resultados de infijo a postfijo

(a+b)*c-b
a*(b+c-(a+b/c)-a)-b
Conversin de infija a prefija

La conversin se hace de la misma forma que de
infija a postfija, con las siguientes diferencias:
1.
2.
3.
Se lee la expresin a evaluar de derecha a

izquierda
El parntesis que cierra entra a la pila y lo
saca el parntesis que abre
Se invierte la solucin
Ejemplos
(x+z)*w/ty-v
+
)
*
/
+
-
/
-
*
-
Solucion 1 ->
)
*
-
)
*
-
vytw/zx+*-
Solucion 2 -> -*+xz/wtyv
*
-
Ejemplos
(A+B*C)/D*K1
Solucion 1 ->
1KD*CB*A+/
Solucion 2 ->
/+A*BC*DK1
Transformacin de expresiones infijas en

expresiones prefijas
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* -
Evaluacin de expresiones postfijas
Infija
=> 5*(6+2)-12/4
Postfija => 5,6,2,+,*,12,4,/,Smbolo

5
6
2
+
*
12
4
/
-
PILA
5
56
562
58
40
40 12
40 12 4
40 3
37
Evaluacin de expresiones postfijas
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
Expresion en postfijo =>
ab+
Crear una calculadora con las operaciones de

+,-,/,* de expresiones infijas, las opciones de
conversin a postfijo y su evaluacin.
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
de automviles esperando servicio en una gasolinera

Cola de clientes en una ventanilla del banco para pagar un
servicio
Cola de programas en espera de ser ejecutados por una
computadora.
Es una lista en la que las supresiones se realizan

solamente al principio de la lista y las inserciones
al final de la misma.
0
P
(PRIMERO)
U
(LTIMO)
PEPS = Primero Entrar - Primero Salir
Las colas abundan en la vida cotidiana:
TIPOS DE COLAS:
Cola simple: Estructura lineal donde los elementos

salen en el mismo orden en que llegan.
Cola circular: Representacin lgica de una cola simple

en un arreglo.
Cola Doble (Bicola): Estructura lineal en la que los

elementos se pueden aadir o quitar por cualquier
extremo de la cola (cola bidireccional).
Cola de Prioridades: Estructura lineal en la cual los

elementos se insertan en cualquier posicin de la cola y
se remueven solamente por el frente.
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
Las colas pueden ser representadas en

arreglos
de
una
dimensin
(vector)
manteniendo dos variables que indiquen el
FRENTE y FINAL de los elementos de la cola.
0
Frente
2
S
3
D
4
Z
Final
Cuando la cola esta vaca las variables frente y

final son nulos y no es posible remover elementos.
Cuando la cola esta llena ( frente = 0 y final = n-1)

no es posible insertar elementos nuevos a la cola.
Cuando se remueven elementos el frente puede

incrementarse para apuntar al siguiente elemento
de la cola.
Cuando no hay espacios libres al final del arreglo

los elementos pueden ser desplazados para
desocupar posiciones del arreglo o se puede
manejar una estructura circular.
Ejemplo: Suponer que usamos un arreglo de 5

posiciones.
Frent
e
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
Usando memoria dinmica: Listas ligadas.
Final
Frente
Definicin de un tipo abstracto: Cola

Insertar.- Almacena en la cola el elemento que se recibe
como paramtro.
Eliminar.- Saca de la cola el elemento que se encuentra al
frente.
Vaca.- Regresa un valor booleano indicando si la cola tiene
o no elementos (true si la cola esta vacia, false si la
cola tiene al menos un elemento).
Llena.- Regresa un valor booleano indicando si la cola tiene
espacio disponible para insertar nuevos elementos ( true
si esta llena y false si existen espacios disponibles).
Interface de un TDA llamado Cola:

interface ICola{
public boolean llena();
public boolean vacia();
public void insertar (Object elem);
public Object eliminar();
}
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.
Implementacion de la clase Cola

Sencilla
Ver ejemplo Cola.java
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
Cola Sencilla con la primera

solucion
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
EJERCICIO: Cola Sencilla con la

segunda solucin
Realizar el cambio para la solucin 2

ejemplo Cola_Sencilla
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
Funciona igual que la cola simple, pero optimiza

el uso de memoria (al reutilizar localidades
disponibles).
1) Inicialmente vaca
1
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
Ejemplo de cola circular

class ColaCirc max=3
InsColaCirc(A);
InsColaCirc(B);
InsColaCirc(C);
RetColaCirc();
RetColaCirc();
InsColaCirc(D);
InsColaCirc(F);
InsColaCirc(E); DESBORDAMIENTO
Ejercicio para clase
Modificar el programa anterior ColaCirc modificando y

agregando los mtodos:
ColaCirc_llena()
ColaCirc_vacia()
InsColaCirc(Object dato)
RetColaCirc()
Hacer un programa, que contenga un men para llamar

los mtodos de insercin y retiro de los elementos de la
cola circular.
BICOLA
Es una variacin del tipo de datos cola.
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
Operaciones Bsicas de una bicola

CrearB.- inicializa una bicola sin elementos
EsVaca.- Regresa un valor booleano indicando si la bicola tiene o no
elementos .
InsertarIZQ.- Aade un elemento por el extremo izquierdo.
InsertarDER.- Aade un elemento por el extremo derecho.
EliminarIZQ.- Devuelve el elemento Izquierdo y lo retira de la bicola.
EliminarDER.- Devuelve el elemento Derecho y lo retira de la bicola.
Representacion esttica
Se mantienen los elementos de la bicola
en un arreglo circular.
Se utilizan dos variables indice Izquierdo y
Derecho.
Restricciones en las bicolas
Restricciones de entrada: Es aquella que solo

permite inserciones por uno de los extremos,
pero permite la eliminacin por los dos
extremos.
Restricciones de salida: Es aquella que

permite inserciones por los dos extremos, pero
solo permite retirar elementos por un extremo.
Estructura tipo bicola

Frente: 2
Final: 4
luz
agua
ri
Al aadir el elemento sql por el frente:

Frente: 1
Final: 4
sql
luz
agua
ri
Puede eleiminar por el final:

Frente: 1
Final: 3
sql
luz
agua
Implementar la clase bicola
Problema:
El estacionamiento de las avionetas de un aeropuerto es en lnea,

con una capacidad de 12 avionetas.
Las avionetas llegan por el extremo izquierdo y salen por el extremo
derecho.
Cuando llega un piloto a recoger su avioneta, si esta no esta
justamente en el extremo de salida (derecho), todas las avionetas a
su derecha han de ser retiradas, sacar la suya y las avionetas
retiradas son colocadas de nuevo en el mismo orden en que
estaban.
La salida de una avioneta supone que las dems se mueven hacia
delante, de tal forma que los espacios libres del estacionamiento
estn en la parte izquierda.
El programa para emular este estacionamiento tiene como entrada

un carcter que indica una accin sobre la avioneta, y la matricula
de la avioneta.
La accin puede ser llegada (E) o salida (S) de avioneta.
En la llegada puede ocurrir que el estacionamiento este lleno, si es
as la avioneta espera hasta que se quede una placa libre, o hasta
que se d orden de retirada (salida).
Anlisis del programa
El estacionamiento va a estar representado por una bicola de salida

restringida Por qu? La salida siempre se hace por el mismo
extremo, sin embargo la entrada se puede hacer por los dos
extremos, y as contemplar la llegada de una avioneta nueva ,y que
tenga que entrar una avioneta que ha sido movida para que salga
una intermedia.
La lnea de espera para entrada de una avioneta (estacionamiento
lleno) se representa por una bicola a la que se aaden avionetas
por un extremo, salen para entrar en el estacionamiento por el otro
extremo.
Las avionetas que se mueven para poder retirar del
estacionamiento una intermedia se almacenan en una lista lifo
(pila); asi la ltima en entrar ser la primera en aadirse en el
extremo salida del estacionamiento y seguir en el mismo orden.
La restriccin de salida se refleja en que no es valida la operacin
retirar por el extremo de salida
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.
Cola de Prioridad en Java

java.util
Class PriorityQueue<E>
java.lang.Object
java.util.AbstractCollection<E>
java.util.AbstractQueue<E>
java.util.PriorityQueue<E>
Type Parameters:
E - the type of elements held in this collection
All Implemented Interfaces:

Serializable, Iterable<E>, Collection<E>, Queue<E>
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 containing the elements in the specified collection.

PriorityQueue(intinitialCapacity)
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)

PriorityQueue(SortedSet<? 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
Los nodos de las listas

Un nodo se divide en 2 partes:
Informacin: Contiene la informacin del elemento.
Enlace: Contiene la direccin del siguiente nodo de la
lista.
informacin enlace
Nodo
Procesar una lista:

1.
2.
Almacenar los datos

Manipular los datos
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
3. Los elementos no necesitan estar fsicamente

adyacentes en memoria
debido al uso de los
apuntadores o ligas.
Un apuntador es una variable que almacena una

direccin de memoria.
Se dividen en:
* Listas encadenadas (listas simples)
* Listas dobles
* Listas circulares
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:
* Una primera que contiene la informacin asociada al

elemento.
* Y la segunda, llamada campo de enlace o campo de
puntero, que contiene la direccin del siguiente elemento
de la lista.
Caractersticas de las Listas

Sencillas / Simples
Coleccin de elementos llamados nodos.

Existe un elemento llamado INICIO que apunta al primer
elemento de la lista.
Cada nodo en su campo enlace apunta al siguiente
elemento.
El ltimo elemento de la lista en su campo enlace
apunta a nulo.
Al principio el apuntador Inicio apunta a nulo.
Qu diferencias existen entre las listas y los arreglos?
Operaciones con listas sencillas:
Insertar: Agrega un elemento a la lista.
Eliminar: Retira un elemento de la lista.
Buscar: Busca un elemento en la lista.
Recorrer: Visita todos los elementos de la lista.
Vaca: Indica si la lista contiene o no elementos.
Insercin de Elementos en Listas
Consiste en agregar un nuevo nodo a la

Lista. Casos que se pueden presentar al
insertar:
Insertar
un nodo al inicio de la lista

Insertar un nodo al final de la lista
Insertar un nodo antes / despus de otro
Representacin de una lista encadenada:
P=Principio
(cabeza)
F=Fin
Puntero Principio: Contiene
la direccin de la posicin del
elemento inicial de la lista.
Contiene la Informacin
del elemento
Puntero Fin: Contiene la

direccin
del
elemento
siguiente al ltimo de la lista.
Primer ejemplo de una lista encadenada:

P = NULL
F = NULL
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
Quedara de la siguiente manera:

A
P
D
F
4) Insertar C
INSERCIN EN MEDIO
B
F
C

A
P
D
F
5) Eliminar la A
A
ELIMINAR AL PRINCIPIO
B

B
P
D
F
Borrar elementos de Listas

El inicio y el fin no se mueven de posicin
para no perder la lista.
Se utiliza una variable aux para
posicionarla en el nodo que se desee
borrar.
Se da como entrada algn dato de la lista
que se desee borrar.
Problemas bsicos en el borrado en

Listas
1. Que el nodo que se desee borrar este al
inicio de la lista:
Inicio
Aux
2.
Nota: Si se borra Aux se puede perder la Lista
Que el nodo que se desee borrar este al

medio de la lista:
Inicio
Aux
Nota: Si borro Aux se desconecta la lista
Problemas bsicos en el borrado en

Listas
3.
Que el nodo a borrar este al final de la

lista.
Inicio
Nota: Si se borra Aux se pierde el fin de la
Lista
Aux
Bsquedas de elementos en Listas
La operacin de bsqueda de un elemento en

una lista se realiza de modo secuencial.
Se deben de recorrer los nodos, tomando el
campo LIGA como puntero al siguiente nodo a
visitar.
Esta operacin esta implcita en algunos casos
de insercin y borrado, por que?
Agregar el mtodo de bsqueda a la tarea
Creacin de Listas en Java
Ver ejemplo lista2
Ejemplo: Alumnos
Crear
una lista sencilla

Agregar los siguientes datos:
01 luis ing 23
02 marta bio 20
Mostrar
lista
los elementos de la
Ejemplos con dibujos

Insertar al final
Hacer mtodo en java
Insertar al inicio
Hacer mtodo en java
Insertar en el medio
Hacer mtodo en java (nuevo)
Tarea:
Escribir la implementacin vista y agregar:

Mtodo
que indique si la lista esta vaca

Mtodo que regrese el numero de elementos
que contiene la lista
Hacer mtodo InsertaOrdNom, para que
inserte elementos en ordenados por nombre.
Ejercicio
Implementar una pila usando una lista
ligada.
La pila contiene nmeros enteros.
Que elementos (datos) se requieren?
Que mtodos se implementan?
tope
10
Implementacin de una pila de datos Integer usando una lista

class Pila_Lista {
class Nodo{
public Integer dato;
public Nodo enlace;
Nodo (Integer n){
dato = n;
enlace = null;
}
}
Nodo tope;
Pila_Lista(){
tope=null;
}
return (tope == null);
}
return false;
}
public Integer pop(){

if (tope != null) {
Nodo n = tope;
tope = tope.enlace;
return n.dato;
}
else ERROR;
}
public void push(Integer elem){
Nodo n = new Nodo(elem);
n.enlace = tope;
tope = n;
}
}
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
Implementacin de una cola de datos String usando una lista

class Cola_Lista {
class Nodo{
public String nombre;
public Nodo enlace;
Nodo (String n){
nombre = n;
enlace = null;
}
}
Nodo frente;
Nodo final;
Cola_Lista(){
frente=null;
final=null;
}
return (frente == null);
}
return false;
}
public void insertar (String e ){

Nodo n = new Nodo(e);
if (this.vacia() )
{
frente = n;
final = n;
} else {
final.enlace= n;
final = n;
}
public String eliminar(){
Nodo n = frente;
if (frente != null) {
frente = n.enlace;
return n.nombre;
}
else ERROR;
}
} // final de la clase
Continuar Ejemplo:
Lista sencilla
Alumnos.java
borrar_nodo(NC)
llena_lista(NC,Nom,Ca,E)
mostrar()
buscar(nc)
Otros tipos de Listas
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.
Representacin de una lista circular:
P=Principio
(cabeza)
F=Fin
del elemento

direccin de la cabeza (la
direccin
del
primer
elemento).
Ejemplo de lista sencilla circular
Alumnos2.java
llena_lista
(NC,Nom,Ca,E)
borrar_nodo(NC)
Recorrido(inicio,fin)
buscar(nc)
Reto: Representar la lista circular, tomando como

referencia la lista simple.
1) Lista circular vaca
2) Insertar el 5
(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:
Son aquellas en que cada elemento,

adems
de
su
informacin
correspondiente, contiene un puntero
con la direccin del siguiente elemento,
y un puntero con la posicin del
elemento anterior de la lista.
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
Listas Doblemente Ligadas

Una LDL es una estructura
lineal
de
elementos
llamados
nodos
los
cuales contienen enlaces
a elementos anterior y
siguiente de la lista.
El primer nodo contiene
nulo al elemento anterior
y
el
ultimo
nodo
contiene
nulo
al
siguiente elemento.
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
Representacin de una lista doble:

F=Fin
P=Principio
LI =Apunta al
anterior
LD =Apunta al
siguiente
del elemento

direccin
del
elemento
siguiente al ltimo de la lista.
Primer ejemplo de una lista doble:
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
Quedara de la siguiente manera

P
4) Insertar C
INSERCIN EN EL MEDIO
B
C
Se realiza una bsqueda primero para
encontrar la C y luego se procede a
eliminarla.
Cdigo para listas dobles

class Lista_Doble
{
public String ncontrol;
public String nombre;
public String carrera;
public int edad;
public Lista_Doble ligaizq;
public Lista_Doble ligader;
public void mostrar()
{
System.out.print(ncontrol + " "+nombre+" "+carrera+"
"+edad);
}
public class AlumnosDoble

{ // usa la clase de Lista Doble
public static Lista_Doble inicio;
public static Lista_Doble fin;
public static void llena_lista(String nc, String nom, String carr,int ed)
{ // inserta nodo en la lista doble
Lista_Doble nodo;
nodo= new Lista_Doble();
nodo.ncontrol=nc;
nodo.nombre=nom;
nodo.carrera=carr;
nodo.edad=ed;
nodo.ligaizq=null;
nodo.ligader=null;
if (inicio==null){
inicio=nodo;
fin=nodo;
}
else{
fin.ligader=nodo;
nodo.ligaizq=fin;
fin=nodo;
}
}
}
Como insertaras un nodo al inicio

de la lista doble?
Se crea el nodo y se inicializan las variables
nodo.ligader=inicio;
Inicio.ligaizq=nodo;
Inicio=nodo;
public static void MostrarD()

{
Lista_Doble aux=inicio;
while (aux!=null)
{
aux.mostrar();
aux=aux.ligader;
}
}
public static void MostrarI()
{
Lista_Doble aux=fin;
while (aux!=null)
{
aux.mostrar();
aux=aux.ligaizq;
}
}
public static void main(String args[])

{
llena_lista("1","anaa","ingenieria",23);
llena_lista("2","luis","ingenieria",24);
llena_lista("3","pepe","ingenieria",25);
llena_lista("4","rosa","ingenieria",26);
System.out.println("muestra la lista de inicio-fin");
MostrarD();
System.out.println("muestra la lista de fin-inicio");
MostrarI();
}
}
Borrar Elementos de LDL
Conceptos importantes para entender borrado:

nodo.ligaizq.ligader
nodo
Inicio
nodo.ligader.ligaizq
Inicio
es:
Fin
B
es:
nodo
Fin
5) Eliminar la A
P
ELIMINAR AL PRINCIPIO
B

P
Segundo ejemplo de una lista doble:
Se tiene la siguiente lista doble, que sucedera si

se eliminara la D.
ELIMINAR AL FINAL
P

P
Tercer ejemplo de una lista doble:
Se tiene la siguiente lista doble, que sucedera si

se eliminara la C.
ELIMINAR EN EL MEDIO
P

P
public static boolean borrar_fin()

{
boolean res=false;
Lista_Doble aux=inicio;
if (!esvacia())
{
if (aux==fin)
{
res=true;
}
else
{
while(aux.ligader!=fin)
{
aux=aux.ligader;
}
if(aux.ligader==fin) //el elemento esta en el fin
{
fin=aux;
aux=aux.ligader;
fin.ligader=null;
aux.ligaizq=null;
res=true;
}
else
res=false;
}
public static boolean esvacia()

{
if (inicio==null)
return true;
else
return false;
}
if (res)
{
if(aux==fin)
{
fin=null;
aux=null;
}
aux=null; // borro
elemento
}}
public static void main(String args[])

{
llena_lista("1","anaa","ingenieria",23);
llena_lista("2","luis","ingenieria",24);
llena_lista("3","pepe","ingenieria",25);
llena_lista("4","rosa","ingenieria",26);
System.out.println("muestra la lista de inicio-fin");
MostrarD();
System.out.println("muestra la lista de fin-inicio");
MostrarI();
borrar_fin();
MostrarD();
borrar_fin();
borrar_fin();
MostrarD();
}
}
Desplegar Datos en Listas
Tarea : Agregar a la clase AlumnosDoble, AlumnosCircular los mtodo

recorrido, insercin y borrado :
Recorrer la lista de Izquierda a Derecha

Recorrer la lista de Derecha a Izquierda
Insertar al inicio
Insertar al final
Insertar en medio
Borrar al inicio, final y en medio
Agregar a la clase Lista_Doble el campo sexo y obtener lo

siguiente:
Total de hombres y mujeres

El nombre del alumno de mayor edad.
El promedio de las edades.
Escribe un programa que lea un cadena del teclado e
insertar en una lista las vocales que contiene dicha
cadena, no se deben de insertar vocales repetidas
Puntos extras (investigar)
Hacer la simulacin con multilistas de un sistema

de archivos:
Crear
unidades (D:, C:, A:)

Las unidades podrn tener carpetas (Cero o mas)
Cada carpeta podr tener archivos (Cero o mas)
Hacer men que:
Agregue Unidades
Asigne Carpeta(s) a las unidades
Asigne Archivos a cada Carpeta
Tener
en cuenta que:
No se pueden repetir unidades

No se pueden repetir carpetas en cada unidad
No se pueden repetir archivos en cada carpeta
Estructura de Datos
Unidad 4. Recursividad
Recursion
Un metodo recursivo permite la definicion de

soluciones mas cortas y eficientes.
Una funcion o procedimiento recursivo es aquel
que se llama a si mismo ya sea directa o
indirectamente.
Ejemplos:
Factorial
Numeros
de Fibonacci
Torres de Hanoi
Algoritmos de Ordenamiento de datos
Etc.
La recursividad se puede presentar

de 2 formas:
Recursin directa: Es la que ocurre cuando una funcin

A realiza otra llamada a la funcin A.
Ejemplo:
public void A()
{
----------A();
----------}
La recursividad se puede presentar

de 2 formas:
Recursin indirecta: Sucede cuando la funcin A llama a la funcion B, que a su

vez, llama a la funcin A.
Ejemplo:
public void A()

{
----------B();
----------}
public void B()

{
----------A();
----------}
Control de secuencia de programas.

// Programa Principal
class Principal{
public static void proceso1(){
System.out.println(proceso1);
proceso2();
}
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
En muchos lenguajes de programcin, las

funciones, procedimientos o mtodos recursivos
se ejecutan mediante un pila de registros de
activacin.
Un registro de activacin de un mtodo contiene
el estado actual de todas las variables definidas
en el.
Ejemplo:
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:
Factorial: Es multiplicar un nmero por sus anteriores

mayor que cero. El producto de los enteros positivos
desde 1 hasta n.
Ejemplo:
3!= 3 * 2 * 1
4!= 4 * 3 * 2 * 1
4!= 4 * 3!
N!= n * n-1 * n-2 * * 3 * 2 * 1
Mtodo factorial sin recursividad

4! = 24
public static int factorial1(int n)
{
int res;
if(n==0)
return 1;
res=1;
for(int i=1; i<=n; i++)
res=res*i;
return res;
}
Res = 1
Res = 1*1 = 1
Res = 1*2 = 2
Res = 2*3 = 6
Res = 6*4 = 24
Mtodo factorial con recursividad

4! = 24
public static int factorial1(int n)
{
if(n==0)
return 1;
else
return n*factorial1(n-1);
}
Factorial1(4)
= 4*factorial1(3) = 24
Factorial1(3)
Factorial1(2)
Factorial1(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:
F(3) = F(2)+F(1) = 1+1 = 2

F(6) = F(5)+F(4) = 5+3 = 8
Mtodo fibonacci
public static int fibonacci(int n)
{
if((n==0) ||(n==1))
return n;
else
return fibonacci(n-1)+fibonacci(n-2);
}
Fib(5) -> fib(4) + fib(3) = 5

Fib(4) -> fib(3) + fib(2) = 3
Fib(3) -> fib(2) + fib(1) = 2
Fib(2) -> fib(1) + fib(0) = 1
Fib(1) -> 1 = 1
Fib(0) -> 0 = 0
La ejecucin de mtodos recursivos

consume tiempo y espacio, adems de
limitar el valor de n para el cual se puede
ejecutar el programa
La recursin debe evitarse si es posible
usar un ciclo repetitivo
Tarea
Elaborar una funcin recursiva que se llame potencia que va ha

recibir 2 parmetros. X es el numero base y Y es la potencia a
elevar.
x=2 y=3 = 8
Potencia(x,y)
2*2*2=8
Dame el numero base => 2

Dame el numero exponente => 3
La potencia es => 8
int potencia( int base, int exponente) {

if(exponente == 0) {
return 1
} else {
return base * potencia(base, exponente -1) // llamada recursiva
}
}
Torre de Hanoi
1.
2.
3.
4.
Es un juego clsico para la recursin consiste

en lo siguiente:
Tenemos n discos y 3 torres
Debemos de pasar todos los discos a la torre
C desde la torre A
No puede ponerse un disco arriba del otro de
menor tamao
La cantidad de movimientos permitidos se
calculan en 2-1
Ejemplo: Las torres de Hanoi
Elementos:
Tres
postes
N discos de diferentes tamaos
Reglas:
Mover
los n discos del poste A al poste C usndo el

porte B como intermediario.
Solo se puede mover un disco la ve.
Ningn disco puede colocarse encima de otro mas
pequeo.
Poste A
Poste B
Poste C
1
2
3
2
3
1
2
3
Como se puede mover

el disco ms grande?
4 discos
Mueve disco 1 de la torre A a la torre B

Mueve disco 2 de la torre A a la torre C
Mueve disco 1 de la torre B a la torre C
Mueve disco 1 de la torre C a la torre A
Mueve disco 2 de la torre C a la torre B
Mueve disco 2 de la torre B a la torre A
Mueve disco 1 de la torre C a la torre A
rboles
Introduccin
rboles
Son estructuras de datos No-Lineales y

Dinmicas.
Son No-Lineales por que cada elemento del

rbol puede seguirle varios elementos.
Son Dinmicas por que la estructura de un rbol

puede cambiar en tiempo de ejecucin.
rboles
Definicin de un rbol: Es una estructura jerarquica

aplicada sobre una coleccin de elementos llamados
nodos; uno de los cuales es conocido como raz
Definicin formal de un rbol : Un rbol de tipo T es

una estructura homognea resultado de la
concatenacin de un elemento de tipo T junto con un
numero finito de rboles disjuntos, llamados subrboles
Se crean diversas relaciones entre los distintos nodos de
un rbol: padre, hijo, hermano, antecesor, sucesor, etc.
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
Caractersticas de los rboles
Existe un nodo especial llamado raz.

Los nodos restantes se dividen en rboles mas
pequeos llamados subrboles.
La definicin de un rbol implica tener una
estructura recursiva (por la existencia de
muchos rboles).
La representacin de los rboles se realiza con
notaciones tpicas de los rboles genealgicos.
Propiedades de los rboles:

1.
2.
3.
4.
5.
Todo rbol que no es vaco tiene un nico nodo (por lo

menos).
Un nodo X es descendiente de un nodo Y, si el nodo
X es sealado (o apuntado por el nodo Y (X es hijo de
Y).
Un nodo Y es antecesor directo de un nodo X, si el
nodo Y apunta al nodo X.
Todos los descendientes directos de un mismo nodo
son hermanos.
hermanos
Todos los nodos que no tienen hijos son llamados
hojas.
hojas
Propiedades (cont..)
6.
7.
8.
9.
Todos los nodos que no son raz o terminales se les

conoce como nodos intermedios.
intermedios
El grado es un numero de descendientes directos de
un determinado nodo. Grado de un rbol es el mximo
grado de todos los nodos del rbol.
Nivel es el numero de arcos que deben ser recorridos
para llegar a un determinado nodo. La raz tiene nivel
1.
Altura del rbol:
rbol Es el mximo numero de niveles de
todos los nodos del rbol.
Ejemplo de conceptos de
rboles
Raz
Hijos
Padres
B
Hermanos
Hojas
D
I,E,J,K,G,L
Nodos Intermedios
Grados C 2
Grado del rbol 3

Nivel G 3
Altura del arbol 4
rbol Binario
En un rbol binario cada nodo puede tener

como mximo dos subrboles y siempre es
necesario distinguir entre el rbol izquierdo y
derecho.
Definicin formal de rbol binario: Es un
conjunto finito de nodos (M>=0), que es vaci
(M=0) o consta de un nodo raz con dos subrboles llamados sub-arbolizq y sub-arbolder.
Aplicaciones de rboles binarios:

Representacin en una estructura en la
cual se tienen 2 opciones (ifelse.)
rbol genealgico
Expresiones algebraicas
Etc.
Clasificacin de rbol binario

rboles Binarios Distintos
rboles Binarios Similares
rboles Binarios Equivalentes
rboles binarios completos
rboles Binarios Distintos
Dos rboles binarios son distintos

cuando sus estructuras son diferentes:
A
A
B
A
B
C
D
C
E
rboles Binarios Similares
Dos rboles binarios son similares cuando sus

estructuras son idnticas, pero la informacin
que contienen es diferente:
A
B
A
C
B
E
E
C
rboles Binarios Equivalentes
Dos rboles binarios son equivalentes si

tienen estructuras idnticas y contienen la
misma informacin.
A
B
A
E
B
D
E
C
rboles binarios completos
Un rbol binario completo es aquel en el

cual todos sus nodos (excepto las hojas)
tienen 2 hijos:
NumNodos= 2h-1
Donde h representa
la altura del rbol
rbol Binario de Bsqueda (ABB)
Es un tipo de rbol en el que todos los nodos tienen

elementos menores en su liga izquierda y elementos
mayores en su liga derecha.
Para todo nodo T del rbol:

Todos los valores de los nodos del subrbol izquierdo
son menor al valor del nodo T.
Todo los valores de los nodos del subrbol derecho son

mayor al valor del nodo T.
Nota: En un ABB NO deben existir elementos repetidos
Construir un ABB
Se toman los elementos de izquierda a derecha y se van

comparando con todos los nodos que correspondan (a la
izq. o der.) hasta que no exista un punto de comparacin.
Ver ejemplos.
1 3 2
31240
1
3
2
Una vez construido el rbol ser necesario consultar

(visitar) la informacin que contiene en sus diferentes
nodos. Para visitar los nodos se necesita recorrer el rbol
de forma sistemtica (solo una vez por nodo).
Existen tres formas para los recorridos:
Recorridos en un rbol binario:
Inorden
Preorden
Visitar el subrbol izquierdo en inorden

Visitar el nodo raz
Visitar el subrbol derecho en inorden
Visitar el nodo raz
Visitar el subrbol izquierdo en preorden
Visitar el subrbol derecho en preorden
Postorden
Visitar el subrbol izquierdo en postorden

Visitar el subrbol derecho en postorden
Visitar el nodo raz
Los datos quedan

ordenados de
forma ascendente
Ejemplo de los recorridos

Raiz
C,D,A,B,E,F,I,H
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
Insertar los siguentes datos en

un ABB y realizar sus recorridos
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)
{
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);
}
}
B,A,H,I,F,E,D,C
Bsqueda de datos en ABB

Funcionamiento:
Se
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
Bsqueda en ABB (Cdigo)
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 ");
}
public static boolean Busca(String dato, NodoArbol nodo)

{
if (nodo!=null)
{
if (nodo.claveart.compareTo(dato)==0)
{
return true;
}
else
{
if (nodo.claveart.compareTo(dato)>0)
{
return Busca(dato,nodo.LI);
}
else
{
return Busca(dato,nodo.LD);
}
}
}
return false;
}
Fin del curso!
Insercin de datos en ABB

Los
El
nodos se insertan siempre como nodos hoja
algoritmo de insercin garantiza para cada nodo del rbol que:

Su subrbol izquierdo contiene claves menores
Su subrbol derecho contiene claves mayores
Funcionamiento:
Si el rbol estuviera vaco, se inserta el nodo en la raz
Si no, se va recorriendo el rbol:
En cada nodo se decide si hay que insertar a la derecha o la
izquierda
Si el subrbol en que hay que insertar es vaco, se inserta el nuevo
elemento
Si el subrbol en que hay que insertar no es vaco hay que
recorrerlo hasta encontrar el lugar que le corresponde al nodo en
ese subrbol
El proceso de insertar un elemento es recursivo, y que la insercin es
en el subrbol izquierdo o derecho sigue la misma filosofa.
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
Insercin ABB (Cdigo)

InsertaABB
CreaNodo
class NodoArbol
{
public String claveart;
public String descripcion;
public float precio;
public NodoArbol LI;
public NodoArbol LD;
}
public static NodoArbol CreaNodo(String clave, String des, float pre)

{
NodoArbol nvo= new NodoArbol();
nvo.claveart=clave;
nvo.descripcion=des;
nvo.precio=pre;
nvo.LD=null;
nvo.LI=null;
return nvo;
}
NodoArbol nvo=CreaNodo("N", "", 2);

Raiz=nvo;
System.out.println("Se inserto "+Raiz.claveart);
InsertaABB("C",
InsertaABB("F",
InsertaABB("A",
InsertaABB("P",
InsertaABB("S",
"",
"",
"",
"",
"",
1,Raiz);
1,Raiz);
1,Raiz);
1,Raiz);
1,Raiz);
Borrado en ABB
Funcionamiento:
Buscar el nodo a borrar
Si es un nodo hoja (no tiene hijos), basta con eliminar el nodo

haciendo nulo el enlace del padre del nodo borrado.
Si no es nodo hoja hay que sustituirlo por otro

1. El nodo a borrar slo tiene un hijo: se elimina el nodo
reemplazando el enlace del padre del nodo con el enlace del hijo
del nodo.
2. El nodo a borrar tiene dos hijo:, sustituirlo por el nodo mas la
izquierda en el subrbol derecho del nodo o por el nodo que esta
mas la derecha en el subrbol izquierdo
.
El menor de su subrbol derecho

El mayor de su subrbol izquierdo
Si el nodo a borrar es la raz, hay que variarla aplicando el caso
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
Obtener el numero de elementos

Public int tamao(){
Return tamao(raiz);
}
Private int tamao(Nodo raiz){
if(raiz==null)
return 0;
else
return 1+ tamao(raiz.izquierdo)+ tamao(raiz.derecho);
}
Programa completo rboles
Tarea:
Implementar los mtodos vistos
Insercin,
recorridos, bsqueda, borrado (hacer)

Utilizar una plantilla que contenga nicamente un
dato numrico
Agregar los siguientes mtodos:
Mtodo que indique si el rbol esta vaco

Mtodo que regrese el numero de nodos del rbol
Mtodo que regrese el elemento mayor del rbol
Entregar un trabajo para calificar como

unidad con los siguientes puntos:
Algoritmos de Ordenamiento
Algoritmos de ordenamiento por Distribucin.
Intercalacin directa.
Mezcla natural.
Algoritmos de ordenacin externa.
Radix.
Algoritmos de ordenacin externa.
Burbuja.
Quicksort.
ShellSort.
Secuencial.
Binaria.
Hash.
Bsqueda externa.
Secuencial.
Binaria.
Continua
grafos!
Buena suerte en el examen final!

Estructura de Datos I (Ingenieria)

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Estructura de Datos I (Ingenieria)

Transféré par

Droits d'auteur :

Formats disponibles

Estructura de Datos

Objetivo general del Curso:

seleccionar y aplicar eficientemente

Relacin con otras asignaturas del plan de estudio:

Aportacin de la asignatura al perfil del

Unidad 1. Anlisis de algoritmos.

5.- Knuth Donald E.

2.- Mark Allen Weiss Mark

6.- Robert L. Krue

4.- Seymour Lipschutz

Evaluacin Escrita 80%

Elaboracin de Programas 20%

de investigacin/ participacin en clase

Los datos en una computadora se clasifican en:

Estructura de Datos: Es una coleccin de datos

Recorrido: Procesa c/elemento de la estructura.

Bsqueda: Recupera la posicin de un elemento

Insercin: Adiciona un nuevo elemento a la

Borrado: Elimina un elemento de la estructura.

Ordenacin: Ordena los elementos de la estructura

Mezcla: Combina 2 estructuras en una sola.

Unidad 1: Anlisis de algoritmos

Algoritmo: Es una secuencia de operaciones o

Complejidad de un algoritmo: es la funcin

Bsqueda secuencial: Recorre cada elemento, uno a

Bsqueda binaria: compara el nombre buscado con el

Es evidente que entre menos comparaciones se realicen

Lgica Selectiva: Utiliza un conjunto de

Lgica iterativa (flujo repetitivo): ciclos

Analizar algoritmos es la tarea mas

Factores que miden la eficiencia de

Por el tiempo de ejecucin

Por el espacio (memoria)

los pasos se enuncian con precisin.

Es difcil determinar la cantidad exacta de ejecucin de un

Como se codifico el programa

Que computadora se utilizara

Que datos debe utilizar el programa

A medida que crece un elemento del programa, generalmente

Para determinar la eficiencia de un programa debemos de considerar:

En ocasiones pueden existir varios algoritmos para resolver una aplicacin

velocidad de operacin de la computadora en que se ejecuta. Es diferente

compilador utilizado (calidad del cdigo generado). Cada compilador

estructura del algoritmo para resolver el problema.

En la solucin 2, lo ideal, al hacer la evaluacin de la eficiencia del

Esto implica que, por ms que se conozca el tamao de los datos de

Usualmente el anlisis de un algoritmo incluye:

que tan cerca al caso promedio trabaja el algoritmo,

Nosotros trabajaremos con el TA(n) en el peor de los casos (O), ya que es

O(n) es mas eficiente que el O(n2)

O(log n) es mas rpido que O(n log n) y

Significa que la mayora de las instrucciones se ejecutan una vez o muy

Este teorema expresa una de las bases del anlisis de algoritmos: lo

Una asignacin que no

for( j=0 ; j<n ; j++)

Tal que TA2 es O(f2(n)) y TA1 es O(f1(n)),

el tiempo de ejecucin del programa

Completo TA(n)=TA1(n) * TA2(n) es O(f1(n) * O(f2(n))

for(i=0; i<5 ; i++)

El tiempo de ejecucin va a depender, del tamao del N.

for (int i= 0; i < N; i++) {

for (int j= 0; j < N; j++) {

for (int i= 0; i < N; i++) {