100442777-pilas-y-colas

Universidad Nacional del Santa-Ing. de Sistemas e Informática 2010

1 Ejercicios de Pilas y Colas Estructura de Datos



PILAS

1.- Codificar el algoritmo de una expresión infija a expresión postfija en la herramienta

de programación de laboratorio (java 6.8)

package notacionpolaca;

import java.io.*;

import java.lang.String;

public class PrefijaPosfija {

static char Pila[]=new char[60];

static int tope=0;

static char sacar='0';

char Exin[]=new char[60];

char Expre[]=new char[60];

char Expo[]=new char[60];

int A, int B;

char Bandera= ')';

String cadena="";

int topex=0;

public void PreProfija()throws IOException{

int op,rta=0;

BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

System.out.println("Elegir Opcion a la que desea transformar" );

System.out.println(" 1. Exp Postfija ");

System.out.println(" 2. Exp Prefija ");

System.out.println("");

String temp = br.readLine();

op= Integer.parseInt(temp);

switch (op){

case 1:

System.out.println("Ingresar Expresion Infija:");

cadena= br.readLine();

for(int i=0; i<cadena.length();i++){

Exin[i]=cadena.charAt(i);

System.out.println("Exin[ "+(i+1)+" ] : " +Exin[i]);

}

int N=cadena.length();

Exin[N]=')';

System.out.println("Exin[ n ] : " +Exin[N]);

Meter('(');




System.out.println("Pila[ "+tope+" ] :" +Pila[tope-1]);


//Realiza la transformacion de Expresion infija a postfija//

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

char com=Exin[i];

System.out.println("Compara : " +com);

System.out.println(" "+Exin[i]);

if(com=='^' | com=='/' | com=='*' | com=='+' | com=='-'){

while(Precedencia(Pila[tope-1])>=Precedencia(com)){

Expo[topex]=Sacar();

topex++;

for(int k=0;k<topex;k++){

System.out.println("Expo[ "+ (k+1)+" ] : " +Expo[k]);

}

}

if(Precedencia(Pila[tope-1])<Precedencia(com)){

Meter(com);

for(int k=0; k<tope;k++){

System.out.println("Pila[ "+k+" ] :" +Pila[k]);

}

}

}else if(com=='('){

Meter(com);

}else if(com==')'){

int j=tope-1;

while(Pila[j]!='('){

char aux = Sacar();

System.out.println(aux);

Expo[topex] =aux;

topex++;

j--;

}

Sacar();

}else{

Expo[topex]=com;

topex++;

}

}

System.out.println("Datos finales");


System.out.println(Expo[k]);

}



break;

case 2:

System.out.println("Ingresar Expresion Infija:");

cadena= br.readLine();

Exin[0]='(';

System.out.println("Exin[ 0 ] : " +Exin[0]);

for(int i=0; i<cadena.length();i++){

Exin[i+1]=cadena.charAt(i);

System.out.println("Exin[ "+(i+1)+" ] : " +Exin[i+1]);

}

N=cadena.length();

Meter(')');


System.out.println("Pila[ "+tope+" ] :" +Pila[tope-1]);


for(int i=N;i>=0;i--){

char com=Exin[i];

System.out.println("Compara : " +com);

System.out.println(" "+Exin[i]);

if(com=='^' | com=='/' | com=='*' | com=='+' | com=='-'){

while(Precedencia(Pila[tope-1])>Precedencia(com)){

Expre[topex]=Sacar();

topex++;


System.out.println("Expre[ "+ (k+1)+" ] : " +Expre[k]);

}

}

if(Precedencia(Pila[tope-1])<=Precedencia(com)){

Meter(com);


System.out.println("Pila[ "+k+" ] :" +Pila[k]);

}

}

}else if(com==')'){

Meter(com);

}else if(com=='('){

int j=tope-1;


System.out.println("Pilita[ "+k+" ] :" +Pila[k]);

}



while(Pila[j]!=')'){

char aux = Sacar();

System.out.println(aux);

Expre[topex] =aux;

topex++;

j--;

}

Sacar();

}else{

Expre[topex]=com;

topex++;

}

}

System.out.println("Datos finales");

for(int k=topex-1;k>=0;k--){

System.out.print(Expre[k]);

}

break;

}

}

public static void Meter(char cad){

if(tope<50){

Pila[tope] = cad;

tope = tope + 1;

}

}

public static char Sacar(){

if(tope>0){

sacar = Pila[tope-1];

tope = tope -1;

}

return sacar;

}

public static int Precedencia(char ope){

int prece=0;

switch (ope){

case '^':

prece=5;

break;

case '*':

prece=4;

break;



case '/':

prece=4;

break;

case '+':

prece=2;

break;

case '-':

prece=2;

break;

}

return prece;

}

}

2.-codificar el algoritmo de evaluación de expresión postfija en la herramienta de

programación de laboratorio (java 6.8)

package exprposfija;

import java.util.*;

import java.lang.Math.*;

public class EPosfija {

Scanner entrada= new Scanner(System.in);

String expre, d1=")";

int lon,i=0,j=0;

char aux, d[]={')'};

public void RealizarOp(){

System.out.println("Ingresar la Expresion Posfija que desea evaluar:");

expre=entrada.next();

lon=expre.length();

double pila[]=new double[lon];

expre=expre.concat(d1);

while(expre.charAt(i)!=d[0])

{

aux=expre.charAt(i);

switch(aux)

{

case '+':

pila[j-2]=pila[j-2]+pila[j-1];

j--;

break;



case '-':

pila[j-2]=pila[j-2]-pila[j-1];

j--;

break;

case '*':

pila[j-2]=pila[j-2]*pila[j-1];

j--;

break;

case '/':

pila[j-2]=pila[j-2]/pila[j-1];

j--;

break;

case '^':

pila[j-2] = Math.pow(pila[j-2],pila[j-1]);

j--;

break;

default :

char aux1[]={aux};

String aux2= new String(aux1);

pila[j]=Integer.parseInt(aux2);

j++;

}

i++;

}

System.out.println("El resultado de la opreacion es:"+" "+pila[j-1]);

}

}



4.- Dado los caracteres (), [],{}, y una cadena s; s está balanceada si tiene alguno de

estos formatos, s=””,(string nulo), s=(T), s={T}, s= TU en donde T y U son cadenas

balanceadas (en otras palabras, para cada paréntesis , llave o corchete abierto existe un

carácter de cierre correspondiente ). Ejemplo s= {(a + b) [(c - d) ^ 2]}. Escribir el

algoritmo (psudocodigo) que use una PILA para ver si una cadena es balanceada.

INICIO

Leer s;

esBalanceado verdadero;

meter ”!” en pila;

Si s=”” entonces //s es nulo.


Caso contrario

Examinar s de izquierda a derecha

Si se encuentra caracter de apertura entonces

Meter en pila;

esBalanceado falso;

Fin_si

Si se encuentra carácter de cerradura entonces

Si carácter es de la misma precedencia que el valor del tope de la

pila entonces

Sacar de pila último dato;


Caso contrario

esBalanceado falso;

Fin_si

Fin_si

Fin_si

Imprimir (s+“ es balanceado: ” esBalanceado);

FIN



6.- Se tiene la siguiente formula

√

√

Escribir su forma infija, prefija y postfija correspondiente

Infija:

a+((b^2-c)^(1/2))/(d^(1/3)-e/f)

Prefija:

a+((b^2-c)^(1/2))/(d^(1/3)-e/f)

a+(([^b2]-c)^[/12])/(d^[/13]-[/ef])

a+([-^b2c]^[/12])/([^d/13]-[/ef])

a+[^-^b2c/12]/[-^d/13/ef]

a+[/^-^b2c/12-^d/13/ef]

+a/^-^b2c/12-^d/13/ef

Postfija:

a+((b^2-c)^(1/2))/(d^(1/3)-e/f)

a+(([b2^]-c)^[12/])/(d^[13/]-[ef/])

a+([ b2^c-]^[12/])/([d13/^]-[ef/])

a+[b2^c-12/^]/[d13/êf-]

a+[ b2^c-12/^ d13/êf-/]

a b2^c-12/^ d13/êf-/+



7. Se tiene una pila con los 10 números naturales, y una cola con los 10 siguientes,

escriba el algoritmo en pseudocódigo que utilizando las operaciones básicas para cada

una de estas estructuras permita obtener la sumatoria del producto de sus datos,

atendiendo la regla LIFO para la pila y FIFO para la cola.

COLA

Índice 1 2 3 4 5 6 7 8 9 10

Dato 11 12 13 14 15 16 17 18 19 20

INICIO

Frente = 1 Tope =10 Sumatoria = 0

Final = 10 Fondo =1 N =10

Mientras (Frente = N) y (Tope > 0) hacer

Si (Frente = 0) y (Tope = 0) entonces

Escribir “Pila Vacía”

Caso Contrario

Sumatoria = Sumatoria + Pila [Tope] * Cola [Frente]

Si (Frente = Final) entonces

Frente = 0

Final = 0

Tope = 0

Caso Contrario

Frente = Frente + 1

Tope = Tope – 1

Fin _ Si

Fin _ Si

Fin _ Mientras

Escribir “La sumatoria es:” + Sumatoria

FIN

PILA 10 10

9 9

8 8

7 7

6 6

5 5

4 4

3 3

2 2

1 1

Índice Dato



8.- Dado los caracteres (), [], {}, y una cadena s; s está balanceada si tiene alguno de

estos formatos, s=””,(string nulo), s=(T), s={T}, s= TU en donde T y U son cadenas

balanceadas (en otras palabras, para cada paréntesis , llave o corchete abierto existe un

carácter de cierre correspondiente ). Ejemplo s = {[(c - d) ^ 2] + 1}. Escribir el

algoritmo (psudocodigo) que use una PILA para ver si una cadena es balanceada.

INICIO

Leer s;


meter ”!” en pila;

Si s=”” entonces //s es nulo.


Caso contrario

Examinar s de izquierda a derecha

Si se encuentra caracter de apertura entonces

Meter en pila;

esBalanceado falso;

Fin_si

Si se encuentra carácter de cerradura entonces

Si carácter es de la misma precedencia que el valor del tope de la

pila entonces

Sacar de pila último dato;


Caso contrario

esBalanceado falso;

Fin_si

Fin_si

Fin_si

Imprimir (s+“ es balanceado: ” esBalanceado);

FIN



COLAS

1. Se considera una cola frente a una ventanilla en la cual si un cliente al llegar a la

misma no puede ser atendido, se le reintegra a la cola a la posición nº 10, si hay

más de 10 personas, o al final de la misma, en caso contrario. Se pide diseñar un

procedimiento de ATENCION (lo que debe suceder cuando un cliente es

atendido), REINGRESO (vuelta a la cola) y otro de INGRESO (inicial) en cola.

Todo ello con vistas a que el reingreso sea sencillo, para lo que se sugiere

controlar el nº de personas en la cola, y en su caso, un puntero al elemento

adecuado de la cola para ejecutar el reingreso.

//Procedimiento de ingreso

INICIO

Frente 0, final 0;

Leer cliente

Si final = n entonces

Escribir “Cola llena”

Caso contrario

final final + 1

cola[final] cliente

ptr final – frente + 1

si frente = 0 entonces

frente 1

ptr final

fin si

fin si

FIN

//Procedimiento de Atención

INICIO

si No puede ser atendido entonces

Llamar al Procedimiento Reingreso

caso contrario

si frente = 0 entonces

escribir “cola vacia”

caso contrario

cliente cola[frente]

si frente = final entonces

frente 0 , final 0

caso contrario

frente frente + 1

fin-si



repetir desde i 1 hasta n – 1

cola[i] cola[ i+1]

fin-repetir

frente 1

final final – 1

fin-si

fin-si

FIN

//Procedimiento reingreso

INICIO

tope 0

si final <= 10 entonces

final final + 1

cola [final] cola[frente]

caso contrario

repetir desde j= ptr hasta 10

tope tope + 1

pila[tope] cola[j]

fin_repetir

cola[10] cola [frente]

p tope

repetir desde k=1 hasta tope

cola[10+k] pila[p]

p tope-1

fin_repetir

fin_si

repetir desde i=1 hasta n-1

cola[i] cola[i+1]

fin_repetir

frente 1

final final – 1

FIN



2. Un ascensor está situado en un edificio de N plantas (la planta baja es la 0) y

responde a dos tipos de peticiones de funcionamiento: las de los usuarios que

están dentro del ascensor (peticiones internas) y las de lo están fuera (peticiones

externas). Estas últimas solo serán atendidas cuando no haya peticiones internas.

Los dos tipos de peticiones se gestionan independientemente y responden a

criterios de temporalidad, de manera que las llamadas van siendo atendidas

según el orden de solicitud. Con este planteamiento, hay que escribir un

programa que simule el funcionamiento del ascensor de forma que las peticiones

se realicen mediante pulsaciones de teclado y, “al mismo tiempo”, mover el

ascensor a los pisos que se van solicitando. Se distinguirá entre peticiones

interiores y exteriores según las teclas pulsadas (teclas: 0, 1, 2, … N, indican

peticiones interiores a dichos pisos; teclas: -0, -1, -2, …, -N, indican peticiones

exteriores en el mismo orden), la tecla „N+1‟ se reserva para finalizar la

simulación. La visualización del proceso se puede realizar utilizando un método

MOVER _ ASCENSOR que muestra por pantalla el movimiento del ascensor.

Este método responde al siguiente perfil: MOVER _ ASCENSOR (desde, hasta:

0…N); donde desde indica la posición actual del ascensor y hasta, el piso al que

debe ir.

INICIO

leer pet

si pet = n + 1 entonces

finaliza simulación

caso contrario

si pet es interna entonces

frente i 0, final i 0

leer x

si final i = n entonces

escribir “cola llena :

no hay lugares para peticiones internas”

caso contrario

final i final i + 1

cola[final] x

fin_si

si frente i = 0 entonces

frente i 1

fin_si

llamar a procedimiento cumplir_orden i

caso contarrio

frente e 0,final e 0

leer x



si final e = n entonces

escribir “cola llena :

no hay lugares para peticiones externas”

caso contrario

final e final + 1

cola[frente] x

fin_si

si frente e = 0 entonces

frente 1

fin_si

llamar a procedimientos cumplir_orden e

fin_si

fin_si

FIN

// Procedimento cumplir_orden i

INICIO

Piso_actual 0

Repetir

Piso_destino cola[frente i]

Hasta que (frente i = 0)

Repetir

Si frente i = final i entonces

Frente i 0

Final i 0

Caso contrario

Frente i frente i + 1

Fin_si

Piso_actual piso_destino

Hasta piso_destino

FIN



//Procedimiento cumplir_orden e

INICIO

Piso_actual 0

Repetir

Piso_destino cola[frente e]

Hasta que (frente e = 0)

Repetir

Si frente e = final e entonces

Frente e 0

Final e 0

Caso contrario

Frente e frente e + 1

Fin_si

Piso_actual piso_destino

Hasta piso_destino

FIN

3. Considera que palabra es una palabra de tipo Cola que contiene la entrada del

usuario por teclado, P una pila de caracteres y el siguiente algoritmo:

1. Mientras haya mas caracteres en palabra hacer

2. apilar el primero de la cola en la pila P

3. sacar de la cola

4. Fin_Mientras

5. Mientras la pila P no sea vacia hacer

6. Escribir la cima de P

7. Desafilar de P

8. Fin_mientras

¿Cuál es la salida para la entrada “examen”?

1 2 3 . . . . N

N

3

2

1



INICIO

Datos iniciales

Frente = -1 ; N

Final = -1 ; Tope = 1

//Algoritmo para meter los caracteres

Si Frente = -1 entonces

Escribir “Cola vacía”

Frente =1

Final =1

Cola [Frente]=carac

Sino

Si Final = N entonces


Sino

Final = Final +1

Fin_Si

Fin_Si

// Algoritmo para Sacar un caracter de Cola y ponerlo en Pila

Mientras Frente <= Final hacer

Pila [Tope] = Cola [Frente]

Frente = Frente +1

Tope = Tope +1

Fin_Mientras

//Algoritmo para Sacar de Pila un caracter y mostrarlo

Mientras tope <> 0 hacer

Escribir “Pila[Tope]”

Tope = Tope – 1

Si Tope = 0 entonces

Tope = -1

Frente = -1

Final = -1

Fin_Si

Fin_Mientras

FIN



N = 6

frente final Cola[frente] Cola[final]

-1

1

-1

1

2

3

4

5

6

7

e

x

a

m

e

n

e

x

a

m

e

n

Tope Pila[Tope]

6

5

4

3

2

1

0

n

e

m

a

x

e

La salida es: nemaxe

Final Frente Tope Pila[tope] Cola[frente]

6 1

2

3

4

5

6

7

1

2

3

4

5

6

e

x

a

m

e

n

e

x

a

m

e

n



4. Escribe el algoritmo en pseudocódigo que lea una cadena de caracteres del

teclado y decida si es palíndromo, es decir, si se lee igual de izquierda a derecha

que de derecha a izquierda. Impleméntalo después en el Lenguaje de

programación de su dominio. Ejemplo: daba le arroz a la zorra en el abad es

palíndromo.

INICIO

N ← Cantidad de caracteres

i ← 1, j ← N , Band ← 1

Hacer Mientras (i < j y Band = 1)

Si caracter(i) <> caracter(j) entonces

Band ← 0

Fin_Si

I ← i + 1

J ← j + 1

Fin_Mientras

Si Band = 1 entonces

Escribir “Es Palíndromo”

Sino

Escribir “No es Palíndromo”

Fin_Si

FIN

5. Un estacionamiento de las avionetas de un aeródromo es en línea, con una

capacidad hasta 12 avionetas. Las avionetas llegan por el extremo izquierdo y

salen por el extremo derecho. Cuando llega un piloto a recoger su avioneta, si

ésta no esta justamente en el extremo de salida (derecho), todas las avionetas a

su derecha han de ser retiradas, sacar la suya y las retiradas colocadas de nuevo

en el mismo orden relativo en que estaban. La salida de una avioneta supone que

las demás se mueven hacia delante, de tal forma que lo espacios libres del

estacionamiento estén por la parte izquierda. Escribia el algoritmo

(Pseudocódigo) para emular este estacionamiento tiene como entrada un carácter

que indica una acción sobre la avioneta, y la matricula de la avioneta. La acción

pude 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 quede una plaza

libre, o hasta que se dé la orden de retirada (salida).

Algoritmo para llegada de Aviones



INICIO

N ← 12

FINAL ← 0

Leer AVION

Si FINAL >= N entonces

Escribir “Estacionamiento lleno”

Sino

FINAL ← FINAL + 1

Fin_Si

FIN

//Algoritmo para la salida de las Aviones

INICIO

Ingrese POSICION de la Avion

Si FINAL <= 0 Entonces

Escribir “No hay Aviones para salir”

Sino

Si POSICION = 1 Entonces

Si FINAL = 1 Entonces

COLA[POSICION] ← Vacio

FINAL ← FINAL -1

Sino


ARREGLARPOSICION /* Procedimiento

FINAL ← FINAL -1

Fin_Si

Sino

SACAR /* Procedimiento


LLENAR /* Procedimiento

FINAL ← FINAL – 1

Fin_Si

Fin_Si

FIN

// Fin de salida de Aviones



PROCEDIMIENTOS ( ):

ARREGLAR POSICION:

i = 1

Mientras i<= FINAL – 1 hacer

COLA[i] ← COLA[i + 1]

COLA[i + 1] ← Vacio

i = i+1

Fin_Mientras

FIN_ARREGLARPOSICION

//Sacar

SACAR

i = 1

Mientras i<= POSICION – 1 hacer

COLAAUX[i] ← COLA[i]

COLA[i] ← Vacio

i = i+1

Fin_Mientras

FIN_SACAR

LLENAR:

i = 1

Mientras i <= POSICION – 1 hacer

COLA[i] ← COLAAUX[i]

i = i+1

Fin_Mientras

COLAAUX ← Vacio

Si FINAL > POSICION entonces

i = 1

Mientras i <= FINAL – 1 hacer

COLA[i] ← COLA[i+1]

COLA[i+1] ← Vacio

Fin_Mientras

Fin_Si

FIN_LLENAR



6. Elabore el pseudocódigo de las operaciones METER Y SACAR de una bicola,

donde la cola de un extremo guarda códigos de Radios y la del otro extremo

códigos de televisores.

//Algoritmo Insertar

FinalD ← 0 Finall ← 1

INICIO:

Verificar Opcion: Leer x //Dato

Si Opcion = Derecha entonces

Si FinalD >= N entonces


Sino

FinalD ← FinalD + 1

Cola(FinalD) ← x

Fin_Si

Si FinalD > 0 y Finall <= 0 entonces

Escribir “No se puede insertar”

Sino

Si FinalD <= 0 entonces

Cola(1) ← x

FinalD ← 1

Sino

Si Finall > 1 entonces

Finall ← Finall -1

Cola(Finall) ← x

Sino

Escribir “No se puede insertar”

Fin_Si

Fin_Si

Fin_Si

Fin_Si

FIN



//Algoritmo Eliminar

INICIO

Si Finall > FinalD ó FinalD <= 0 ó Finall >= 0 entonces

Escribir “Cola Vacia”

FinalD ← 0, Finall ← 1

Sino

Verificar Opcion(Izq/Der)

Si Opcion es Derecha entonces

x ← Cola(FinalD)

FinalD ← FinalD – 1

Sino // Será Opcion Izquierda

x ← Cola(Finall)

Finall ← Finall + 1

Fin_Si

Fin_Si

FIN

7. En un archivo de texto se encuentran los resultados de una competición de tiro al

plato, de tal forma que en cada línea se encuentra Apellido, Nombre, número de

dorsal y número de platos rotos. Se debe escribir el algoritmo (Pseudocódigo),

que lea el archivo de la competición y determine los tres primeros. La salida ha

de ser los tres ganadores y a continuación los concursantes en el orden en que

aparecen en el archivo (utilizar la estructura cola).

//Algoritmo Para Insertar Datos

Fin1 = Fin2 = Fin3 = Fin4 = 0

INICIO

Ingrese Datos [Apellidos (Ap), Nombre (Nom), Numero de dorsal (Dor),

Platos rotos (Plat)]

Ingrese numero de Datos (N>3)

Si Fin4 >= N entonces


Sino

Fin1 ← Fin1 + 1

Fin2 ← Fin2 + 1

Fin3 ← Fin3 + 1

Fin4 ← Fin4 + 1



Cola1 [Fin1] ← Ap

Cola2 [Fin2] ← Nom

Cola3 [Fin3] ← Dor

Cola4 [Fin4] ← Plat

Fin_Si

FIN

Algoritmo para buscar los tres primeros mayores

INICIO

i ← 1

Mientras (i <=3) hacer

i ← i+1

May = Cola [1]

j ← 1

Mientras k=2 <= Fin4 hacer

Si May < Cola4 [k] Entonces

May ← Cola4 [k]

j ← k

Fin_Si

k ← k + 1

Fin_Mientras

Escribir:

Cola1 [j], Eliminar Cola1 [j]




Fin_Mientras

L = 1

Mientras L <= Fin4 hacer

Si Cola4 [L] <> Vacio Entonces

Escribir :

Cola1 [L]

Cola2 [L]

Cola3 [L]

Cola4 [L]

Fin_Si

L ← L + 1

Fin_Mientras

FIN



8. El despegue de aeronaves en un aeropuerto se realiza siguiendo el orden

establecido por una cola de prioridades. Hay 5 prioridades establecidas según el

destino de aeronave. Destino de menos de 500 km tienen la máxima prioridad,

prioridad 1, entre 500 y 800 km prioridad 2, entre 801 y 1000 km prioridad 3,

entre 1001 y 1350 km prioridad 4 y para mayores distancias prioridad 5. Cuando

una aeronave recibe cierta señal se coloca en la cola que le corresponde y

empieza a contar el tiempo de espera. Los despegues se realizan cada 6 minutos

según el orden establecido en las distintas colas de prioridad. El piloto de una

aeronave puede pasar el aviso a control de que tiene un problema, y no puede

despegar por lo que pasa al final de la cola y se da la orden de despegue a la

siguiente aeronave. Puede darse la circunstancia de que una aeronave lleve mas

de 20 minutos esperando, en ese caso pasará a formar parte de la siguiente cola

de prioridad y su tiempo de espera se inicializa a cero.

Escribir el algoritmo que simule este sistema de colas mediante una lista única,

cada vez que despegue un avión saldrá un mensaje con las características del

vuelo y el tiempo total de espera.

Prioridad A, B, C, D, E

Distancia de viaje (Km):

A: Menor de 500

B: Entre 500 – 800

C: Entre 801 – 1000

D: Entre 1001 – 1350

E: Mayor de 1350

LLENAR COLAS

FRENT_A ← 0, FRENT_B ← 0,

FRENT_C ← 0, FRENT_D ← 0,

FRENT_E ← 0

FIN_A ← 0, FIN_B ← 0, FIN_C ← 0,

FIN_D ← 0, FIN_E ← 0



INICIO

Leer avion (AV), Leer Distancia de destino(DIS)

Si DIS > 0 y DIS < 500 Entonces

FIN_A ← FIN_A + 1

COLA[FIN_A] ← AV

Sino

Si DIS >= 500 y DIS <= 800 Entonces

FIN_B ← FIN_B + 1

COLB[FIN_B] ← AV

Sino

Si DIS >= 801 y DIS<= 1000 Entonces

FIN_C ← FIN_C + 1

COLC[FIN_C] ← AV

Sino

Si DIS >= 1001 y DIS <= 1350 Entonces

FIN_D ← FIN_D + 1

COLD[FIN_D] ← AV

Sino

FIN_E ← FIN_E + 1

COLE[FIN_E] ← AV

Fin_Si

Fin_Si

Fin_Si

Fin_Si

FIN

//Atender al Cliente

Tiempo ← 0

INICIO

Si FRENT_A < FIN_A Entonces

Mostrar ColaA(FRENT_A + 1) // Avion por Salir

Sino

Si FRENT_B < FIN_B Entonces

Mostrar ColaA(FRENT_B + 1)

Sino



Si FRENT_C < FIN_C Entonces

Mostrar ColaC(FRENT_C + 1)

Sino

Si FRENT_D < FIN_D Entonces

Mostrar ColaD(FRENT_D + 1)

Sino

Si FRENT_E < FIN_E Entonces

Mostrar ColaE(FRENT_E + 1)

Fin_Si

Fin_Si

Fin_Si

Fin_Si

Fin_Si

Repetir hasta que tiempo >= 7

tiempo ← tiempo + 1

Si tiempo >= 6 Entonces // Cada 6 segundos como Ejemplo

Si FIN_A > 0 Entonces

Si FRENT_A < FIN_A Entonces

FRENT_A ← FRENT_A + 1

Cola(FRENT_A) ← vacio

tiempo ← 0

Sino

FRENT_A ← 0

FIN_A ← 0

Fin_Si

Sino

Si FIN_B > 0 Entonces

Si FRENT_B < FIN_B Entonces

FRENT_B ← FRENT_ B + 1

Cola(FRENT_ B) ← vacio

tiempo ← 0

Sino

FRENT_ B ← 0

FIN_ B ← 0

Fin_Si

Sino

Si FIN_C > 0 Entonces

Si FRENT_ C < FIN_ C Entonces

FRENT_ C ← FRENT_ C + 1

Cola(FRENT_ C) ← vacio



tiempo ← 0

Sino

FRENT_ C ← 0

FIN_ C ← 0

Fin_Si

Sino

Si FIN_D > 0 Entonces

Si FRENT_ D < FIN_ C Entonces

FRENT_ D ← FRENT_ D + 1

Cola(FRENT_ D) ← vacio

tiempo ← 0

Sino

FRENT_ D ← 0

FIN_ D ← 0

Fin_Si

Sino

Si FIN_E > 0 Entonces

Si FRENT_ E < FIN_ C Entonces

FRENT_ E ← FRENT_ E + 1

Cola(FRENT_ E) ← vacio

tiempo ← 0

Sino

FRENT_ E ← 0

FIN_ E ← 0

Fin_Si

Fin_Si

Fin_Si

Fin_Si

Fin_Si

Fin_Si

Fin_Si

Fin_Repetir

Escribir “Cola vacia”

FIN

100442777-pilas-y-colas

Documents

new char60 int

new char60 char expre

new char60 char expo

int op

new char60 static int

char exin

static char pila

static char sacar