Pilas:
Una pila es un tipo especial de lista enlazada en la que slo se pueden insertar y eliminar
nodos en uno de los extremos de la lista. Estas operaciones se conocen como "push" y
"pop", respectivamente "empilar" y "desempilar". Adems, las escrituras de datos siempre
son inserciones de nodos, y las lecturas siempre eliminan el nodo ledo.
Estas caractersticas implican un comportamiento de lista LIFO (Last In First Out), el
ltimo en entrar es el primero en salir.
Es evidente, que una pila es una lista enlazada. As que sigue siendo muy importante que
nuestro programa nunca pierda el valor del puntero al primer elemento.
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.
Declaraciones de tipos para manejar pilas en C:
typedef struct nodo_s
{
char dato;
struct nodo_s *siguiente;
} nodo_t;
typedef nodo_t *ptrNodo;
typedef nodo_t *ptrPila;
Operaciones bsicas con pilas:
isEmply, comprueba si la pila esta vacia o no.
int pila_vacia(ptrPila *pila)
{
if (*pilla == NULL )
return 1;
return 0;
}
Push, insertar elemento (empilar).
void push(ptrPila *pila, char x)
{
// Crea un nuevo nodo
ptrNodo nodo;
nodo = new(nodo_t);
if (nodo != NULL)
{
nodo->dato = x; //El apuntador nodo->siguiente va a apuntar al primer nodo de la lista
ligada
nodo->siguiente = *pila;// pila va a apuntar al nuevo nodo, con esto hacemos que el
nuevo nodo sea ahora el primer nodo de la lista ligada
*pila=nodo;
}
}
Pop, leer y eliminar un elemento (desempilar).
char pop(ptrPila *pila)
{
// Crea un nuevo nodo
ptrNodo nodo;
char x;
// El nuevo nodo va a apuntar al primer nodo de la lista ligada
nodo = *pila;
x = (*pila)->dato;
// Ahora el segundo nodo de la lista ligada va a ser el primero
*pila = (*pila)->siguiente;
// Borra el primer nodo de la lista ligada
free(nodo);
// Regresa el valor que contena el nodo que se elimin
return x;
}
Colas:
Una cola es un tipo especial de lista enlazada en la que slo se pueden insertar nodos en
uno de los extremos de la lista y slo se pueden eliminar nodos en el otro. Adems, como
sucede con las pilas, las escrituras de datos siempre son inserciones de nodos, y las lecturas
siempre eliminan el nodo ledo.
Este tipo de lista es conocido como lista FIFO (First In First Out), el primero en entrar es el
primero en salir.
El smil cotidiano es una cola para comprar, por ejemplo, las entradas del cine. Los nuevos
compradores slo pueden colocarse al final de la cola, y slo el primero de la cola puede
comprar la entrada.
El nodo tpico para construir colas es el mismo para la construccin de listas y pilas.
Declaraciones de tipos para manejar colas en C:
typedef struct nodo_s
{
char dato;
struct nodo_s *siguiente;
} nodo_t;
typedef nodo_t *ptrNodo;
typedef nodo_t *ptrCola;
Operaciones bsicas con colas:
isEmply, comprueba si la cola esta vacia o no.
int cola_vacia(ptrCola *cola)
{
if (*cola == NULL )
return 1;
return 0;
}
Insertar elemento (encolar).
void encolar(ptrCola *cola, char x)
{
// Crea un nuevo nodo
ptrNodo nodo, aux=cola;
nodo = new(nodo_t,);
nodo->dato=x;
nodo->prox=NULL;
while (aux->sig!=NULL)
aux=aux->sig;
aux->sig = nodo;
}
Leer y eliminar elemento de la cola (desencolar).
char desencolar(ptrCola *cola)
{
char x;
ptrNodo aux=cola;
x=cola->dato;
cola=cola->sig;
free(aux);
return x;
}
