2.

1 Definición
^

Una pila es un tipo especial de lista abierta en la que sólo se pueden insertar y eliminar
nodos en uno de los extremos de la lista. Estas operaciones se conocen como "push" y
"pop", respectivamente "empujar" y "tirar". Además, las escrituras de datos siempre son
inserciones de nodos, y las lecturas siempre eliminan el nodo leído.

Estas características implican un comportamiento de lista LIFO (Last In First Out), el

último en entrar es el primero en salir.

El símil del que deriva el nombre de la estructura es una pila de platos. Sólo es posible
añadir platos en la parte superior de la pila, y sólo pueden tomarse del mismo extremo.

El nodo típico para construir pilas es el mismo que vimos en el capítulo anterior para la
construcción de listas:

struct nodo \{
int dato;
struct nodo *siguiente;
};

2.2 Declaraciones de tipos para manejar pilas en C

^

Los tipos que definiremos normalmente para manejar pilas serán casi los mismos que para
manejar listas, tan sólo cambiaremos algunos nombres:

typedef struct _nodo \{

int dato;
struct _nodo *siguiente;
} tipoNodo;

typedef tipoNodo *pNodo;

typedef tipoNodo *Pila;

tipoNodo es el tipo para declarar nodos, evidentemente.

pNodo es el tipo para declarar punteros a un nodo.

Pila es el tipo para declarar pilas.

Pila

Es evidente, a la vista del gráfico, que una pila es una lista abierta. Así que sigue siendo
muy importante que nuestro programa nunca pierda el valor del puntero al primer elemento,
igual que pasa con las listas abiertas.

Teniendo en cuenta que las inserciones y borrados en una pila se hacen siempre en un
extremo, lo que consideramos como el primer elemento de la lista es en realidad el último
elemento de la pila.

Pilas y colas en C
Anuncios Google

 Subsea Insulationwww.aisplc.com - For rigid structures and jumpers 200 deg C and 300
Bar

Bueno aqui les dejo algo de info para todos aquellos que quieren saber como hacer un pila y una
cola en C.
Primero que nada una pila (stack en inglés) es una lista ordinal o estructura de datos en la que el
modo de acceso a sus elementos es de tipo LIFO (del inglés Last In First Out, último en entrar,
primero en salir) que permite almacenar y recuperar datos. Se aplica en multitud de ocasiones en
informática debido a su simplicidad y ordenación implícita en la propia estructura.

Para el manejo de los datos se cuenta con dos operaciones básicas: apilar (push), que coloca un
objeto en la pila, y su operación inversa, retirar (o desapilar, pop), que retira el último elemento
apilado.

ejemplo de pila en C

#include<stdio.h>
#include<conio.h>
main ()
{

int arreglo[6];
int numero=0,i=0,x=0;
do
{
clrscr ();
scanf("%i",&numero);
switch(numero)
{
case 1:{
if(i>5)
else
{
scanf("%i",&arreglo);
i++;
}
}
break;
case 2:
{
if(i<=0)
else
{
// i--;
arreglo=0;
i--;
}
}
break;
case 3:
{
for(x=0;x<i;x++)
{
printf("t%it",arreglo[x]);
}
}
getch();
break;
case 4:
{
}
break;
}
}
while(numero<4);
return 0;
}

y una cola es una estructura de datos, caracterizada por ser una secuencia de elementos en la que
la operación de inserción push se realiza por un extremo y la operación de extracción pop por el
otro. También se le llama estructura FIFO (del inglés First In First Out), debido a que el primer
elemento en entrar será también el primero en salir.

Las colas se utilizan en sistemas informáticos, transportes y operaciones de investigación (entre

otros), dónde los objetos, personas o eventos son tomados como datos que se almacenan y se
guardan mediante colas para su posterior procesamiento. Este tipo de estructura de datos
abstracta se implementa en lenguajes orientados a objetos mediante clases, en forma de listas
enlazadas.

ejemplo de cola en C
#include<stdio.h>
#include<conio.h>
main ()
{
int arreglo[6];
int numero=0,i=0,x=0;

do
{
scanf("%i",&numero);
switch(numero)
{
case 1:
{
if(i>5)
else
{
scanf("%i",&arreglo);
i++;
}
getch();
}
break;
case 2:
{
//if(i>=0 &&i<=5)
// {
if(i<1)
else
{
arreglo[0]=NULL;
for(x=0;x<i;x++)
{
arreglo[x]=arreglo[x+1];
}
arreglo[x]=0;
i--;

// }
getch();
}
break;
case 3:
{
for(x=0;x<i;x++)
{
printf("t%it",arreglo[x]);
}
getch();
}
break;
case 4:
{
printf("tSALIENDO...n"
}
break;
}
}
while(numero<4);
getch ();
return 0;
}