UNIVERSIDAD AUTONOMA GABRIEL RENE MORENO

FACULTAD DE CIENCIAS EXACTAS Y TECNOLOGIAS

Carrera de Ingeniería Informática

Seminario de Grado
Modulo: Algoritmos y Estructura de Datos

“Tema 7. Pilas y Colas (Stack and Queues)”

Docente: Ing. Ubaldo Pérez Ferreira

E-mail: ubaperez@gmail.com

Santa Cruz de la Sierra – Bolivia ©

2008
Abstracción

• Abstraer: Eliminar lo irrelevante y

quedarnos con lo realmente
importante.

• ¿Qué es lo importante?
– En cada parte del trabajo puede serlo
cosas distintas

• Para llevar a cabo la abstracción los

lenguajes nos proporcionan
mecanismos:
– Módulos, clases, genericidad, ocultación,
Abstracción

• El diseño de programas está basado en

el uso de abstracciones. Se trata de:

• 1. Identificar los subproblemas.

• 2. Especificación abstracta de cada uno de
ellos.
• 3. Implementar cada abstracción.
• 4. Verificación del programa.
Especificaciones informales.

La descripción de una abstracción se realiza con un lenguaje

natural (ambiguas e imprecisas).

Notación de espeficicación:
Partes que debe tener la especificación,
Significado y tipo de cada parte,
Partes que pueden ser opcionales, ...
Especificaciones informales.

• Notación
• Operación <nombre> (ent <id>: <tipo>;...; sal
<tipores>)

– Requiere: establece restricciones de uso.

– Modifica: identifica los datos de entrada que se
modifican.
– Calcula: descripción textual del resultado de la
operación.
– Requiere y Modifica, y los parámetros de entrada y
salida son opcionales.
– Puede ser parametrizada:
– Operación <nombre> [<id>:<tipo>;...] (...
Especificaciones informales.

Ejemplo: concatenar dos cadenas.

 
– Operación concat (ent a,b: cadena; sal c:
cadena)
– Calcula: la cadena de salida c es una
nueva cadena que contiene los caracteres
de a (en el mismo orden) seguidos de los
caracteres de b (en el mismo orden).
Especificaciones Formales.

Notación
La descripción formal constará de cuatro partes:
NOMBRE. Nombre genérico del TAD.
CONJUNTOS. Conjuntos de datos que intervienen
en la definición.
SINTAXIS. Signatura de las operaciones definidas.
<nombre_operación> : <conj_dominio> →
<conj_resultado>
SEMÁNTICA. Indica el significado de las
operaciones.
Especificaciones Formal – Numeros Naturales

NOMBRE natural
• CONJUNTOS N conjunto de naturales, B conjunto de valores
booleanos
• SINTAXIS
• cero: → N
• sucesor: N → N
Funciones
• escero: N → B
• igual: N x N →B
• suma: N x N →N
• SEMANTICA ∀ m, n ∈ N
• 1. escero (cero) = true
• 2. escero (sucesor (n)) = false
• 3. igual (cero, n) = escero (n) Axiomas
• 4. igual (sucesor (n), cero) = false
• 5. igual (sucesor (n), sucesor (m)) = igual (n, m)
• 6. suma (cero, n) = n
• 7. suma (sucesor (m), n) = sucesor (suma (m, n))
Especificación Formal - Arreglos

Structure Array(Value,index)
Declare Create()  Array
Retrive(Array,Index)  Vakue
F Store(Array,Index,Value)  Array
Funciones

Swap(Array,Index,Index)  Array
Equal(index,index) Bolean

∀ A ∈ N i , j ∈ Index, x ∈ Value

Retrieve(Create,i)::= error
A Retrieve(Store(A,i,x),j)::= Axiomas
If Equal(i,j) Then x Else Retrieve(A,j)
Especificación Formal – TAD Polinomios

P(x) = 5x3 + 3x2 – 2x + 2

Operaciones
Evaluar P(2) = 50
Operaciones Binarias: C, P, Q ∈ Polinomios
C(x) = P(X) + Q(X)
Especificación Formal – TAD Polinomios

Podemos Especificar un TAD para los Polinomios

Structure Polinomio
Declare Zero()  Poly //Define polinomio

Iszero(Poly)  Boolean //Esta vació el Polinomio

Coef(Poly, exp)  coef //Obtiene el coef. del Polinomio

F Attach(Poly, coef, exp)  Poly //Adiciona un elemento al Polinomio

Rem(Poly, exp)  Poly //Elimina un elemento del Polinomio

Smult(Poly, coef, exp) Poly // Multiplicación por un monomio

Add(Poly, Poly) Poly //Adición de Polinomios

Mult(Poly, Poly)  Poly //Multiplicación de Polinomios

Especificación Formal – TAD Polinomios

∀ P,Q ∈ Poly c , d ∈ coef, e,f ∈ exp

Rem(Zero, f)::= Zero

Rem( Attach( P, c, e ),f)::=
If e=f Then Rem(P,f) Else Attach(Rem(P,f),c,e)
Iszero(Zero)::=true
Iszero(Attach(P,c,e))::= If Coef(P,e)=-c then Iszero(Rem(P,e)) else false
Coef(Zero,e)::=0
A Coef(Attach(P,c,e),f)::= If e=f then c + Coef(P,f) else Coef(P+f)
Smult(Zero,d,f)::=Zero
Smult(Attach(P,c,e),d,f)::= Attach(Smult(P,d,f), cxd, e+f)
Add( P, Zero )::=P
Add(P,Attach( Q,d,f))::=Attach(Add(P,Q),d,f)
Mult(P,Zero)::=Zero
Mult(P,Attach(Q,d,f))::= Add(Mult(P,Q),Smult(P,d,f)
Ejercicio de Especificación Formal – TAD Polinomios

Dado el Polinomio P(x)= 3x6+2x4+3 y el polinomio Q(x)=3x-1 cual es el

resultado de aplicar las siguientes expresiones utilizando las Funciones y
Axiomas del TAD Polinomio
Rem(P, f)
Rem(Attach(P,-8,5,),0)
Iszero(Attach(P,0,0))
Smult(Zero,3,6)
Smult(Attach(P,2,2),1,1)
Attach(Smult(P,1,1), 1*2, 2+1)
Add( P, Zero )
Add(P,Attach( P,3,2))
Attach(Add(P,Q),3,2)
Mult(P,Zero)
Mult(P,Attach(Q,4-2,3))
Add(Mult(P,Q),Smult(P,4-2,3)
Ejercicio de Especificación Formal – TAD Polinomios

Dado el Polinomio P y Q, diseñar el algoritmo para sumar dos polinomios (AddPoly),

utilizando las Funciones y Axiomas del TAD Polinomio. Se debe considerar la función
Exp(Poly) la misma que obtiene el grado de un polinomio o exponente mayor.

Procedurre AddPoly()
C= Zero
While NOT (IsZero(A) and IsZero(B)) do
Case
:Exp(A)<Exp(B)
C=Attach(C, Coef(B,Exp(B)),Exp(B))
B=Rem(B,Exp(B))
:Exp(A)>Exp(B)
C=Attach(C,Coef(A,Exp(A)),Exp(A))
A=Rem(A,Exp(A))
:Exp(A)=Exp(B)
C=Attach(C,Coef(A,Exp(A))+ Coef(B,Exp(B)),,Exp(A))
A=Rem(A,Exp(A))
B=Rem(B,Exp(B))
End Case
End while
TAD – PILAS (Stacks)

Ilustración
Vehículos en un calle sin salida

A4 A3 A2 A1

Descripción. Una pila es una lista especial en la cual todas las inserciones y
eliminaciones tiene lugar en un extremo denominado Tope.

Tope

Es una lista de tipo LIFO (Last-in First-out)

Especificación Informal del TAD – PILAS (Stacks)

Sea S una Pila, a menudo se incluye las siguientes operaciones

Create(S)
Creas una Pila S, se debe asegurar que S no exista.

Drop(S) Destruye la Pila S, es decir la Pila ya no existe.

Toma el elemento Tope de la Pila, sin sacarlo de ella,

Top(S) la Pila S debe existir y ≠ 0 .

Elimina el elemento Tope de la Pila, la Pila S debe

Delete(S) existir y ≠ 0 .

Vacia(S) Devuelve TRUE si S no contiene elemento, de lo

contrario FALSE.

Inserta el elemento i en la parte superior de S, el

Add(i, S) anterior Tope se convertirá en el siguiente elemento.
La Pila S debe existir.
Especificación Forma del TAD – PILAS (Stacks)

Structure Stack(item)
Declare Create()  Stack
Add(item, Stack)  Stack Funciones

F Delete(Stack)  Stack
Top(Stack)  item
Vacia(Stack) Bolean

∀ s ∈ Stack i ∈ Item
Vacia(Create(S))::= error
Vacia(Add(i,S))::= false
Axiomas
A Delete(Create(S))::=error
Top(Create(S))::=error Pila= D, F , A
Top(Add(i,S))::=i

D= stack, item,boolean
Implementación de TAD – PILAS usando vectores

1 2… max

top=0

Const
max = 100
Type
Pila = record
elemento: Array[1..max] of tipo_elemento
top :int
End record
Implementación de TAD – PILAS usando vectores

Function Create(var P: Pila) Function Vacia(var P: Pila): boolean

P.tope=0 if P.top=0 then
End function Vacia = True
return
Function Drop(var P:Pila) else
P.top=0 Vacia=false
End Function return
end if
End function

Function Top(var P:Pila): Tipo_elemento

Top=P.elemento[P.top]
End Function
Implementación de TAD – PILAS usando vectores

Function Add(var E:Tipo_elemento, P: Pila)

P.top=P.top + 1
P.elemento[P.top]=E
End function

Function Delete(var P:Pila)

P.top=P.top - 1
End Function
TAD – COLAS (Queue)

Ilustración
Vehículos en una gasolinera

A4 A3 A2 A1

Descripción. Una cola es una lista especial en la cual los elementos son
insertados en un extremo (posterior, rear) y son eliminados en el otro
extremo (frente, front) .

Front
(Elimina)
Es una lista de tipo FIFO (First-in First-out)

Rear
(Inserta)
Especificación Informal del TAD – COLA

Sea Q una Cola, a menudo se incluye las siguientes operaciones

Create(Q)
Creas una cola Q, se debe asegurar que Q no exista.

Drop(Q) Destruye la Cola Q, es decir Q ya no existe.

Toma el primer elemento de Q, sin sacarlo de ella, Q

Front(Q) debe existir y ≠ 0 .

Elimina el elemento del Front de Q, además Q debe

Delete(Q) existir y ≠ 0 .

Vacia(Q) Devuelve TRUE si Q no contiene elemento, de lo

contrario FALSE.

Add( Q, E) Inserta el elemento E en la parte posterior de Q.

Especificación Forma del TAD – COLA

Structure Cola(item)
Declare Create()  Cola
Add(item, Cola)  Cola Funciones

F Delete(Cola)  Cola
Front(Cola)  Cola
Vacia(Cola) Bolean
Especificación Forma del TAD – COLA

∀ Q ∈ Stack i ∈ Item
Vacia(Create(Q))::= true
Vacia(Add(i,Q))::= false
Axiomas
Delete(Create(Q))::=error
A Delete(Add,(i,Q))::=if Vacia(Q) then Create(Q) else Add(i,delete(Q))
Front(Create(Q))::=error
Front(Add(i,Q))::=if Vacia(Q) then i else Front(Q)

D= cola, item, boolean Cola= D, F , A

Implementación de TAD – COLA usando vectores

1 2… max
Q

top=0
Const
max = 100
Type
Cola = record
elemento: Array[1..max] of tipo_elemento
rear :int
front :int
End recor
 Implementación de TAD – COLA usando vectores

Function Vacia(var Q: Cola): boolean

Function Create(var Q: Cola) if Q.front = Q.rear then
Q.tope = 0 Vacia = True
Q.front = 0 else
End function Vacia=false
end if
Function Drop(var Q:Cola) End function
Q.tope = 0
Q.front = 0 Function Front(var Q:Cola): Tipo_elemento
End Function If Vacia(Q) then
error “Cola vacia”
else
Front=Q.elemento[Q.front + 1]
end if
End Function
Implementación de TAD – COLA usando vectores

Function Add(var i:Tipo_elemento, Q: Cola)

if Q.rear = max then
Mensaje “Pila llena”
else
Q.rear = Q.rear + 1
Q.elemento[Q.rear] = i
Function Delete(var Q:Cola)
end if
if Q.front = Q.rear then
End function
Mensaje “Pila vacia”
else
Q.front = Q.front + 1
end if
End Function
Implementación de TAD – COLA CIRCULAR usando
vectores

1 2… max
Q

front=rear=max
Existe un problema cuando rear = max, ya no se pueden adicionar mas datos

Solucion PILA
CIRCULAR!!!
n-3
2
n-2
1 n-1
0

Estado inicial de la Cola Q

Implementación de TAD – COLA CIRCULAR usando
vectores

Para que gire la COLA

If Q.rear = n-1 then
Q.rear = 0
n-3
2
n-2
Else
1 n-1
0
Q.rear=Q.rear + 1
End if

Otra forma de hacer girar la COLA

(Q.rear + 1) mod n // para el rear
(Q.Front + 1) mod n // para front
Implementación de TAD – COLA CIRCULAR usando
vectores

Los Algoritmos Add y Delete quedarian de la siguiente manera

Function Add(var i:Tipo_elemento, Q: Cola)

Q.rear = (Q.rear + 1) mod n
if Q.front = Q.rear then Function Delete(var Q:Cola)

Mensaje “Pila llena” if Q.front = Q.rear then

else Mensaje “Pila vacia”

Q.elemento[Q.rear] = i else

end if Q.front = (Q.Front + 1) mod n

end if
End function
End Function

Al ejecutar Add y Delete nos econtramos con un problema

cuando Q.front = Q.rear ¿Esta llena o vacía la Cola?
Implementación de TAD – COLA CIRCULAR usando
vectores

Mejorando los algoritmos Add y Delete cuando Q.front=Q.rear, se adiciona

un contador c Function Add(var i:Tipo_elemento, Q: Cola)
if Q.c=n then
Const Mensaje “Cola llena”
max = 100 else
Q.rear = (Q.rear + 1) mod n
Type
Q.elemento[Q.rear] = i
Cola = record Q.c = Q.c + 1
elemento: Array[1..max] of end if
tipo_elemento Function Delete(Q: Cola)
if Q.c=0 then
rear: int
Mensaje “Cola vacio”
front: int
else
c: int Q.front = (Q.front + 1) mod n

End recor Q.elemento[Q.rear] = i

Q.c = Q.c - 1
end if
Hacer la prueba de escritorio!!!!
MULTIPLES PILAS y COLAS

¿Que pasa si se requiere mas de una Pila o mas de una Cola o ambas ?
Respuestas: Definir tal vez tantas pilas y colas se requieran
S1(1:n1)
S2(1:n2)
Q1(1:n1) y un conjunto de funciones para cada una
Ejemplo para dos Pilas

a) b)
1 2… n1 1 2… m

S1 V
top1=0 top2=0
top1=0
Para desarrollar
1 2… n2
¿Cuándo esta vacia? If top1, top2 = 0
S2
¿Cuándo esta llena? If top1+1 = top2
top2=0 ¿Cómo hacer las funciones Add y Delete?
MULTIPLES PILAS y COLAS

Que sucede si queremos alamcenar n Pilas

1 2… m
V El tamaño de cada pila Si será │m/n │

S1 s2 … Sn
1≤i≤n

Se utilizaran dos arreglos adicionales

B(1:n+1) para almacenar el inicio y el fin de las pilas
Si = B(i) a B(i+1) tamaño de cualquier Si
T(1:n+1) para almacenar el estado del puntero Top de cada pila Si
Al crear las n pilas el estado de B y T sera:
B(i) = T(i) = │m/n │(i-1) 1≤i≤n
Para B(n+1) = m por si existe division fragmentada de │m/n │
MULTIPLES PILAS y COLAS

Algunas consultas sobre multiples Pilas

¿Cuál es el espacio libre de cualquier pila Si?

Xi = B(i+1) – T(i)
¿Cuál es el espacio disponible en toda la lista V?
n

ed = ∑i=1 X i

¿Cuántas celdas ocupadas existen V?

edv = m – ed
¿Cuándo esta vacia una pila Si?
if T(i) = B(i) then
¿Cuándo esta vacia una pila Si?
if T(i) = B(i+1) then
MULTIPLES PILAS y COLAS

Los algoritmos para Add y Delete para multiples Pilas

Add(x,i)
if T(i) = B(i+1) then
mensaje “pila llena”
n
else
Xi
i=1 T(i) = T(i) + 1
V(T(i)) = x
end if Desarrolle Múltiples Colas!!!!!
Implementar Add y Delete
Delete(i)
Que pasa si tengo Cola Circular
if T(i) = B(i) then
mensaje “pila vacia”
else
T(i) = T(i) - 1
end if