Pilas

2. Pilas Una Pila es una colección de elementos del mismo tipo organizada como una superposición ordenada de los mismos. Por ejemplo Pila de platos, Pila de cartas, Pila de camisas, Pila de libros TOPE DE LA PILA Los elementos se recuperan en el orden inverso al que fueron almacenados. El último en entrar (TOPE) es el primer en salir.

3. Pilas • Representación Gráfica ELEMENTO n ELEMENTO n -1 ……… ELEMENTO 1 Tope de la Pila

4. Pilas • Que se puede hacer sobre una pila? Apilar Desapilar VerTope …..

5. Pilas en Pascal TOPE En Pascal vamos a trabajar con Pilas de Enteros. • Cada pila tendrá un nombre. • Sólo se ve el TOPE, no se sabe cuantos elementos hay • Se podrán hacer las siguientes operaciones: ReadPila() InicPila () Tope() Apilar () Desapilar() el Elemento que se desapila debe ir a otra Pila EsVacia() WritePila() NombrePila

6. NOMBRE Comentarios Estructu es una Unidad que permite trabajar con pilas en Pascal Se definen los datos con los que va a trabajar el programa. Se escriben las instrucciones que trabajarán sobre los datos para lograr el objetivo del programa.

7. C:\fpc\bin\Inicial Ingresar elementos a la Pila: <Base><...><Tope> Program Inicial; {Este Programa es un ejemplo sencillo de manejo de Pilas en Pascal: Leer los datos de una Pila por pantalla e imprimirlos } uses Estructu; var Origen: pila; Begin ReadPila(Origen); WritePila(Origen); end. 1 2 3 4 5 6 7 8 9 10 11 12 13 4 1 Estado de las Pilas durante ejecución: 1 4 Origen

8. C:\fpc\bin\Inicial Ingresar elementos a la Pila: <Base><...><Tope> Program Inicial; {Este Programa es un ejemplo sencillo de manejo de Pilas en Pascal: Leer los datos de una Pila por pantalla e imprimirlos } uses Estructu; var Origen: pila; Begin ReadPila(Origen); WritePila(Origen); end. 1 2 3 4 5 6 7 8 9 10 11 12 13 4 1 <Base> 1 4 <Tope> Estado de las Pilas durante ejecución: 1 4 Origen

9. Sentencias Secuenciales: se ejecutan una después de la otra

10. Problema: pasar el tope de una pila a otra Origen Destino

11. Problema: pasar el tope de una pila a otra Origen Destino Apilar (Destino, Desapilar(Origen));

12. Problema: pasar el tope de una pila a otra ¿ Qué pasaría si Destino tiene elementos? Origen Destino Apilar (Destino, Desapilar(Origen));

13. Problema: pasar el tope de una pila a otra ¿ Qué pasaría si Destino tiene elementos? Origen Destino Apilar (Destino, Desapilar(Origen));

14. Problema: pasar el tope de una pila a otra ¿Qué pasaría si Origen NO tiene elementos? ¡ Desapilar de una pila vacía da error! ¿Cómo se puede controlar? Origen Destino Apilar (Destino, Desapilar(Origen));

15. Sentencia de control: Selección A través de la selección se incorpora la capacidad de decisión en un programa. IF (condición) then acción o acciones a realizar si la condición es verdadera else acción o acciones a realizar si la condición es falsa donde condición es una expresión que al ser evaluada puede tomar solamente uno de dos valores posibles: verdadero o falso. De esta forma será posible seleccionar una de dos alternativas de acción posibles durante la ejecución del programa.

16. Sentencia de control: Selección If (condición) then acción o acciones a realizar si la condición es verdadera En este caso, si la condición es falsa, no se especifica ningún camino alternativo a seguir.

17. C:\fpc\bin\PasaTope Program PasaTope; {Este Programa pasa el tope de la pila Origen a Destino } uses Estructu; var Origen, Destino: pila; Begin ReadPila(Origen); InicPila(Destino, ' '); if not PilaVacia(Origen) then Apilar (Destino, Desapilar(Origen)); WritePila(Origen); WritePila(Destino); end. Condición que dará Verdadero o Falso Estado de las Pilas durante ejecución: Origen Destino

18. C:\fpc\bin\PasaTope Ingresar elementos a la Pila: <Base><...><Tope> Program PasaTope; {Este Programa pasa el tope de la pila Origen a Destino } uses Estructu; var Origen, Destino: pila; Begin ReadPila(Origen); InicPila(Destino, ' '); if not PilaVacia(Origen) then Apilar (Destino, Desapilar(Origen)); WritePila(Origen); WritePila(Destino); end. 4 1 Estado de las Pilas durante ejecución: Origen Destino 1 4

19. C:\fpc\bin\PasaTope Ingresar elementos a la Pila: <Base><...><Tope> Program PasaTope; {Este Programa pasa el tope de la pila Origen a Destino } uses Estructu; var Origen, Destino: pila; Begin ReadPila(Origen); InicPila(Destino, ' '); if not PilaVacia(Origen) then Apilar (Destino, Desapilar(Origen)); WritePila(Origen); WritePila(Destino); end. 4 1 Estado de las Pilas durante ejecución: Origen Destino ‘ ‘ 1 4

20. C:\fpc\bin\PasaTope Ingresar elementos a la Pila: <Base><...><Tope> Program PasaTope; {Este Programa pasa el tope de la pila Origen a Destino } uses Estructu; var Origen, Destino: pila; Begin ReadPila(Origen); InicPila(Destino, ' '); if not PilaVacia(Origen) then Apilar (Destino, Desapilar(Origen)); WritePila(Origen); WritePila(Destino); end. 4 1 Estado de las Pilas durante ejecución: Origen Destino ‘ ‘ 1 4

21. C:\fpc\bin\PasaTope Ingresar elementos a la Pila: <Base><...><Tope> Program PasaTope; {Este Programa pasa el tope de la pila Origen a Destino } uses Estructu; var Origen, Destino: pila; Begin ReadPila(Origen); InicPila(Destino, ' '); if not PilaVacia(Origen) then Apilar (Destino, Desapilar(Origen)); WritePila(Origen); WritePila(Destino); end. 4 1 Estado de las Pilas durante ejecución: Origen Destino 1 4

22. C:\fpc\bin\PasaTope Ingresar elementos a la Pila: <Base><...><Tope> Program PasaTope; {Este Programa pasa el tope de la pila Origen a Destino } uses Estructu; var Origen, Destino: pila; Begin ReadPila(Origen); InicPila(Destino, ' '); if not PilaVacia(Origen) then Apilar (Destino, Desapilar(Origen)); WritePila(Origen); WritePila(Destino); end. 4 1 <Base> 1 <Tope> Estado de las Pilas durante ejecución: Origen Destino 1 4

23. C:\fpc\bin\PasaTope Ingresar elementos a la Pila: <Base><...><Tope> Program PasaTope; {Este Programa pasa el tope de la pila Origen a Destino} uses Estructu; var Origen, Destino: pila; Begin ReadPila(Origen); InicPila(Destino, ' '); if not PilaVacia(Origen) then Apilar (Destino, Desapilar(Origen)); WritePila(Origen); WritePila(Destino); end. 4 1 <Base> 1 <Tope> <Base> 4 <Tope> Estado de las Pilas durante ejecución: Origen Destino 1 4

24. C:\fpc\bin\PasaTope Ingresar elementos a la Pila: <Base><...><Tope> Program PasaTope; {Este Programa pasa el tope de la pila Origen a Destino y avisa si la Pila Origen es vacia} uses Estructu; var Origen, Destino: pila; Begin ReadPila(Origen); InicPila(Destino, ' '); if not PilaVacia(Origen) then begin Apilar (Destino, Desapilar(Origen)); WritePila(Origen); WritePila(Destino) end else Writeln('La Pila Origen está vacía'); end. Estado de las Pilas durante ejecución: Origen Destino

25. C:\fpc\bin\PasaTope Ingresar elementos a la Pila: <Base><...><Tope> Program PasaTope; {Este Programa pasa el tope de la pila Origen a Destino y avisa si la Pila Origen es vacia} uses Estructu; var Origen, Destino: pila; Begin ReadPila(Origen); InicPila(Destino, ' '); if not PilaVacia(Origen) then begin Apilar (Destino, Desapilar(Origen)); WritePila(Origen); WritePila(Destino) end else Writeln('La Pila Origen está vacía'); end. Estado de las Pilas durante ejecución: Origen Destino

26. C:\fpc\bin\PasaTope Ingresar elementos a la Pila: <Base><...><Tope> Program PasaTope; {Este Programa pasa el tope de la pila Origen a Destino y avisa si la Pila Origen es vacia} uses Estructu; var Origen, Destino: pila; Begin ReadPila(Origen); InicPila(Destino, ' '); if not PilaVacia(Origen) then begin Apilar (Destino, Desapilar(Origen)); WritePila(Origen); WritePila(Destino) end else Writeln('La Pila Origen está vacía'); end. Estado de las Pilas durante ejecución: Origen Destino

27. C:\fpc\bin\PasaTope Ingresar elementos a la Pila: <Base><...><Tope> Program PasaTope; {Este Programa pasa el tope de la pila Origen a Destino y avisa si la Pila Origen es vacia} uses Estructu; var Origen, Destino: pila; Begin ReadPila(Origen); InicPila(Destino, ' '); if not PilaVacia(Origen) then begin Apilar (Destino, Desapilar(Origen)); WritePila(Origen); WritePila(Destino) end else Writeln('La Pila Origen está vacía'); end. La Pila Origen está vacía Estado de las Pilas durante ejecución: Origen Destino

28. Práctica 1) Cargar desde el teclado una pila DADA con 5 elementos. Pasar los tres primeros elementos a la pila CJTO1 y los dos restantes a la pila CJTO2, ambas pilas inicializadas en vacío. (Ejercicio 1 de Práctico 1) 2 ) Cargar desde el teclado una pila DADA. Inicializar una pila MODELO con al menos un elemento. Pasar el tope de DADA a una pila MENOR si es menor al tope de MODELO. Si es mayor pasarlo a una pila MAYOR.

29. Problema: Pasar todos los elementos de una Pila a Otra

30. Program PasaPila; {Este Programa pasa los elementos de la pila Origen a Destino} uses Estructu; var Origen, Destino: pila; Begin ReadPila(Origen); InicPila(Destino, ' '); if not PilaVacia(Origen) then Apilar (Destino, Desapilar(Origen)); if not PilaVacia(Origen) then Apilar (Destino, Desapilar(Origen)); if not PilaVacia(Origen) then Apilar (Destino, Desapilar(Origen)); ……… WritePila(Origen); WritePila(Destino) end. x Whilenot PilaVacia(Origen) do Apilar (Destino, Desapilar(Origen));

31. Estructura de control: Iteración (WHILE) • Existen situaciones en las que se quiere repetir un conjunto de acciones pero se desconoce de antemano el número de veces. La iteración es una estructura de control que permite al algoritmo ejecutar en forma repetitiva un conjunto de acciones utilizando una condición para indicar su finalización.

32. C:\fpc\bin\OrdenarPorSeleccion C:\fpc\bin\PasaPila Ingresar elementos a la Pila: <Base><...><Tope> Program PasaPila; {Este Programa pasa los elementos de la pila Origen a Destino} uses Estructu; var Origen, Destino: pila; Begin ReadPila(Origen); InicPila(Destino, ' '); While not PilaVacia(Origen) do Apilar (Destino, Desapilar(Origen)); WritePila(Origen); WritePila(Destino) end. 1 4 3 Estado de las Pilas durante ejecución: 1 4 3 Origen Destino

33. C:\fpc\bin\PasaPila Ingresar elementos a la Pila: <Base><...><Tope> Program PasaPila; {Este Programa pasa los elementos de la pila Origen a Destino} uses Estructu; var Origen, Destino: pila; Begin ReadPila(Origen); InicPila(Destino, ' '); While not PilaVacia(Origen) do Apilar (Destino, Desapilar(Origen)); WritePila(Origen); WritePila(Destino) end. 1 4 3 Estado de las Pilas durante ejecución: 1 4 3 Origen ‘ ‘ Destino

34. C:\fpc\bin\PasaPila Ingresar elementos a la Pila: <Base><...><Tope> Program PasaPila; {Este Programa pasa los elementos de la pila Origen a Destino} uses Estructu; var Origen, Destino: pila; Begin ReadPila(Origen); InicPila(Destino, ' '); While not PilaVacia(Origen) do Apilar (Destino, Desapilar(Origen)); WritePila(Origen); WritePila(Destino) end. 1 4 3 Estado de las Pilas durante ejecución: 1 4 3 Origen ‘ ‘ Destino

35. C:\fpc\bin\PasaPila Ingresar elementos a la Pila: <Base><...><Tope> Program PasaPila; {Este Programa pasa los elementos de la pila Origen a Destino} uses Estructu; var Origen, Destino: pila; Begin ReadPila(Origen); InicPila(Destino, ' '); While not PilaVacia(Origen) do Apilar (Destino, Desapilar(Origen)); WritePila(Origen); WritePila(Destino) end. 1 4 3 Estado de las Pilas durante ejecución: 1 4 Origen 3 Destino

36. C:\fpc\bin\PasaPila Ingresar elementos a la Pila: <Base><...><Tope> Program PasaPila; {Este Programa pasa los elementos de la pila Origen a Destino} uses Estructu; var Origen, Destino: pila; Begin ReadPila(Origen); InicPila(Destino, ' '); While not PilaVacia(Origen) do Apilar (Destino, Desapilar(Origen)); WritePila(Origen); WritePila(Destino) end. 1 4 3 Estado de las Pilas durante ejecución: 1 4 Origen 3 Destino

37. C:\fpc\bin\PasaPila Ingresar elementos a la Pila: <Base><...><Tope> Program PasaPila; {Este Programa pasa los elementos de la pila Origen a Destino} uses Estructu; var Origen, Destino: pila; Begin ReadPila(Origen); InicPila(Destino, ' '); While not PilaVacia(Origen) do Apilar (Destino, Desapilar(Origen)); WritePila(Origen); WritePila(Destino) end. 1 4 3 Estado de las Pilas durante ejecución: 1 Origen 3 4 Destino

38. C:\fpc\bin\PasaPila Ingresar elementos a la Pila: <Base><...><Tope> Program PasaPila; {Este Programa pasa los elementos de la pila Origen a Destino} uses Estructu; var Origen, Destino: pila; Begin ReadPila(Origen); InicPila(Destino, ' '); While not PilaVacia(Origen) do Apilar (Destino, Desapilar(Origen)); WritePila(Origen); WritePila(Destino) end. 1 4 3 Estado de las Pilas durante ejecución: 1 Origen 3 4 Destino

39. C:\fpc\bin\PasaPila Ingresar elementos a la Pila: <Base><...><Tope> Program PasaPila; {Este Programa pasa los elementos de la pila Origen a Destino} uses Estructu; var Origen, Destino: pila; Begin ReadPila(Origen); InicPila(Destino, ' '); While not PilaVacia(Origen) do Apilar (Destino, Desapilar(Origen)); WritePila(Origen); WritePila(Destino) end. 1 4 3 Estado de las Pilas durante ejecución: Origen 3 4 1 Destino

40. C:\fpc\bin\PasaPila Ingresar elementos a la Pila: <Base><...><Tope> Program PasaPila; {Este Programa pasa los elementos de la pila Origen a Destino} uses Estructu; var Origen, Destino: pila; Begin ReadPila(Origen); InicPila(Destino, ' '); While not PilaVacia(Origen) do Apilar (Destino, Desapilar(Origen)); WritePila(Origen); WritePila(Destino) end. 1 4 3 Estado de las Pilas durante ejecución: Origen 3 4 1 Destino

41. C:\fpc\bin\PasaPila Ingresar elementos a la Pila: <Base><...><Tope> Program PasaPila; {Este Programa pasa los elementos de la pila Origen a Destino} uses Estructu; var Origen, Destino: pila; Begin ReadPila(Origen); InicPila(Destino, ' '); While not PilaVacia(Origen) do Apilar (Destino, Desapilar(Origen)); WritePila(Origen); WritePila(Destino) end. 1 4 3 <Base> Vacía <Tope> Estado de las Pilas durante ejecución: Origen 3 4 1 Destino

42. C:\fpc\bin\PasaPila Ingresar elementos a la Pila: <Base><...><Tope> Program PasaPila; {Este Programa pasa los elementos de la pila Origen a Destino} uses Estructu; var Origen, Destino: pila; Begin ReadPila(Origen); InicPila(Destino, ' '); While not PilaVacia(Origen) do Apilar (Destino, Desapilar(Origen)); WritePila(Origen); WritePila(Destino) end. 1 4 3 <Base> Vacía <Tope> <Base> 3 4 1 <Tope> Estado de las Pilas durante ejecución: Origen Destino 3 4 1

43. Estructura de control: Iteración (WHILE) While (condición sea verdadera)do Acción o acciones a realizar - La condición es evaluada en cada ciclo - Debe haber alguna acción dentro del conjunto de acciones que modifiquen el valor de la condición (SE CORTA la Iteración)

44. Program PasaPila; {Este Programa pasa los elementos de la pila Origen a Destino} uses Estructu; var Origen, Destino: pila; Begin ReadPila(Origen); InicPila(Destino, ' '); While not PilaVacia(Origen) do Apilar (Destino, Desapilar(Origen)); WritePila(Origen); WritePila(Destino) end. Al ir desapilando los elementos de Origen, en algún momento la pila Origen estará vacía y la condición se dejará de cumplir

45. Program PasaPila; {Este Programa pasa los elementos de la pila Origen a Destino} uses Estructu; var Origen, Destino: pila; Begin ReadPila(Origen); InicPila(Destino, ' '); While not PilaVacia(Origen) do Apilar (Origen, Desapilar(Origen)); WritePila(Origen); WritePila(Destino) end. ¡INCORRECTO! Nunca va a ser falsa la condición, no se termina la iteración

46. Ejercitación • Cargar desde teclado una pila DADA y pasar a la pila DISTINTOS todos aquellos elementos distintos al valor 8. (ej. 2 del práctico) • ¿Cuál es la condición del siguiente ciclo? ¿Cuándo finaliza el ciclo? (Pila1, Pila2, y Descarte son pilas) (ej. 3 del práctico) while not pilaVacia(Pila1) do begin apilar (Pila2, desapilar(Descarte)) end • Pasar todos los elementos de una pila Origen a la pila Menor si son menores a 5 y sino pasarlos a la pila MAYOR.

47. C:\fpc\bin\DivideMenores5 Program DivideMenores5; {este programa pasa todos los números de la pila Origen a la pila Menores y los otros a la pila Mayores} uses Estructu; var Origen, Menores, Mayores: Pila; Begin ReadPila(Origen); InicPila(Menores, ' '); InicPila(Mayores, ' '); While not PilaVacia(Origen) do if tope(Origen) < 5 then Apilar (Menores, Desapilar(Origen)) else Apilar (Mayores, Desapilar(Origen)); writePila(Menores); writePila(Mayores); end. Ingresar elementos a la Pila: <Base><...><Tope> 1 8 2 Estado de las Pilas durante ejecución: Origen 1 8 2 Menores Mayores

48. C:\fpc\bin\DivideMenores5 Program DivideMenores5; {este programa pasa todos los números de la pila Origen a la pila Menores y los otros a la pila Mayores} uses Estructu; var Origen, Menores, Mayores: Pila; Begin ReadPila(Origen); InicPila(Menores, ' '); InicPila(Mayores, ' '); While not PilaVacia(Origen) do if tope(Origen) < 5 then Apilar (Menores, Desapilar(Origen)) else Apilar (Mayores, Desapilar(Origen)); writePila(Menores); writePila(Mayores); end. Ingresar elementos a la Pila: <Base><...><Tope> 1 8 2 Estado de las Pilas durante ejecución: Origen 1 8 2 ‘ ‘ Menores Mayores

49. C:\fpc\bin\DivideMenores5 Program DivideMenores5; {este programa pasa todos los números de la pila Origen a la pila Menores y los otros a la pila Mayores} uses Estructu; var Origen, Menores, Mayores: Pila; Begin ReadPila(Origen); InicPila(Menores, ' '); InicPila(Mayores, ' '); While not PilaVacia(Origen) do if tope(Origen) < 5 then Apilar (Menores, Desapilar(Origen)) else Apilar (Mayores, Desapilar(Origen)); writePila(Menores); writePila(Mayores); end. Ingresar elementos a la Pila: <Base><...><Tope> 1 8 2 Estado de las Pilas durante ejecución: Origen 1 8 2 ‘ ‘ Menores Mayores ‘ ‘

50. C:\fpc\bin\DivideMenores5 Program DivideMenores5; {este programa pasa todos los números de la pila Origen a la pila Menores y los otros a la pila Mayores} uses Estructu; var Origen, Menores, Mayores: Pila; Begin ReadPila(Origen); InicPila(Menores, ' '); InicPila(Mayores, ' '); While not PilaVacia(Origen) do if tope(Origen) < 5 then Apilar (Menores, Desapilar(Origen)) else Apilar (Mayores, Desapilar(Origen)); writePila(Menores); writePila(Mayores); end. Ingresar elementos a la Pila: <Base><...><Tope> 1 8 2 Estado de las Pilas durante ejecución: Origen 1 8 2 ‘ ‘ Menores Mayores ‘ ‘