Pilas Una Pila es una coleccin de elementos

Pilas Una Pila es una colección de elementos del mismo tipo organizada como una

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

Pilas • Que se puede hacer sobre una pila? Apilar Desapilar Ver. Tope ….

Pilas en Pascal TOPE En Pascal vamos a trabajar con Pilas de Enteros. 1)

NOMBRE Comentarios Estructu es una Unidad que permite trabajar con pilas en Pascal Se

C: fpcbinInicial Ingresar elementos a la Pila: <Base><. . . ><Tope> 1 2 3

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

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

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

Problema: pasar el tope de una pila a otra ¿ Qué pasaría si Destino

Problema: pasar el tope de una pila a otra ¿Qué pasaría si Origen NO

Sentencia de control: Selección A través de la selección se incorpora la capacidad de

Sentencia de control: Selección If (condición) then acción o acciones a realizar si la

C: fpcbinPasa. Tope Program Pasa. Tope; {Este Programa pasa el tope de la pila

Práctica 1) Cargar desde el teclado una pila DADA con 5 elementos. Pasar los

Problema: Pasar todos los elementos de una Pila a Otra

Program Pasa. Pila; {Este Programa pasa los elementos de la pila Origen a Destino}

Estructura de control: Iteración (WHILE) • Existen situaciones en las que se quiere repetir

C: fpcbinPasa. Pila C: fpcbinOrdenar. Por. Seleccion Program Pasa. Pila; {Este Programa pasa los

C: fpcbinPasa. Pila Program Pasa. Pila; {Este Programa pasa los elementos de la pila

Estructura de control: Iteración (WHILE) While (condición sea verdadera) do Acción o acciones a

Ejercitación • Cargar desde teclado una pila DADA y pasar a la pila DISTINTOS

C: fpcbinDivide. Menores 5 Program Divide. Menores 5; {este programa pasa todos los números

Resumen: operaciones con Pilas • Read. Pila(nombre. Pila) • Inic. Pila(nombre. Pila, ' ')

Estructuras de control • SECUENCIA < sentencia 1 >; < sentencia 2 >; <

Estructuras de control • SELECCIÓN if <condición> then < sentencia si condición es verdadera

Estructuras de control ITERACIÓN while <condición> do < sentencia mientras condición sea verdadera >;

SENTENCIAS COMPUESTAS Una serie de instrucciones básicas que se ejecutan una a continuación de

Estructuras de control if <condición> then begin < sentencia si condición es verdadera >;

Estructuras de control while <condición> do begin < sentencia mientras condición es verdadera >;

Estructuras de control Las estructuras de control se pueden combinar EJEMPLO ……. . While

INDENTACIÓN Program Divide. Menores 5; {este programa pasa todos los números de la pila

Slides: 72

Download presentation

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.

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

Pilas • Que se puede hacer sobre una pila? Apilar Desapilar Ver. Tope …. .

Pilas en Pascal TOPE En Pascal vamos a trabajar con Pilas de Enteros. 1) Cada pila tendrá un nombre. 1) Sólo se ve el TOPE, no se sabe cuantos elementos hay 1) Se podrán hacer las siguientes operaciones: Read. Pila() Inic. Pila () Tope() Apilar () Desapilar() el Elemento que se desapila debe ir a otra Pila Es. Vacia() Write. Pila() Nombre. Pila

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.

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

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

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

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

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

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

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));

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.

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.

C: fpcbinPasa. Tope Program Pasa. Tope; {Este Programa pasa el tope de la pila Origen a Destino } uses Estructu; var Origen, Destino: pila; Begin Read. Pila(Origen); Inic. Pila(Destino, ' '); if not Pila. Vacia(Origen) then Apilar (Destino, Desapilar(Origen)); Write. Pila(Origen); Write. Pila(Destino); end. Condición que dará Verdadero o Falso Estado de las Pilas durante ejecución: Origen Destino

C: fpcbinPasa. Tope Program Pasa. Tope; {Este Programa pasa el tope de la pila Origen a Destino } Ingresar elementos a la Pila: <Base><. . . ><Tope> 1 4 uses Estructu; var Origen, Destino: pila; Begin Read. Pila(Origen); Inic. Pila(Destino, ' '); if not Pila. Vacia(Origen) then Apilar (Destino, Desapilar(Origen)); Write. Pila(Origen); Write. Pila(Destino); end. Estado de las Pilas durante ejecución: Origen Destino 1 4

C: fpcbinPasa. Tope Program Pasa. Tope; {Este Programa pasa el tope de la pila Origen a Destino } Ingresar elementos a la Pila: <Base><. . . ><Tope> 1 <Base> 1 4 <Tope> uses Estructu; var Origen, Destino: pila; Begin Read. Pila(Origen); Inic. Pila(Destino, ' '); if not Pila. Vacia(Origen) then Apilar (Destino, Desapilar(Origen)); Write. Pila(Origen); Write. Pila(Destino); end. Estado de las Pilas durante ejecución: Origen 1 Destino 4

C: fpcbinPasa. Tope Program Pasa. Tope; {Este Programa pasa el tope de la pila Origen a Destino} uses Estructu; var Origen, Destino: pila; Begin Read. Pila(Origen); Inic. Pila(Destino, ' '); if not Pila. Vacia(Origen) then Apilar (Destino, Desapilar(Origen)); Write. Pila(Origen); Write. Pila(Destino); end. Ingresar elementos a la Pila: <Base><. . . ><Tope> 1 <Base> 1 4 4 <Tope> Estado de las Pilas durante ejecución: Origen 1 Destino 4

C: fpcbinPasa. Tope Program Pasa. Tope; {Este Programa pasa el tope de la pila Origen a Destino y avisa si la Pila Origen es vacia} Ingresar elementos a la Pila: <Base><. . . ><Tope> uses Estructu; var Origen, Destino: pila; Begin Read. Pila(Origen); Inic. Pila(Destino, ' '); if not Pila. Vacia(Origen) then begin Apilar (Destino, Desapilar(Origen)); Write. Pila(Origen); Write. Pila(Destino) end else Writeln('La Pila Origen está vacía'); end. Estado de las Pilas durante ejecución: Origen Destino

C: fpcbinPasa. Tope Program Pasa. Tope; {Este Programa pasa el tope de la pila Origen a Destino y avisa si la Pila Origen es vacia} Ingresar elementos a la Pila: <Base><. . . ><Tope> La Pila Origen está vacía uses Estructu; var Origen, Destino: pila; Begin Read. Pila(Origen); Inic. Pila(Destino, ' '); if not Pila. Vacia(Origen) then begin Apilar (Destino, Desapilar(Origen)); Write. Pila(Origen); Write. Pila(Destino) end else Writeln('La Pila Origen está vacía'); end. Estado de las Pilas durante ejecución: Origen Destino

Práctica 1) Cargar desde el teclado una pila DADA con 5 elementos. Pasar los tres primeros elementos a la pila CJTO 1 y los dos restantes a la pila CJTO 2, 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.

Problema: Pasar todos los elementos de una Pila a Otra

Program Pasa. Pila; {Este Programa pasa los elementos de la pila Origen a Destino} uses Estructu; var Origen, Destino: pila; x Begin Read. Pila(Origen); Inic. Pila(Destino, ' '); if not Pila. Vacia(Origen) then Apilar (Destino, Desapilar(Origen)); ……… Write. Pila(Origen); Write. Pila(Destino) end. While not Pila. Vacia(Origen) do Apilar (Destino, Desapilar(Origen));

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.

C: fpcbinPasa. Pila C: fpcbinOrdenar. Por. Seleccion Program Pasa. Pila; {Este Programa pasa los elementos de la pila Origen a Destino} Ingresar elementos a la Pila: <Base><. . . ><Tope> 1 4 3 uses Estructu; var Origen, Destino: pila; Begin Read. Pila(Origen); Inic. Pila(Destino, ' '); While not Pila. Vacia(Origen) do Apilar (Destino, Desapilar(Origen)); Write. Pila(Origen); Write. Pila(Destino) end. Estado de las Pilas durante ejecución: Origen Destino 143

C: fpcbinPasa. Pila Program Pasa. Pila; {Este Programa pasa los elementos de la pila Origen a Destino} Ingresar elementos a la Pila: <Base><. . . ><Tope> 1 4 3 uses Estructu; var Origen, Destino: pila; Begin Read. Pila(Origen); Inic. Pila(Destino, ' '); While not Pila. Vacia(Origen) do Apilar (Destino, Desapilar(Origen)); Write. Pila(Origen); Write. Pila(Destino) end. Estado de las Pilas durante ejecución: Origen Destino 143 ‘ ‘

C: fpcbinPasa. Pila Program Pasa. Pila; {Este Programa pasa los elementos de la pila Origen a Destino} Ingresar elementos a la Pila: <Base><. . . ><Tope> 1 4 <Base> Vacía 3 <Tope> uses Estructu; var Origen, Destino: pila; Begin Read. Pila(Origen); Inic. Pila(Destino, ' '); While not Pila. Vacia(Origen) do Apilar (Destino, Desapilar(Origen)); Write. Pila(Origen); Write. Pila(Destino) end. Estado de las Pilas durante ejecución: Origen Destino 3 4 1

C: fpcbinPasa. Pila Program Pasa. Pila; {Este Programa pasa los elementos de la pila Origen a Destino} Ingresar elementos a la Pila: <Base><. . . ><Tope> 1 4 3 <Base> Vacía <Tope> <Base> 3 4 1 <Tope> uses Estructu; var Origen, Destino: pila; Begin Read. Pila(Origen); Inic. Pila(Destino, ' '); While not Pila. Vacia(Origen) do Apilar (Destino, Desapilar(Origen)); Write. Pila(Origen); Write. Pila(Destino) end. Estado de las Pilas durante ejecución: Origen Destino 3 4 1

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)

Program Pasa. Pila; {Este Programa pasa los elementos de la pila Origen a Destino} uses Estructu; var Origen, Destino: pila; 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 Begin Read. Pila(Origen); Inic. Pila(Destino, ' '); While not Pila. Vacia(Origen) do Apilar (Destino, Desapilar(Origen)); Write. Pila(Origen); Write. Pila(Destino) end.

Program Pasa. Pila; {Este Programa pasa los elementos de la pila Origen a Destino} uses Estructu; var Origen, Destino: pila; Begin Read. Pila(Origen); Inic. Pila(Destino, ' '); While not Pila. Vacia(Origen) do Apilar (Origen, Desapilar(Origen)); Write. Pila(Origen); Write. Pila(Destino) end. ¡INCORRECT O! Nunca va a ser falsa la condición, no se termina la iteración

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? (Pila 1, Pila 2, y Descarte son pilas) (ej. 3 del práctico) while not pila. Vacia(Pila 1) do begin apilar (Pila 2, 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.

C: fpcbinDivide. Menores 5 Program Divide. Menores 5; {este programa pasa todos los números de la pila Origen a la pila Menores y los otros a la pila Mayores} Ingresar elementos a la Pila: <Base><. . . ><Tope> 1 8 2 uses Estructu; var Origen, Menores, Mayores: Pila; Begin Read. Pila(Origen); Inic. Pila(Menores, ' '); Inic. Pila(Mayores, ' '); While not Pila. Vacia(Origen) do if tope(Origen) < 5 then Apilar (Menores, Desapilar(Origen)) else Apilar (Mayores, Desapilar(Origen)); write. Pila(Menores); write. Pila(Mayores); end. Estado de las Pilas durante ejecución: Origen Menores Mayores 1 8 2

C: fpcbinDivide. Menores 5 Program Divide. Menores 5; {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 Read. Pila(Origen); Inic. Pila(Menores, ' '); Inic. Pila(Mayores, ' '); While not Pila. Vacia(Origen) do if tope(Origen) < 5 then Apilar (Menores, Desapilar(Origen)) else Apilar (Mayores, Desapilar(Origen)); write. Pila(Menores); write. Pila(Mayores); end. Ingresar elementos a la Pila: <Base><. . . ><Tope> 1 <Base> 2 8 2 1 <Tope> Estado de las Pilas durante ejecución: Origen ‘ ‘ Menores 2 1 Mayores 8

C: fpcbinDivide. Menores 5 Program Divide. Menores 5; {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 Read. Pila(Origen); Inic. Pila(Menores, ' '); Inic. Pila(Mayores, ' '); While not Pila. Vacia(Origen) do if tope(Origen) < 5 then Apilar (Menores, Desapilar(Origen)) else Apilar (Mayores, Desapilar(Origen)); write. Pila(Menores); write. Pila(Mayores); end. Ingresar elementos a la Pila: <Base><. . . ><Tope> 1 <Base> 2 <Base> 8 8 2 1 <Tope> Estado de las Pilas durante ejecución: Origen ‘ ‘ Menores 2 1 Mayores 8

Resumen: operaciones con Pilas • Read. Pila(nombre. Pila) • Inic. Pila(nombre. Pila, ' ') o Inic. Pila(nombre. Pila, ‘ 3 6 7 ') • Pila. Vacia(nombre. Pila) • Tope(nombre. Pila) • Apilar(nombre. Pila, Desapilar(nombre. Otra Pila)) o Apilar(nombre. Pila, 8) • Write. Pila(nombre. Pila)

Estructuras de control • SECUENCIA < sentencia 1 >; < sentencia 2 >; < sentencia 3 >; Se ejecutan una sola vez en el mismo orden en que aparecen

Estructuras de control • SELECCIÓN if <condición> then < sentencia si condición es verdadera >; if <condición> then < sentencia si condición es verdadera > else < sentencia si condición es falsa >;

Estructuras de control ITERACIÓN while <condición> do < sentencia mientras condición sea verdadera >; En <sentencia> se debe asegurar que la condición va a cambiar para ser falsa en algún momento y cortar el ciclo

SENTENCIAS COMPUESTAS Una serie de instrucciones básicas que se ejecutan una a continuación de otra como un bloque. BEGIN <SENTENCIA 1>; <SENTENCIA 2> END . . IF not Pila. Vacia(Origen) THEN IF tope(Origen) < 5 THEN BEGIN Apilar (Menores, Desapilar(Origen)); write. Pila(Menores); END; ………. . . IF not Pila. Vacia(Origen) THEN IF tope(Origen) < 5 THEN Apilar (Menores, Desapilar(Origen)) write. Pila(Menores); ………. ¿Qué diferencia hay entre los dos códigos?

Estructuras de control if <condición> then begin < sentencia si condición es verdadera >; < sentencia si condición es verdadera > end else begin < sentencia si condición es falsa >; end

Estructuras de control while <condición> do begin < sentencia mientras condición es verdadera >; end

Estructuras de control Las estructuras de control se pueden combinar EJEMPLO ……. . While not Pila. Vacia(Origen) do if tope(Origen) < 5 then begin Apilar (Menores, Desapilar(Origen)); write. Pila(Menores) end else begin Apilar (Mayores, Desapilar(Origen)); write. Pila(Mayores) end …………

INDENTACIÓN Program Divide. Menores 5; {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 Read. Pila(Origen); Inic. Pila(Menores, ' '); Inic. Pila(Mayores, ' '); While not Pila. Vacia(Origen) do if tope(Origen) < 5 then Apilar (Menores, Desapilar(Origen)) else Apilar (Mayores, Desapilar(Origen)); write. Pila(Menores); write. Pila(Mayores); end.

Ejercitación