ED Cap4 PilasColas12010

Estructura de Datos
Pilas Colas
Prof.: Mauricio Solar
Prof.: Lorna Figueroa
Primer Semestre,
2010
Universidad Tcnica Federico Santa Mara - Departamento de Informtica
Indice
TDA: Pilas
TDA: Colas
Colas de Prioridad
Anillos
BiColas
BiColas Circulares
Pilas - Stack
Una de las estructuras de datos ms primitivas y ms antiguas en
la ciencia de los computadores.
A pesar de ser tan simple, es esencial en los compiladores,
SS.OO., etc.
Se pueden representar como una lista lineal que crece y decrece
por el mismo extremo.
El ltimo elemento que se incorpora a la estructura, es el
nico que se puede consultar y eliminar.
LIFO
Entrada
Salida
trabajos
Pilas - Stack
Es un tipo lineal de datos, secuencia de elementos de un tipo,
una estructura tipo LIFO (Last In First Out) ltimo en entrar
primero en salir.
Son un subconjunto de las listas, en donde las eliminaciones e
inserciones se realizan en un solo extremo.
LIFO
Entrada
Salida
trabajos
Aplicaciones de las Pilas

Aplicaciones Directas:
Histrico de pginas visitadas en un browser de web.
Secuencia de undo en un editor de textos.
Cadena de llamadas a mtodos en JVM o medioambiente
runtime en C++
Parsers en Compiladores (reconocedores sintcticos).
SSOO.
Convertir notacin infija a posfija o prefija.
Implementacin de recursividad.
Aplicaciones Indirectas:
Estructuras de datos auxiliares para algoritmos
Componentes de otras estructuras de datos.
Ejemplo Aplicacin de las pilas
Suponga que se quiere evaluar una expresin aritmtica,

mediante un proceso que se basa en guardar dicha expresin en
dos pilas:
una de operadores (+, -, * y /) y
otra de operandos (nmeros naturales).
Ejemplo Aplicacin de las pilas
El mtodo consiste en seguir el siguiente proceso de forma

reiterada:
1. Si la pila de operadores est vaca, la cima de la de operandos
contiene el resultado final.
2. En caso contrario, tomar los dos operandos de la cima de la
pila y operarlos segn el operador de la cima de la otra pila.
El resultado colocarlo en la cima de la pila de operandos.
*
+
4
2
3
1
8
3
1
Iteracin 1
5
1
Iteracin 2
9
Iteracin 3
Definicin del TAD Pilas

Se definir la semntica de las operaciones del TDA Pila en
trminos de las operaciones del TDA Lista.
Operaciones:
CrearPilaVaca( P )
PilaVaca( P ) B
Apilar( x, P )
Desapilar( P )
Tope( P ) E
apilar

CrearPilaVaca:
CrearPilaVaca:Pila
PilaPila
Pila
CrearPilaVaca(P)
CrearPilaVaca(P)==CrearListaVaca(P)
CrearListaVaca(P)
Invocacin:
Invocacin:CrearPilaVaca(P)
CrearPilaVaca(P)
PilaVaca:
PilaVaca:Pila
PilaLgico
Lgico
PilaVaca(P)
PilaVaca(P)==ListaVaca(P)
ListaVaca(P)
Invocacin:
Invocacin:PilaVaca(P)
PilaVaca(P)
Apilar:
Apilar:Elemento
ElementoxxPila
PilaPila
Pila
Apilar(
Apilar(x,x,PP))==Insertar(
Insertar(x,x,Primera(P),
Primera(P),PP))
Invocacin:
Invocacin:Apilar(x,P)
Apilar(x,P)
desapilar
tope

Desapilar:
Desapilar:Pila
PilaPila
Pila
Desapilar(
Desapilar(PP)){{
Si
Si(no
(noListaVaca(P))
ListaVaca(P))
Eliminar(
Eliminar(Primera(P),
Primera(P),PP))
sino
sinoError
Error
}}
Invocacin:
Invocacin:Despilar(P)
Despilar(P)

Tope:
Tope:Pila
PilaElemento
Elemento
Tope(
Tope(PP)) {{
Si
Si(no
(noListaVaca(P))
ListaVaca(P))
Retornar(
Retornar(Recuperar(Primera(P),
Recuperar(Primera(P),P)
P)))
Sino
Sino Error
Error
}}
Invocacin:
Invocacin:Tope(P)
Tope(P)
Aplicaciones con TAD Pila

void
voidMostrarPila(Pila
MostrarPila(Pila P)
P){{
Pila
p1;
Pila p1;
CrearPilaVacia(
CrearPilaVacia(p1
p1))
PasarPila(
////definirla
PasarPila(P,
P,p1
p1))
definirla
mientras
mientrasno
noPilaVacia(
PilaVacia(p1
p1)){{
Imprimir(
Imprimir(Tope(p1)
Tope(p1)))
Apilar(
Tope(p1),
Apilar( Tope(p1),PP))
Desapilar(
Desapilar(p1
p1))
}}
}}
Aplicaciones con TAD Pila

Pila
PilaPasarPila(
PasarPila(Pila
PilaOrigen
Origen)) {{
Pila
PilaDest;
Dest;
mientras
mientras(no
(noPilaVacia(
PilaVacia(Origen
Origen))))
Apilar(
Apilar(Tope(Origen),
Tope(Origen),Dest
Dest))
Desapilar(
Desapilar(Origen
Origen))
}}
return
returnDest;
Dest;
}}
PILAS
La representacin grfica de una pila es como la de cualquier
estructura dinmica:
tope
...
NULL
PILAS Implementaciones
typedef struct nodoP {
tElemento info;
struct nodoP* sig;
}
Las pilas se implementan como una lista enlazada simple.
El puntero de la lista (el tope) apunta al primer nodo de la
pila.
tope
a1
a2
pila
an
boolean
booleanEstaVacia
EstaVacia(struct
(structnodoP*
nodoP*tope)
tope) {{
return
return(tope
(tope
sig
sig====NULL);
NULL);
////Verdadero
Verdaderosisiest
estvaca
vaca
}}
void
voidPush
Push(tElemento
(tElementox,
x,struct
structnodoP*
nodoP*tope)
tope) {{
struct
structnodoP*
nodoP*q;
q;
qq==(struct
(structnodoP*)
nodoP*)malloc
malloc(sizeof
(sizeof(struct
(structnodoP));
nodoP));
qq
////almacena
info
info==x;
x;
almacenaelelelemento
elemento
qq
////enlaza
sig
sig==tope;
tope;
enlazaalalnodo
nodocon
conelelresto
resto
tope
////yylo
tope==q;
q;
lopone
poneen
enlalacabeza
cabeza
}}
tElemento
tElementoPop
Pop(struct
(structnodoP*
nodoP*tope)
tope) {{
struct
structnodoP*
nodoP*temp;
temp;
tElemento
tElementox;
x;
ifif(EstaVaca(tope))
(EstaVaca(tope))
printf
printf(Error:
(Error:pila
pilavaca);
vaca);
else
else {{
xx==tope
tope
info;
info;
temp
temp==tope;
tope; ////Se
Seeliminar
eliminareleltope
tope
tope
tope==tope
tope
sig;
sig;
free(temp);
free(temp);
return(x);
return(x);
}}
}}
Ejemplo
1000
100
100
100
100
10
10
10
10
10
push(10)
push(100)
push(1)
pop()
push(1000)
100
10
pop()
Expresiones infijas, prefijas, postfijas

Ejemplo de suma de dos operandos:
Infija A + B (operador va entre operandos )
Prefija o polaca + A B
(operador va antes que
operandos)
Postfija o polaca inversa A B + (operador va despus de
operandos)
Solo existe una expresin prefija y una postfija para cada
expresin algebraica.
Para evaluar estas expresiones se usan las pilas.
Notacin polaca inversa (postfija)

2
Para evaluar la expresin aritmtica: b b 4 a c
2a
Se sigue el orden indicado por las flechas, (segn prioridad

de operadores y uso de parntesis).
(b + (b^2 4 * a * c) ^ 0.5) / (2 * a)
Notacin polaca inversa (postfija)

Para eliminar esta dificultad, se hace una traduccin de las
expresiones aritmticas a notacin postfija.
Esta notacin tiene la ventaja de que las operaciones
aparecen en el orden en que se efecta realmente la
evaluacin.
Notacin postfija
La idea bsica detrs de la notacin de cadenas polacas es que
los operadores se escriben al final y no en medio de las
expresiones.
A + B se escribe como A B +.
En esta forma, el operador + se considera como una
instruccin para sumar los valores de las dos variables que
lo preceden inmediatamente. Ejemplo:
La clave de la traduccin de notacin infija a posfija es la

prioridad de los operadores: ( ), + -, * /, ^
Notacin postfija
Reglas bsicas para convertir expresiones infijas a posfijas:
1. Si el elemento es un ( se coloca directamente en la pila de
operadores.
2. Si el elemento es un ), los operadores de la pila se transfieren
uno a uno, al extremo derecho de la expresin posfija hasta
llegar a un (. Este se saca pero no va a la salida.
3. Si el elemento localizado es una variable, se coloca
inmediatamente en el extremo derecho de la expresin posfija
que se est creando.
4. Si el elemento es un operador y es de menor precedencia que
el operador en la pila, el operador de la pila se saca y va a la
salida, continuando de esta manera hasta encontrar un ( o
hasta que el operador de la pila sea de menor precedencia.
Cuando esto ocurre, el operador en turno se apila.
Conversin infija a postfija

Ecuacin cuadrtica
b b 2 4 a c
2a
En notacin infija:
( -b + ( b ^ 2 4 * a * c ) ^ ( 1 / 2 ) ) / ( 2 * a )
En notacin postfija:
-b b 2 ^ 4 a c * * 1 2 / ^ + 2 a * /
Algoritmo
1.
2.
Implementar la pila
Repetir hasta encontrar el fin de la expresin postfija
Tomar un carcter.
Si el carcter es un operando colocarlo en la pila.
Si el carcter es un operador entonces sacar los dos
valores del tope de la pila (operando2 operando1), aplicar
el operador (operando1 operador operando2) y colocar el
resultado en el nuevo tope de la pila.
Estructura de datos y organizacin de archivos. Mary

E. Loomis. Prentice Hall. 2a Ed.
www.itlp.edu.mx/publica/tutoriales/estru1/33.htm
thales.cica.es/rd/Recursos/rd99/ed99-0636-03/notacion_polaca.html
Algoritmo para evaluar una expresin postfija
Para evaluar una expresin postfija con pilas:

i=1
Mientras i < Longitud(expresion)
si expresin[i] es operando
Insertar expresion[i] en la pila
sino {es operador}
Extraer dos elementos de la pila
operarlos segn el operador,
insertar el resultado de nuevo en la pila
FinMientras
valor = cimaPila
Aplicacin: Invertir una Pila
nodoP
nodoPInvPila(nodoP
InvPila(nodoP*tope)
*tope) {{
//// Funcin
Funcinque
queinvierte
invierteuna
unapila
pila
tElemento
tElementox;
x;
nodoP
nodoP*tope1;
*tope1;
while(
while(!EstaVacia(tope)
!EstaVacia(tope))) {{
xx==Pop(tope);
Pop(tope);
Push(x,
Push(x,tope1);
tope1);
}}
return(tope1);
return(tope1);
}}
Implementacin en C
#include
#include<stdlib.h>
<stdlib.h>
#include
#include<stdio.h>
<stdio.h>
typedef
typedefstruct
structnodoP
nodoP{{
int
intvalor;
valor;
struct
structnodoP
nodoP*sig;
*sig;
}}tipoNodo;
tipoNodo;
typedef
typedeftipoNodo
tipoNodo*pNodo;
*pNodo;
typedef
typedeftipoNodo
tipoNodo*Pila;
*Pila;
////Prototipo
Prototipode
delas
lasfunciones
funciones
void
voidPush(Pila
Push(Pila*p,
*p,int
intx);
x);
int
intPop(Pila
Pop(Pila*p);
*p);
Ejemplo
Algoritmo para encontrar el factorial de un nmero mediante
pilas
leer n;
mientras n > 1 {
push(n);
n = n-1;
}
factorial = 1;
mientras pila no est vaca
factorial = factorial * pop();
Ejercicios
1. Evaluar, indicando en cada paso el estado de la pila:
Pila p = (Pila *)malloc(sizeof(Pila));
a) Pop ( Pop ( Push ( 3, Pop ( Push ( 4, Push ( 5, Push ( 6, p ) ) ) ) ) ) )
b) EstaVacia(Pop(Pop(Push( 8,p))))
c) InvPila( Push ( 3, Pop ( Push ( 4, Push ( 5, Push ( 6, p ) ) ) ) ) ) ) )
2. Escribir una funcin que permita contar todos los elementos pares que
estn en una pila dada.
COLAS
COLAS
Colas - queue
Es una abstraccin til con muchos paralelismos en la vida

real: colas de espera en bancos, supermercados, etc
Ello hace que su importancia sea crucial en simulaciones.
Computacionalmente hay muchos casos en los que aparecen
colas de espera, por ejemplo:
Procesos que esperan a ser ejecutados en sistemas
multitarea
Procesos batch de clculo intensivo
Acceso a recursos compartidos (impresora)
Colas - queue
Aplicaciones Indirectas:
Estructuras de datos auxiliares para algoritmos.

Componentes de otras estructuras de datos.
Colas
Tipo de dato lineal con estructura FIFO (First In, First Out),
indica que el primer elemento que se incorpor a la estructura,
ser el primero que salga, y el nico que se puede consultar en
un momento dado.
FIFO
entrada
trabajos
salida
Colas
Las colas son un subconjunto de las listas, en donde las
eliminaciones se dan al comienzo de la lista y las inserciones
al final.
Los elementos se procesan en el orden como se reciben
(similar a la cola de impresin en redes).
Cuando se desea accesar un elemento que no est en un
extremo, obligadamente se debe realizar una operacin
desplazamiento de los nodos anteriores (o posteriores) a l.
FIFO
entrada
trabajos
salida
Definicin del TAD Cola
encolar
final
frente
desencolar
CrearColaVaca( C )
ColaVaca( C ) B
PonerEnCola( x, C )
SacarDeCola( C )
Frente( C ) E

CrearColaVaca:
CrearColaVaca:Cola
ColaCola
Cola
CrearColaVaca(C)
CrearColaVaca(C)==CrearListaVaca(C)
CrearListaVaca(C)
Invocacin:
Invocacin:CrearColaVaca(C)
CrearColaVaca(C)
ColaVaca:
ColaVaca:Cola
ColaLgico
Lgico
ColaVaca(C)
ColaVaca(C)==ListaVaca(C)
ListaVaca(C)
Invocacin:
Invocacin:ColaVaca(C)
ColaVaca(C)
PonerEnCola:
PonerEnCola:Elemento
ElementoxxCola
ColaCola
Cola
PonerEnCola(
PonerEnCola(x,x,CC))==Insertar(
Insertar(x,x,Fin(C),
Fin(C),CC))
Invocacin:
Invocacin:PonerEnCola(x,
PonerEnCola(x,C)
C)

SacarDeCola:
SacarDeCola:Cola
ColaCola
Cola
SacarDeCola(
SacarDeCola(CC)){{
Si
Si(no
(noListaVaca(C))
ListaVaca(C))
Eliminar(
Eliminar(Primera(C),
Primera(C),CC))
sino
sinoError
Error
}}
Invocacin:
Invocacin:SacarDeCola
SacarDeCola(C)
(C)
Frente:
Frente:Cola
ColaElemento
Elemento
Frente(
Frente(CC)){{
Si
Si(no
(noListaVaca(C))
ListaVaca(C))
retornar(
retornar(Recuperar(Primera(C),
Recuperar(Primera(C),C)
C)))
Sino
Sino Error
Error
}}
Invocacin:
Invocacin:Frente(C)
Frente(C)
Colas - Implementacin
Estructura para los nodos:
info
sig
typedef struct TColas {

tElemento info;
struct tColas* sig;
}
Entrada de Dato
TColas *tCola;
Salida de Dato
Colas
Representacin grfica:
frente
final
...
NULL
Por aqu se sale
Por aqu entran
Colas
Otra representacin:
Colas
Se dispone de un puntero ms.

Cuando la cola est vaca se tiene la siguiente situacin:
frente
final
NULL
Colas
INSERTAR(dato;frente;final)
INSERTAR(dato;frente;final){{
Nuevo(p);
Nuevo(p);
p->info
p->info==dato;
dato;
p
dato
ififfinal
final====NULL
NULL{{
frente
////1a
frente==p;p;
1a
final
final==p;p; ////2a
2a
}}
else
else{{
final->sig
final->sig==p;p; ////1b
1b
final
final==p;p; ////2b
2b
}}
final
2a
dato
frente
1a
final
p->sig
p->sig==null;
null; //// 33
2b
p
final
frente
...
}}
3
null
dato
1b
3
null
Colas
Algoritmo
AlgoritmoEliminar(frente)
Eliminar(frente)
{{
ififfrente
frente====NULL
NULL
cola
colavaca
vaca
else
else {{
pp==frente;
//// 11
frente;
frente
frente==frente->sig;
frente->sig; //// 22
free(p);
//// 33
free(p);
}}
frente
null
frente
frente
final
2
...
null
}}
boolean
booleanEstaVaca
EstaVaca(tCola
(tCola**frente,
**frente,tCola
tCola**final)
**final){{
//// Verificacin
de
cola
vaca
Verificacin de cola vaca
ifif((*final
((*final==
==NULL)
NULL)&&
&&((*frente
*frente==
==NULL))
NULL))
return(
////Verdadero
return(true);
true);
Verdaderosisiest
estvaca
vaca
else
else
return
return(false);
(false);
}}
void
voidEnqueue
Enqueue(tCola
(tCola**frente
**frente,tCola
,tCola**final)
**final){{
tElemento
tElementodato;
dato;
printf("Ingrese
printf("Ingreseelemento
elemento");
"); scanf("%d",&dato);
scanf("%d",&dato);
if(
if(*frente
*frente==
==NULL)
NULL){{
*frente=(tCola
*)
malloc(sizeof(tCola));
*frente=(tCola *) malloc(sizeof(tCola));
(*frente)->info
(*frente)->info==dato;
dato; ////los
losparntesis
parntesisson
sonrequeridos
requeridospor
por
(*frente)->sig
(*frente)->sig==NULL;
NULL; ////precedencia
precedenciade
deoperandos
operandos
*final
=
*frente;
*final = *frente;
}}
else
else{{
tCola
tCola*q
*q==(tCola
(tCola*)
*)malloc
malloc(sizeof
(sizeof(tCola)
(tCola)););
q->info=
q->info=dato;
dato;
q->sig
q->sig==NULL;
NULL;
*final
*final==(*final)->sig
(*final)->sig==q;
q;
}}
}}
tElemento
tElementoDequeue
Dequeue(TCola
(TCola**top,
**top,TCola
TCola**final)
**final){{
tCola
tCola*temp;
*temp;
ifif(EstaVacia(frente,final))
(EstaVacia(frente,final))
printf("Error
printf("Error(cola
(colavacia)");
vacia)");
else
else {{
tElemento
tElementox=(*frente)->info;
x=(*frente)->info;
temp
temp==*frente;
*frente;
*frente
*frente==(*frente)->
(*frente)->sig;
sig;
temp->sig=NULL;
temp->sig=NULL;
free(temp);
free(temp);
return(x);
return(x);
}}
}}
Ejemplo
a
a
No es necesario mover
todos los elementos
Apuntadores al frente
y al final
Colas - Ejercicios
Escribir
Escribir una
una funcin
funcin que,
que, dada
dada una
una cola
cola que
que almacena
almacena nmeros
nmeros
enteros,
enteros,cuente
cuentelalacantidad
cantidadde
demltiplos
mltiplosde
de55que
quecontiene.
contiene.
Solucin:
Solucin:
int
intMul5EnCola(tCola**frente,
Mul5EnCola(tCola**frente,tCola**final)
tCola**final){{
////Contar
Contarlos
losnmeros
nmerosmltiplos
mltiplosde
de55almacenados
almacenadosen
enlalacola
cola
int
intcont=0;
cont=0;
tCola
tCola*aux
*aux=*frente;
=*frente;
while
while(*aux!=
(*aux!=NULL)
NULL){{
int
inttemp
temp==Dequeue(aux,
Dequeue(aux,final);
final);
if(temp
if(temp%
%55==
==0)
0)
cont++;
cont++;
}}
return(cont);
return(cont);
}}
Colas Ejercicios
#include
#include<stdlib.h>
<stdlib.h>
#include
#include<stdio.h>
<stdio.h>
#include
#include<malloc.h>
<malloc.h>
struct
structtColas
tColas{{
int
intinfo;
info;
struct
structTColas*
TColas*sig;
sig;
};
};
typedef
typedefTColas
TColastCola;
tCola;
void
voidEnqueue(tCola
Enqueue(tCola**frente,
**frente,tCola
tCola**final);
**final);
int
intDequeue
Dequeue(tCola
(tCola**frente,
**frente,tCola
tCola**final);
**final);
int
intMultiplos5EnCola(tCola
Multiplos5EnCola(tCola**frente,
**frente,tCola
tCola**final);
**final);
int
intEstaVacia(tCola
EstaVacia(tCola**final,
**final,tCola
tCola**frente);
**frente);
Colas Ejercicios
void
voidmain()
main(){{
int
intm5,
m5,i,i,max;
max;
tCola
tCola*final
*final==NULL;
NULL;
tCola
tCola*frente
*frente==NULL;
NULL;
//// Ingresar
Ingresardatos
datosaalalacola
cola
printf("Cuantos
printf("Cuantosdatos
datosaaingresar?
ingresar?");
"); scanf("%d",&max);
scanf("%d",&max);
for(i=0;i
<
max;
i++)
for(i=0;i < max; i++)
Enqueue(&frente,&final);
Enqueue(&frente,&final);
//// Buscar
Buscarlos
losmltiplos
mltiplosde
de55
m5=
m5=Multiplos5EnCola(&frente,
Multiplos5EnCola(&frente,&final);
&final);
printf("\n\nNumeros
printf("\n\nNumerosmultiplos
multiplosde
de5:
5:%d",m5);
%d",m5);
getch();
getch();
}}
Operaciones:
Estado de la cola:
Inicio: Cola Vaca
1.1.- Insertar A
2.2.- Insertar B
3.3.- Insertar C
4.4.- Remover Elemento

5.5.- Insertar D
6.- Remover Elemento
Tipos de colas
Colas de prioridad
Anillos
BiColas
BiColas circulares
Tipos de colas: Colas de Prioridad

Una cola de prioridad es una generalizacin de los conceptos de
pila y cola en la que, tras entrar en la cola, la salida de los
elementos no se basa necesariamente en el orden de llegada sino
que se basa en un orden definido entre ellos.
Los elementos se atienden en el orden indicado por una
prioridad asociada a cada uno.
Si varios elementos tienen la misma prioridad, se atendern de
modo convencional segn la posicin que ocupen.

Los objetos se introducen de igual forma que en los casos
anteriores;
La diferencia aparece en el caso de la extraccin y en la consulta
del siguiente objeto a extraer.
El elemento que se saca es el menor de los que se han
introducido segn la relacin de orden total.
Si hay varios elementos menores, con el mismo valor, el que
se saca es aqul que se introdujo primero.
Existen dos formas de implementacin:

1. Aadir un campo a cada nodo con su prioridad. Resulta
conveniente mantener la cola ordenada por orden de
prioridad.
cp
dato1 pr1
...
dato2 pr2
daton prn
typedef struct {
// Informacion
// Prioridad
Cola *sgte;
} Cola_Prioridad;

2. Crear tantas colas como prioridades haya, y almacenar cada
elemento en su cola.
Frente
Final
prim
P1
I11
P2
I21
I12
I13
P3
ult
P4
I41
I42
Algunas aplicaciones de las colas de prioridad

Gestin de procesos en un SO. Los procesos no se ejecutan
uno tras otro en base a su orden de llegada. Algunos procesos
deben tener prioridad (por su mayor importancia, por su
menor duracin, etc.) sobre otros.
Implementacin de algoritmos voraces, proporcionan
soluciones globales a problemas basndose en decisiones
tomadas slo con informacin local. La determinacin de la
mejor opcin local suele basarse en una cola de prioridad.
Algunos algoritmos sobre grafos, como la obtencin de
caminos o rboles de expansin de costo mnimo, son
ejemplos representativos.
Ejemplos del uso TDA Cola Prioridad

Convertir una expresin aritmtica infija en postfija:
Dada una expresin aritmtica E formada por nmeros y los
operadores: +, -, *, / expresada en formato infijo, transformarla a
formato postfijo.

Cola
ColaConvertir(
Convertir(Cola
ColaInfija
Infija)) {{
Cola
Pila
Elem
ColaPost;
Post;
PilaP;
P;
Elemtoken;
token;
CrearPilaVacia(
CrearPilaVacia(PP););
CrearColaVacia(
CrearColaVacia(Post
Post););
CrearElem(
CrearElem(token
token););
REPETIR
REPETIR
Asignar(token,
Asignar(token,Frente(Infija)),
Frente(Infija)),
SacarDeCola(
SacarDeCola(Infija
Infija););
Si
SiOperando(
Operando(token
token))
PonerEnCola(
PonerEnCola(token,
token,Post
Post););
Sino
Sino
Si
Si(no
(noPilaVacia(P))
PilaVacia(P))&&
&& (Prioridad(token)
(Prioridad(token)<=
<=Prioridad(Tope(P)))
Prioridad(Tope(P))){{
PonerEnCola(
PonerEnCola(Tope(P),
Tope(P),Post
Post))
Desapilar(
Desapilar(PP))
}}

Apilar(
Apilar(token,
token,PP););
}}
HASTA
HASTAColaVacia(
ColaVacia(Infija
Infija))
mientras
mientras(no
(noPilaVacia(P))
PilaVacia(P))
PonerEnCola(
PonerEnCola(Tope(P),
Tope(P),Post
Post););
Desapilar(
Desapilar(PP););
}}
return
returnPost;
Post;
}}
Estructuras de datos y algoritmos - 2007 - Clase 3
Mg. Sergio Alejandro Gmez
Anillos Cola circular

Las colas lineales tienen un grave problema:
como las extracciones slo pueden realizarse por un
extremo, puede llegar un momento en que el apuntador A
sea igual al mximo nmero de elementos en la cola, siendo
que al frente de la misma existan lugares vacos, y al insertar
un nuevo elemento nos mandar un error de overflow (cola
llena).
Para solucionar el problema de desperdicio de memoria se
implementaron las colas circulares, en las cuales existe un
apuntador desde el ltimo elemento al primero de la cola.

Es una secuencia de elementos dispuestos de forma circular.
Los elementos pueden aadirse y eliminarse desde un nico
punto llamado cabeza del anillo.
El crculo de elementos se puede rotar en ambos sentidos, de
manera que los diferentes elementos van pasando por la cabeza
del anillo.
Un anillo es, pues, una estructura en la que todo elemento tiene
un sucesor y un predecesor, y hay una posicin distinguida
llamada cabeza del anillo.

Estructuras con caractersticas parecidas se presentan a distintos
niveles:
redes de computadores con configuraciones de anillo y
comunicacin mediante paso de mensajes
las interfaces de usuario, en los intrpretes de comandos,
que suelen utilizar un buffer de entrada estructurado como
un anillo de lneas que se puede recorrer para recuperar
lneas introducidas con anterioridad.
Implementacin en C Anillos
Declaracin:
struct tcola {
int clave;
struct tcola *sig;
};
Creacin:
void crear(struct tcola **cola) {
*cola = NULL;
}
Funcin que devuelve verdadero si la cola est vaca:
int vacia(struct tcola *cola) {
return (cola == NULL);
}
Poner_En_Cola:
void encolar(struct tcola **cola, int elem) {
struct tcola *nuevo;
nuevo = (struct tcola *) malloc(sizeof(struct tcola));
nuevo->clave = elem;
if (*cola == NULL)
nuevo->sig = nuevo;
else {
nuevo->sig = (*cola)->sig;
(*cola)->sig = nuevo;
}
(*cola) = nuevo;
}
Sacar_De_Cola:
void desencolar(struct tcola **c1, int *elem) {
struct tcola *aux;
*elem = (*c1)->sig->clave;
if ((*c1) == (*c1)->sig) {
free(*c1);
*c1 = NULL;
}
else {
aux = (*c1)->sig;
(*c1)->sig = aux->sig;
free(aux);
}
}
Programa de prueba:
#include <stdio.h>
#include <stdlib.h>
int main(void) {
struct tcola *cola;
int elem;
crear(&cola);
if (vacia(cola))
printf("\nCola vacia!");
encolar(&cola, 100);
desencolar(&cola, &elem);
return 0;
}
Tipos de colas BiColas

Colas en donde los nodos se pueden insertar y eliminar por
ambos extremos;
Se les llama DEQUE (Double Ended QUEue).
TAD BiCola
Las operaciones son las mismas que la del TAD Cola, salvo que
Primero, Insertar y Eliminar son sustituidas por 2 operaciones
respectivamente:
PrimeroIzquierda: TipoDeque TipoElemento
PrimeroDerecha: TipoDeque TipoElemento
InsertarIzquierda: TipoElementox TipoDeque TipoDeque
InsertarDerecha: TipoElemento x TipoDeque TipoDeque
EliminarIzquierda: TipoDeque TipoDeque
EliminarIzquierda: TipoDeque TipoDeque
Tipos de colas BiColas

Existen dos variantes:
Bicolas de entrada restringida: Son aquellas donde la
insercin slo se hace por el final, aunque se puede
eliminar al principio o al final.
Bicolas de salida restringida: Son aquellas donde slo se
elimina por el final, aunque se puede insertar al principio y
al final.
BiColas circulares
Permite la implementacin eficiente de todas las operaciones
del anillo normal, y de la cola doble.
p puede apuntar ahora sin problemas a la cabeza del anillo, ya
que se puede acceder sin problemas y de forma directa al
ltimo elemento.
BiColas circulares
Las rotaciones tanto a derecha como a izquierda no suponen
tampoco complicacin alguna, ya que se tienen punteros en
ambas direcciones.
Bibliografa - Webgrafa
Abstraccin de datos
1. http://www14.uniovi.es/tutorED/abstraccion/abstraccionfr.html
Estructura de Datos
2. http://www14.uniovi.es/tutorED/estlineales/estlineafr.html
3. http://www14.uniovi.es/tutorED/java-c++/java-c++fr.html
4. Como programar en Java. Deitel y Deitel.
Listas
5. http://www14.uniovi.es/tutorED/estlineales/interlistafr.htm
6. http://oviedo3.ccu.uniovi.es/martin/EDI/ListPage.htm
Bibliografa - Webgrafa
Listas, pilas y colas. Ejercicios
7. Fundamentos de programacin. Libro de problemas. Luis
Joyanes Aguilar
8. http://old.algoritmia.net/listas.htm
9. Estructura de datos y organizacin de archivos. Mary E.
Loomis. Prentice Hall. 2a Ed.
10. Pilas y Colas. Cursos Propeduticos 2006, Programacin y
Estructuras de Datos. Manuel Montes, Claudia Feregrino.

ED Cap4 PilasColas12010

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

ED Cap4 PilasColas12010

Hochgeladen von

Copyright:

Verfügbare Formate

Estructura de Datos

Prof.: Lorna Figueroa

Universidad Tcnica Federico Santa Mara - Departamento de Informtica

Universidad Tcnica Federico Santa Mara - Departamento de Informtica

Universidad Tcnica Federico Santa Mara - Departamento de Informtica

Universidad Tcnica Federico Santa Mara - Departamento de Informtica

Aplicaciones de las Pilas

Universidad Tcnica Federico Santa Mara - Departamento de Informtica

Ejemplo Aplicacin de las pilas

Suponga que se quiere evaluar una expresin aritmtica,

Universidad Tcnica Federico Santa Mara - Departamento de Informtica

Ejemplo Aplicacin de las pilas

El mtodo consiste en seguir el siguiente proceso de forma

Universidad Tcnica Federico Santa Mara - Departamento de Informtica

Definicin del TAD Pilas

Universidad Tcnica Federico Santa Mara - Departamento de Informtica

Definicin del TAD Pilas

Universidad Tcnica Federico Santa Mara - Departamento de Informtica

Definicin del TAD Pilas

Universidad Tcnica Federico Santa Mara - Departamento de Informtica

Definicin del TAD Pilas

Universidad Tcnica Federico Santa Mara - Departamento de Informtica

Aplicaciones con TAD Pila

Universidad Tcnica Federico Santa Mara - Departamento de Informtica

Aplicaciones con TAD Pila

Universidad Tcnica Federico Santa Mara - Departamento de Informtica

Universidad Tcnica Federico Santa Mara - Departamento de Informtica

Universidad Tcnica Federico Santa Mara - Departamento de Informtica

Universidad Tcnica Federico Santa Mara - Departamento de Informtica

Universidad Tcnica Federico Santa Mara - Departamento de Informtica

Universidad Tcnica Federico Santa Mara - Departamento de Informtica

Universidad Tcnica Federico Santa Mara - Departamento de Informtica

Expresiones infijas, prefijas, postfijas

Universidad Tcnica Federico Santa Mara - Departamento de Informtica

Notacin polaca inversa (postfija)

Se sigue el orden indicado por las flechas, (segn prioridad

Universidad Tcnica Federico Santa Mara - Departamento de Informtica

Notacin polaca inversa (postfija)

Universidad Tcnica Federico Santa Mara - Departamento de Informtica

La clave de la traduccin de notacin infija a posfija es la

Universidad Tcnica Federico Santa Mara - Departamento de Informtica

Universidad Tcnica Federico Santa Mara - Departamento de Informtica

Conversin infija a postfija

Universidad Tcnica Federico Santa Mara - Departamento de Informtica

Estructura de datos y organizacin de archivos. Mary

Universidad Tcnica Federico Santa Mara - Departamento de Informtica

Algoritmo para evaluar una expresin postfija

Para evaluar una expresin postfija con pilas:

Universidad Tcnica Federico Santa Mara - Departamento de Informtica

Aplicacin: Invertir una Pila

Universidad Tcnica Federico Santa Mara - Departamento de Informtica

Universidad Tcnica Federico Santa Mara - Departamento de Informtica

Universidad Tcnica Federico Santa Mara - Departamento de Informtica

Universidad Tcnica Federico Santa Mara - Departamento de Informtica

Universidad Tcnica Federico Santa Mara - Departamento de Informtica

Es una abstraccin til con muchos paralelismos en la vida

Universidad Tcnica Federico Santa Mara - Departamento de Informtica

Estructuras de datos auxiliares para algoritmos.

Universidad Tcnica Federico Santa Mara - Departamento de Informtica

Universidad Tcnica Federico Santa Mara - Departamento de Informtica

Universidad Tcnica Federico Santa Mara - Departamento de Informtica

Definicin del TAD Cola

Universidad Tcnica Federico Santa Mara - Departamento de Informtica

Definicin del TAD Cola