input/output magazine
DESCRIPTION
POR DESIREE ARAUJOTRANSCRIPT
Presentado por:
Araujo Desiree
C.I: 18.054.971
Profesora:
Elvia Sánchez
EL MUNDO
ING.
COMPUTACION.
EDITORIAL:
En el mundo input/output
(mundo de entrada y salida) se
creo pensando en una revista
donde puedas hacerla parte de tu
mundo entrar y conocer nuevas
temas y luego salir a un mundo
donde podrás poner en practica
todo lo aprendido.
En programación input/output
permite la comunicación entre la
computadora y el usuario. Tienen
una gran importancia en cualquier
lenguaje de programación ya que
no tiene sentido que un lenguaje
de programación no pueda escribir
o leer, cuando se codifica un
programa, se hace con la intención
de que ese programa pueda
interactuar con los usuarios del
mismo, es decir, que el usuario
pueda pedirle que realice cosas y
pueda suministrarle datos con los
que se quiere que haga algo. Una
vez introducidos los datos y las
órdenes, se espera que el programa
manipule de alguna forma esos
datos para proporcionarnos una
respuesta a lo solicitado.
6
4
9
11
12
13
Diferencia entre:
Pila
(Programación)
&
Pila
(Electricidad)
Cuando nos referimos a
pilas llega a la mente de
quien no conoce el
término pila a nivel de
programación la batería
común a la cual todos
estamos acostumbrado:
Pila (eléctrica): Se
denomina pila a
un sistema en el que la
energía química de una
reacción química es
transformada en energía
eléctrica que hace
funcionar a los aparatos.
Pila (programación):
(stack) Una pila es un
conjunto ordenado de
elementos en el cual se
pueden agregar y eliminar
elementos en un extremo,
que es llamado el tope de
la pila
A diferencia de la pila que
comúnmente estamos
acostumbrado a mencionar
stack (apilar en ingles) para
los programadores es una
manera fácil de ver donde
se encuentra una variable.
4 input/output
CALLE 12 ENTRE CARRERAS 18 Y 19.
CONTÁCTANOS: 0251-9764819/ 0412-
6656232/ 0424-5822492
CORREO: [email protected]
Próximamente: Taller de Coctelería Moderna para el sábado 12 y
domingo 13 de Noviembre en INGALA inscripciones abiertas pocos cupos.
Para realizar la inscripción dirigirse a la sede, Valor del curso: 450 Bs.f p/p.
Incluye: materiales, guías y certificado.
Imagina un montón de platos
"apilados" o bien fichas de
dominó formando una torre e
intenta eliminar una desde el
centro, ¿qué ocurre?,
naturalmente esta operación
no está permitida si queremos
mantener intactos a los platos
o a la torre construida. Por
esta razón, una pila se asocia
a una estructura de datos
LIFO (LAST IN FIRST OUT en
español, último en entrar,
primero en salir).
Podemos decir que una pila
es una colección de
elementos a la cual se le
puede insertar o eliminar
elementos solamente por uno
de los extremos los
operaciones de inserción y
extracción se realiza a través
del tope, por la cual no se
puede acceder a cualquier
elemento de la pila .
Otra Manera De Verlo:
PILAS
Son unas estructuras que son más
utilizadas siempre que se quieran
recuperar una serie de elementos en
orden inverso a como se introdujeron.
Tanto la extracción como la inserción
de un elemento en la pila se realiza por
la parte superior, por lo tanto, el único
elemento al que podemos acceder es
el ultimo, y como el ultimo elemento
que se pone en la pila es el primero
que se puede sacar, a estas
estructuras dinámicas llamadas pilas
se les conoce como LIFO (Last In First
Off). Las pilas se deben implementar
de forma dinámica utilizando punteros,
pero si el lenguaje de programación
que estamos utilizando no admite
punteros, entonces tendremos que
utilizar arrays, y además una variable
que normalmente se le da el nombre
de `cima' y es la que apunta al último
elemento de la pila.
Aplicaciones de las pilas: el uso más común que suele darse a
las pilas es cuando hacemos una llamada desde un programa
a otro subprograma. Se utiliza las pilas para guardar el lugar
desde donde se hizo la llamada y para almacenar el estado de
las variables en el momento en que se hace la llamada.
También se utilizan en todos los algoritmos recursivos para
almacenar el valor de las variables y los parámetros.
Si tenemos un par de
elementos en la pila, uno de
ellos debe estar en la parte
superior de la pila, que se
considera el más alto'' en la
pila que el otro. En la pila que
mostramos el elemento F es
el más alto de todos los
elementos que están en la
pila. El elemento D es el más
alto de los elementos A,B,C,
pero es menor que los
elementos E y F.
Para describir
cómo funciona esta estructura,
debemos agregar un nuevo
elemento, el elemento G.
Después de haber agregado el
elemento G a la pila, la nueva
configuración es la que se
muestra
De acuerdo con la
definición, existe
solamente un lugar en
donde cualquier elemento
puede ser agregado a la
pila. Después de haber
insertado el nuevo
elemento, G ahora es el
elemento en la cima.
Debemos aclarar en qué
pila deseamos insertar
elementos, puesto que es
posible tener más de una
pila al mismo tiempo.
Cuando se desea retirar un
elemento de la pila, solo
basta ordenar que sea
retirado un elemento; no
podemos decir
``retira C de la pila'',
porque C no está en la
cima de la pila y solamente
podemos retirar el
elemento que está en la
cima. Para que la
sentencia ``retira C de la
pila'' tenga sentido,
debemos replantear las
órdenes a algo como:
Retira de la pila hasta que
el elemento retirado sea C.
Ni siquiera es necesario
decir: “Retira un elemento
de la pila...'' porque es
sobreentendido que
solamente se puede sacar
un elemento a la vez.
Siguiendo nuestro ejemplo,
ahora deseamos retirar de
la pila P. La configuración
global de la pila es como
se muestra en la figura
- Crear la pila
(CrearPila): La
operación de creación
de la pila inicia la pila
como vacía.
Operaciones para
añadir y eliminar
información:
- Añadir elementos en la
cima (Apilar): pondrá un
nuevo elemento en la
parte superior de la pila.
- Eliminar elementos de
la cima (Desapilar): lo
que hará será devolver
el elemento superior de
la cima y eliminarlo de
la pila.
Operaciones para
comprobar tanto la
información contenida
en la pila, como el
propio estado de la
cima:
- Comprobar si la pila
está vacía (PilaVacia):
Esta operación es
necesaria para poder
decidir si es posible
eliminar elementos de
la pila.
- Acceder al elemento
situado en la cima
(CimaPila): Nos indica el
valor del elemento
situado en la parte
superior de la pila.
La especificación
correcta de todas estas
operaciones permitirá
definir adecuadamente
una pila.
push-> Se utiliza para
introducir elementos, ésta
función necesita como
argumento a la pila y el
elemento a introducir.
pop-> se utiliza para sacar
elementos de la pila, Como
argumentos, necesita,
únicamente a la pila.
Hemos llenado nuestra pila,
llamada "s", con los valores
que le indicamos en la
función push.
Ahora si queremos sacar el
elemento del tope, basta
indicar con la siguiente
sentencia:
Pop(s);
Pop(s);
Y la pila quedaría:
Se debe tener en cuenta que,
dentro de las funciones pop y
push, pueden estar otras
funciones inmersas, por
ejemplo, si queremos
introducir más datos,
debemos tener otra función
que verifique si la pila, no
está llena. Por el contrario si
queremos sacar datos,
debemos cerciorarnos que la
pila no esté vacía, es ahí
donde nacen estas otras
funciones que deben estar
presentes en nuestros
programas:
->empty, que verifica si la pila
está vacía
->stacktop->retorna el
elemento superior de la pila.
Esta implementación es estática, es decir, da un
tamaño máximo fijo a la pila, y si se sobrepasa dicho
límite se produce un error. La comprobación de
apilado en una pila llena o des apilado en una pila
vacía no se han hecho, pero sí las funciones de
comprobación, que el lector puede modificar según
las necesidades de su programa.
- Declaración:
struct tpila
{
int cima;
int elementos[MAX_PILA];
};
Nota: MAX_PILA debe ser mayor o igual que 1. -
Procedimiento de Creación:
void crear(struct tpila *pila)
{
pila->cima = -1;
}
- Función que devuelve verdadero si la pila está
vacía:
int vacía(struct tpila *pila)
{
return (pila->cima == -1);
}
- Función que devuelve verdadero si la pila está llena:
int llena(struct tpila *pila)
{
return (pila->cima == MAX_PILA);
}
- Procedimiento de apilado:
void apilar(struct tpila *pila, int elem)
{
pila->elementos[++pila->cima] = elem;
}
- Procedimiento de desapilado:
void desapilar(struct tpila *pila, int *elem)
{
*elem = pila->elementos[pila->cima--];
}
Programa de prueba:
#include <stdio.h>
int main(void)
{
struct tpila pila;
int elem;
crear(&pila);
if (vacia(&pila)) printf("\nPila vacia.");
if (llena(&pila)) printf("\nPila llena.");
apilar(&pila, 1);
desapilar(&pila, &elem);
return 0;
}
