PILAS EstructuraDeDatos-1

Título Pilas
Nombres y Apellidos Grupo Código de estudiantes

Apaza Licoña Macedonio Jhunior A 82566
Autor/es Patty Apaza Ariel A 88806
Rojas Quispe Martha Mishel A 91510
Tancara Aberari Nataly Priscilla B 87806
Fecha 25/11/2022
Carrera Ingeniería de sistemas

Asignatura Estructura de Datos
Docente Ing. Simón Onofre López
Periodo Académico Segundo Semestre 2022
Subsede La Paz
Copyright © 2022 por (NOMBRES). Todos los derechos reservados.
.
Pilas en programación (java)
RESUMEN:
Una pila, es una estructura de datos que almacena elementos de forma lineal siguiendo una arquitectura
de tipo LIFO que se refiere a que el último elemento que entra es el primero que sale. A la hora de
implementar un stack, se puede utilizar tanto un array como una lista enlazada.
Funciona a través de dos operaciones fundamentales apilar (push), que coloca un objeto en la pila, y su
operación contraria, desapilar (pop), que retira el último elemento apilado.
Las pilas son una estructura de datos y la aplican en la solución de diversos tipos de problemas. Se
pueden ejecutar en programas distintos.
Palabras clave: Pila, Aplicación, Programa
ABSTRACT:
A stack is a data structure that stores elements in a linear fashion following a LIFO-type architecture
that refers to the fact that the last element to enter is the first to leave. When implementing a stack, you
can use both an array and a linked list.
It works through two fundamental operations: push, which pushes an object onto the stack, and its
opposite operation, pop, which removes the last stacked item.
Stacks are a data structure and apply it in solving various types of problems. They can be run in
different programs.
Key words: Stack, Application, Program
Estructura de datos
Ingeniería de sistemas Página 2 de 26
Tabla De Contenidos
Introducción ............................................................................................................................. 4
Capítulo 1. Objetivos ............................................................................................................... 5
Capítulo 2. Marco Teórico ....................................................................................................... 6
2.1 Historia de la Pila ....................................................................................................... 6
2.2 ¿Qué es una Pila? ........................................................................................................ 6
2.3 ¿Cómo se arma una Pila?............................................................................................ 8
2.3.1 Apilar ..................................................................................................................... 8
2.3.2 Desapilar ................................................................................................................ 9
2.3.3 Procedimiento ...................................................................................................... 10
2.4 Aplicaciones de las Pilas .......................................................................................... 11
2.4.1 Llamadas a subprogramas ................................................................................... 11
2.4.2 Eliminación de la Recursividad ........................................................................... 13
2.4.3 Tratamiento de expresiones aritméticas .............................................................. 14
2.5 Prueba y ejecución de pilas en java .......................................................................... 18
2.5.1 Ejemplo de las dos cajas ...................................................................................... 18
2.5.2 Como armar el pogramas de las cajas ................................................................. 18
2.5.3 Imprimir ............................................................................................................... 20
2.5.4 Borrar pantalla ..................................................................................................... 20
2.5.5 Armado del menu ................................................................................................ 21
2.5.6 Menu de opciones ................................................................................................ 22
2.5.7 Ejecución del programa ....................................................................................... 23
Capítulo 3. Conclusiones ....................................................................................................... 25
Bibliografía ............................................................................................................................ 26
Estructura de datos
1. Introducción
La estructura de datos son elementos muy fundamentales al entrar al mundo de la
programación, ya que nos permiten desarrollar y organizar información de forma más
eficiente.
Actualmente hay muchos tipos de estructuras de datos, como la estructura de datos lineales
que son aquellas donde los elementos ocupan lugares en la estructura y cada uno tiene un
sucesor y predesor, si bien este tipo de estructura se divide en tres tipos, en este caso solo nos
centramos en uno de ellas, conoceremos más acerca de las Pilas en la cual nos permite
almacenar y recuperar datos que funciona a través de dos operaciones apilar y desapilar.
Estructura de datos
1. Objetivos
El objetivo de este trabajo es adquirir el conocimiento sobre el tema de las pilas y averiguar
los aspectos importantes en cuanto a lo que son las pilas en java, cuál es su historia de cómo
se creó y quien creo las pilas además de entender como es el armado de una pila para que este
pueda ejecutarse sin ningún problema ya sea la necesidad de usar nuevos métodos como
también está el poner en práctica todo lo aprendido con la aplicación de un ejemplo en el
lenguaje de programación de java y poderlo ejecutar.
Estructura de datos
2. Marco Teórico
2.1 Historia de la Pila
El método de pila para la evaluación de expresiones fue propuesto en 1955 y dos años después
patentado por Friedrich L. Bauer, quien recibió en 1988 el premio “IEEE Computer society
Pioner Award” por su trabajo en el desarrollo de dicha estructura de datos.
2.2 ¿Qué es una Pila (stack)?
Un stack, también conocido como pila, es una estructura de datos que almacena elementos de
forma lineal siguiendo una arquitectura de tipo LIFO (Last In – First Out) en lugar de una
arquitectura de tipo FIFO. Que utilice una arquitectura de tipo LIFO significa que el último
elemento en entrar en el stack es el primero en salir. De este modo, un stack va a trabajar
principalmente a través de dos operaciones clave: push y pop. Al utilizar una arquitectura
LIFO, imaginemos al stack como un cubo en el que vamos introduciendo discos. A medida
que añadimos discos al cubo estos se van apilando uno encima del otro. Esto implica que el
último elemento en ser añadido se va a encontrar siempre en la cima del cubo.
A su vez, en caso de querer desapilar los discos del cubo, tendremos que empezar a quitar los
discos desde la cima. Por tanto, con este ejemplo vemos claramente cómo funciona un stack,
donde tanto la función push (añadir) como la función pop (eliminar) van a actuar siempre
sobre el elemento de la cima de la pila.
Estructura de datos
Además de las funciones push y pop, otras de las tareas que podrá realizar un stack
son:
• Ojear: devuelve el valor de la cima de la pila sin eliminarlo.
• Duplicar: copia el valor de la cima de la pila en otra variable sin eliminarlo.
• Intercambiar: hace un swap de los dos primeros valores de la pila.
• Rotar: desplaza una posición hacia arriba o hacia abajo todos los elementos de la pila
(stack).
A la hora de implementar un stack, se podrá utilizar tanto un array como una lista enlazada.
El elegir una opción u otra será decisión del desarrollador del programa. No obstante, una
lista enlazada será siempre más recomendable debido a que el tamaño de un stack suele ser
dinámico.
Estructura de datos
2.3 ¿Cómo se arma una Pila?
Una pila suele tener 2 operaciones fundamentales:
Apilar (PUSH)
Consiste en añadir un elemento a la pila. En la siguiente imagen se explica de una forma
más abstracta, en la que se puede ver que se está añadiendo el dato 7 sobre el dato 8,
convirtiéndose éste en la cima de la pila.
Estructura de datos
Desapilar (POP)
Es la operación contraria de “Apilar”, es decir, en lugar de añadir el elemento a la pila,
se los va a quitar de la misma forma. En la siguiente imagen se explica de una forma más
abstracta en la que se puede ver que se está quitando de la pila el dato 7 establecido
anteriormente como la cima.
Después de establecer las dos operaciones fundamentales en una pila, se pueden establecer
otras las cuales servirán para obtener información y manipular contenido:
• Crear pila: Inicia la pila
• Pila vacía (EMPTY): Comprueba si la pila no tiene elementos.
• Pila llena: Comprueba si la pila está llena de elementos.
• Limpiar pila: Quita todos sus elementos y deja la pila vacía.
• Cima Pila (PEEK): Obtiene el elemento CIMA de la pila.
• Tamaño de la pila: Números de elementos máximo que puede contener la pila.
• Buscar (SEARCH): Busca un elemento determinado que está dentro de la pila y
devuelve su posición.
Estructura de datos
Procedimiento
• En el Lenguaje JAVA contamos con la clase Starck en la librería java. utill. Es
importante saber que la pila hereda de la pila (aka Vector). Y que por lo tanto podemos
utilizar los elementos del Vector sobre la pila.
• Lo primero será definir la pila, es decir iniciar la clase Stack.
• Como vemos el tipo de elementos que insertaremos en la pila serán String-Cadenas.
• Luego vamos ir creando los elementos insertándolos en las pilas. El método que inserte
elementos a la pila es push (). Este método recibirá como perímetro ele elemento a
insertar.
• Hemos creado un bucle que nos vaya creando los números y nos hemos apoyado en la
clase Interger y su método toString (). Pará convertir los números en cadenas.
• Una vez que tenemos todos los elementos, procedemos al vaciado de la pila.
Tendremos que interactuar sobre la pila hasta que este vacía, cosa que nos dice el
método empty(). En cada cada una de las iteraciones extraeremos un elemento pila
mediante el método pop().
Estructura de datos
2.4 Aplicaciones de la Pilas
Las pilas son una estructura de datos muy usada en la solución de diversos tipos de
Problemas. Algunas de las aplicaciones de la Pilas son:
Llamadas a subprogramas
Cuando se tiene un programa que llama a un subprograma, también conocido como
módulo o función, internamente se usan pilas para guardar el estado de las variables
del programa, así como las instrucciones pendientes de ejecución en el momento que
se hace la llamada. Cuando termina la ejecución del subprograma, los valores
almacenad en la pila se recuperan para continuar con la ejecución del programa en el
punto en cual fue interrumpido. Además de las variables se recupera la dirección del
programa la que se hizo la llamada, porque a esa posición se regresa el control del
proceso.
1)Supongamos, por ejemplo, que se tiene un
programa principal (PP) que llama a los
subprogramas A y B. A su vez, el A B
subprograma B llama al C. Cada vez que la
ejecución de uno de los subprogramas concluye,
se regresa el control al nivel inmediato superior. C
Cuando el programa PP llama a A, se guarda en una pila la posición en la que se hizo
la llamada (a). Al terminar A, el control se regresa a PP recuperando previamente la
dirección de la pila (b). Al llamar a B, nuevamente se guarda la dirección de PP en la
pila (c). Cuando B llama a C, se pone en la pila la dirección de B (d). Después de
Estructura de datos
procesar C, se recupera la posición B para continuar con su ejecución (e). Al terminar
B se regresa el con a PP, obteniendo previamente la dirección guardada en la pila (j).
Permiten guardar la
dirección del programa,
o subprograma, desde
donde se hizo la llamada
a otros subprogramas,
para regresar y seguir
ejecutándolo a partir de
la instrucción inmediata
a la llamada.
2) Supongamos que tenemos 3 subprogramas llamadas A, B y C, A invoca a B y B
invoca a C.
Estructura de datos
B no terminara su trabajo hasta que C haya terminado y devuelva su control a B.
A es el primero que arranca su ejecución, pero es el último que lo termina, tras la
terminación y retorno de B.
Cuando un subprograma termina, debe retornarse a la dirección siguiente a la
instrucción que le llama. Cada vez que se invoca a un subprograma, la dirección
siguiente se introduce en la pila, el vaciado de la pila se realiza por los sucesivos
retornos, decrementandose el puntero de pila que queda libre apuntando a la siguiente
dirección de retorno.
Eliminación de la Recursividad (Programas recursivos a iterativos)
La recursión consume muchos recursos (memoria).
Para transformar algoritmo recursivo en iterativo:
-Se guarda en las pilas el estado del problema en el momento de la llamada
recursiva.
-Se vuelve al principio de la rutina mediante una estructura iterativa.
-La vuelta atrás de la recursión se consigue sacando los valores de las pilas.
Para simular un programa recursivo es necesario la utilización de pilas, ya que está
llamando continuamente a subprogramas que a la vez vuelve a llamarse a sí mismos.
Estructura de datos
Utilizamos como ejemplo el cálculo del número factorial:
Utiliza una pila, donde se van almacenando la instrucciones a ejecutar con los valores
de las constantes y las variables en ese momento.
Cuando se termina la ejecución se llega al estado
básico, se toma la instrucción del tope de la pila y
se continua ejecutando, hasta que la pila queda
vacia.
Tratamiento de expresiones aritméticas
Un problema interesante en computación consiste en convertir expresiones en
notación infija a su equivalente en notación prefija o posfija.
A+B= Infija: Esta notación es Infija porque el operador (+) se encuentra entre los
operandos (A y B).
Estructura de datos
AB+= Posfija: Esta notación es Posfija, porque el operador (+) se encuentra
después de los operandos (A y B).
+AB= Prefija: Esta es una notación Prefija, porque el operador (+) está
precediendo a los operandos (A y B).
La ventaja de usar expresiones en notación posfija o prefija radica en que no son
necesarios los paréntesis para indicar orden de operación, ya que éste queda
establecido por la ubicación de los operadores con respecto a los operandos.
▪ Conversión Infija a Posfija
Para convertir una notación infija a una notación posfija se establecen ciertas
condiciones:
-Los operadores de más alta prioridad se ejecutan primero.
-Si hubiera en una expresión dos o más operadores de igual prioridad,
entonces se procesarán de izquierda a derecha.
-Las subexpresiones que se encuentren entre paréntesis tendrán más
prioridad que cualquier operador.
Estructura de datos
Por ejemplo:
Expresión infija: X + Z * W
Expresión posfija XZW*+
El primer operador que se procesa durante la traducción de la expresión es la
multiplicación, debido a que es el de más alta prioridad.
1.Se coloca el operador de tal manera que los operadores afectados por el
precedan.
2. Para el operador de suma se sigue el mismo criterio, los dos operandos lo
preceden. En este caso el primer operando es X y el segundo es ZW*.
▪ Expresiones Posfijas
-No hace falta conocer reglas de prioridad
-No hace falta emplear paréntesis.
Ejemplo.
1) 6 4 + 2 5 *+
-Se lee la expresión elemento a elemento.
-Si es un operando se mete en una pila
Estructura de datos
-Si es un operador, se extraen los dos últimos elementos introducidos
2)
-Primero creamos una pila
-Se ejecuta la expresion ya que aparecio el
“* “ y se toma los dos ultimos terminos.
-Se actualiza la pila colocando el
siguiente signo que es el “ + “,luego se
vuelve a ejecutar la expresión.
-Se actualiza la pila colocando el
sigueinte numero y el signo que es el “-“,
luego se vuelve a ejecutar la expresión.
-El resultado seria el ultimo digito que
quede en la pila.
Algunos errores seria ingresar algun carácter que no se puede interpretar ni como número ni
como una de las cinco operaciones validas (por ejemplo si la cadena de entrada fue “5 3 &”)
Otro seria que no haya suficientes operandos para realizar la operación (por ejemplo si la cadena
de entrada fue “5 3 - +2).
Estructura de datos
2.5 Prueba y ejecución de pilas en java
El ejemplo de las dos cajas
Para entender mejor sobre el tema de las pilas nosotros nos planteamos el siguiente problema.
Primeramente, tomamos de ejemplo dos cajas donde la principal característica de las cajas al
agregar o poner un producto este entrará, pero si nuevamente colocamos un objeto, el primer
objeto pasará al fondo y el ultimo estará en la cima. ahora al agregar a la otra caja este primero
también pasará al fondo y el último elemento estará en la parte de la cima que será el tope de
nuestra caja
Analizando con el tema de las pilas las dos cajas son las pilas para caja 1 la pila tendrá el nombre
de pila 1 de la misma manera esto se aplicará en la caja 2 que será la pila 2.
Como armar el programa de las cajas
Para empezar con la programación de este ejemplo debemos tomar en cuenta lo que leímos
antes que es el agregar la librería Stack para que el programa reconozca que es una pila lo que
trabajaremos
import java.util.Stack;
Usaremos los siguientes void
public static void imprimir
public static void borrarPantalla ()
Estructura de datos
El programa debemos incluir al programa principal que este será el que una todo y se pueda
compilar dentro del programa principal es donde se recibirá los valores de la pila por ello
como trabajaremos con dos pilas tenemos que colocar dichas pilas utilizando el siguiente
código.
Es aquí donde se agrega las pilas nombrando al objeto seguidamente del nombre que tendra
nuestra pila que se llamaran caja 1 y caja 2.
Una vez ingresado las pilas tenemos que agregar nuestros datos que estaran en las pilas y con
el metodo string podremos colocar nombres mas grandes a diferncia del char que solo recibira
pocas letras . Para agregar las pilas se utiliza el push que se encargara de introducir los datos.
Donde mediante un push agregaremos 4 elementos de tipo string.
En la imagen podemos observar los nombres de tipo string estos seran los objetos que
pondremos en las cajas o pilas y lo agregaremos en la pila 1, por ello ponemos el nombre de
la pila que es caja uno seguidamente de un punto y el push para agregarlo.
Estructura de datos
Imprimir
Antes de seguir con el programa principal debemos tomar en cuenta el void imprimir que lo
utilizaremos a la hora de armar el programa principal y el menu de opciones.
Podemos observar que para hacer la impresion necesitaremos de un ciclo for y dentro de ese
ciclo en condicional if estos nos permitira hacer la impresion de los objetos de la pila que
esten adentro y para saber el tope de la pila es el uso del condicional if .
Borrar pantalla
En java no hay una opcion de borrar las pantallas por ello simularemos un borrado de pantalla
haciendo imprimir 20 o mas lineas en blanco para poder simular dicho borrado de pantalla.
Estructura de datos
Con ciclo for, y dentro del for tenga una impresion de varias teclas espacio armaremos el
borrado de pantalla el cual recorrera 20 lineas de espacio para que este simule un borrar
espacio y cargue el programa ya con el cambio realizado.
Armado del menu
Para poder armar el menu del programa que nos permita realizar el cambio de los objetos a
la otra pila primero debemos de imprimir las pilas y lograr ver su comportamiento a la hora
de hacer el cambio del objeto a la otra pila .
En la siguiente imagen podemos observar que haremos imprimir los datos almacenados en la
pila ademas de imprimir varios “*** ”esto para identificar el fin de la pila y tambien para que
sea mas legible el resultado
Estructura de datos
Menu de opciones
Para realizar el menu de opciones primero realiza la impresion de la barra de menu y cuales
son las opciones y que realizará.
Una vez agregando el menú creamos un objeto para hacer leer el numero entero que se
introducirá, para ello necesitaremos de la librería import java.util.Scanner ; colocando el
objeto opción al principio.
Por ultimo dentro del programa principal realizamos la accion de hacer pasar los objetos de
la pila 1 a la pila 2 .
Estructura de datos
En la primera linea de esta imagen, primero debemos poner el if para ver si se encuentra la
pila vacia y si esta vacia que no nos lance errror posteriormente procedemos a hacer el cambio
de objetos a la otra pila se utiliza el codigo en el medio del if .
Ahora esta imagen solo es para la pila 1 , para realizar la segunda pila es practicamente lo
mismo solo cambia donde dice caja 1 entonces sera caja 2 y viceversa.
Tambien cambia el primer if que nos indica la opcion que estamos colocando en este caso si
ponemos dos con el teclado este hará la opcion de desapilar de la caja2.
Ejecución del programa
Una vez terminado la programación tendría que salirnos como nos muestra en la imagen
posterior.
Estructura de datos
Y si colocamos la opcion uno este desapilara la caja 1 y pasara automáticamente a la caja 2.
Es aquí donde se evidencia que el primer objeto en ingresar este se volvera en el ultimo
elemento.
Estructura de datos
3. Conclusiones
En conclusión, quedamos que las pilas fueron propuestas por Friedrich L. Bauer donde nos
indica que son estructura de datos de tipo LIFO. Usa diferentes tipos de operaciones, pero los
más importantes o más utilizados son el push y pop que son para apilar y desapilar.
Las pilas pueden ser muy útiles en diferentes aplicaciones desde matemáticamente como ser
en los inventarios o en subprogramas y en recursividad. Así también nos ayudan en el
almacenamiento de variables.
Al aplicar ejemplos de pilas en programación dimos a la conclusión que las pilas son muy
útiles dependiendo al uso que las pongas a programar.
Estructura de datos
Bibliografía
Amo Sanz, R., & Martín Fernández, S. (16 de julio de 2014). Pilas y Colas. Obtenido de
SlideServe: https://www.slideserve.com/ranae/pilas-y-colas
Remuzgo, V. (21 de abril de 2018). Aplicaciones de las Pilas. Obtenido de Prezi:
https://prezi.com/rizwicqls7so/aplicaciones-de-las-pilas/
Reyes Ortíz, J. L. (2018). Capítulo PILAS Y COLAS , PILAS. 3.1 INTRODUCCiÓN. Obtenido
de DOCPLAYER: https://docplayer.es/82395435-Capitulo-pilas-y-colas-pilas-3-1-
introduccion.html
Iván Cantador &Rosa Mª Carro.(2015). Programación II, pilas .Obtenido de scholar.gogle.es:
https://www.cartagena99.com/recursos/alumnos/apuntes/prog2-tema2-Pilas-1617.pdf
Victor Cuervo,(06 de octubre de 2009). Crear pila en java.
https://lineadecodigo.com/java/crear-una-pila-en-java/
Estructura de datos

PILAS EstructuraDeDatos-1

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

PILAS EstructuraDeDatos-1

Cargado por

Copyright:

Formatos disponibles

Título Pilas

Nombres y Apellidos Grupo Código de estudiantes

Carrera Ingeniería de sistemas

Palabras clave: Pila, Aplicación, Programa

Key words: Stack, Application, Program

La estructura de datos son elementos muy fundamentales al entrar al mundo de la

programación, ya que nos permiten desarrollar y organizar información de forma más

también está el poner en práctica todo lo aprendido con la aplicación de un ejemplo en el

lenguaje de programación de java y poderlo ejecutar.

2.1 Historia de la Pila

Pioner Award” por su trabajo en el desarrollo de dicha estructura de datos.

2.2 ¿Qué es una Pila (stack)?

elemento en entrar en el stack es el primero en salir. De este modo, un stack va a trabajar

último elemento en ser añadido se va a encontrar siempre en la cima del cubo.

sobre el elemento de la cima de la pila.

• Ojear: devuelve el valor de la cima de la pila sin eliminarlo.

• Duplicar: copia el valor de la cima de la pila en otra variable sin eliminarlo.

• Intercambiar: hace un swap de los dos primeros valores de la pila.

2.3 ¿Cómo se arma una Pila?

Una pila suele tener 2 operaciones fundamentales:

Consiste en añadir un elemento a la pila. En la siguiente imagen se explica de una forma

convirtiéndose éste en la cima de la pila.

Es la operación contraria de “Apilar”, es decir, en lugar de añadir el elemento a la pila,

anteriormente como la cima.

otras las cuales servirán para obtener información y manipular contenido:

• Crear pila: Inicia la pila

• Pila vacía (EMPTY): Comprueba si la pila no tiene elementos.

• Pila llena: Comprueba si la pila está llena de elementos.

• Limpiar pila: Quita todos sus elementos y deja la pila vacía.

• Cima Pila (PEEK): Obtiene el elemento CIMA de la pila.

• Tamaño de la pila: Números de elementos máximo que puede contener la pila.

• Buscar (SEARCH): Busca un elemento determinado que está dentro de la pila y

• En el Lenguaje JAVA contamos con la clase Starck en la librería java. utill. Es

utilizar los elementos del Vector sobre la pila.

• Lo primero será definir la pila, es decir iniciar la clase Stack.

• Como vemos el tipo de elementos que insertaremos en la pila serán String-Cadenas.

mediante el método pop().

2.4 Aplicaciones de la Pilas

Problemas. Algunas de las aplicaciones de la Pilas son:

Cuando se tiene un programa que llama a un subprograma, también conocido como

se hace la llamada. Cuando termina la ejecución del subprograma, los valores

almacenad en la pila se recuperan para continuar con la ejecución del programa en el

1)Supongamos, por ejemplo, que se tiene un

programa principal (PP) que llama a los

subprograma B llama al C. Cada vez que la

ejecución de uno de los subprogramas concluye,

se regresa el control al nivel inmediato superior. C

Cuando el programa PP llama a A, se guarda en una pila la posición en la que se hizo

la llamada (a). Al terminar A, el control se regresa a PP recuperando previamente la

dirección de la pila (b). Al llamar a B, nuevamente se guarda la dirección de PP en la

pila (c). Cuando B llama a C, se pone en la pila la dirección de B (d). Después de

procesar C, se recupera la posición B para continuar con su ejecución (e). Al terminar

B se regresa el con a PP, obteniendo previamente la dirección guardada en la pila (j).

dirección del programa,

donde se hizo la llamada

para regresar y seguir

2) Supongamos que tenemos 3 subprogramas llamadas A, B y C, A invoca a B y B

B no terminara su trabajo hasta que C haya terminado y devuelva su control a B.

A es el primero que arranca su ejecución, pero es el último que lo termina, tras la

Cuando un subprograma termina, debe retornarse a la dirección siguiente a la

instrucción que le llama. Cada vez que se invoca a un subprograma, la dirección

siguiente se introduce en la pila, el vaciado de la pila se realiza por los sucesivos

retornos, decrementandose el puntero de pila que queda libre apuntando a la siguiente