PILAS, COLAS Y

LASTAS
PILAS
DEFINICION:

La pila es una estructura de datos que permite almacenar datos
en el orden LIFO (Last In First Out) en espaol, ltimo en entrar,
primero en salir).

La recuperacin de los datos es hecha en el orden inverso de su
insercin.
PILAS


EJEMPLO
#include <stdio.h>
#include <stdlib.h>

typedef struct nodo_s
{
char dato;
struct nodo_s *siguiente;
} nodo_t;

typedef nodo_t *ptrNodo;
typedef nodo_t *ptrPila;


Agrega un nodo al inicio de la lista ligada
*pila es el apuntador que apunta al primer nodo de la lista ligada (la cima de la
pila)
*/
void push(ptrPila *pila, char x)
{
// Crea un nuevo nodo
ptrNodo nodo;
nodo = (ptrNodo)malloc(sizeof(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;
}
}

/*
Elimina el primer nodo de la lista ligada
*pila es el apuntador que apunta al primer nodo de la lista ligada (la cima de la
pila)
*/
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
DEFINICION.
Una cola es un tipo especial de lista abierta 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

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

typedef tipoNodo *pNodo;
typedef tipoNodo *Cola;

tipoNodo es el tipo para declarar nodos, evidentemente.
pNodo es el tipo para declarar punteros a un nodo.
Cola es el tipo para declarar colas.

Aadir elemento en una cola,
caso general

Para generalizar el caso anterior, slo necesitamos aadir una
operacin:
Hacemos que nodo->siguiente apunte a NULL.
Si ultimo no es NULL, hacemos que ultimo->siguiente apunte a
nodo.
Y actualizamos ultimo, haciendo que apunte a nodo.
Si primero es NULL, significa que la cola estaba vaca, as que
haremos que primero apunte tambin a nodo.

Leer un elemento en una
cola caso general

Hacemos que nodo apunte al primer elemento de la pila, es
decir a primero.
Asignamos a primero la direccin del segundo nodo de la pila:
primero->siguiente.
Guardamos el contenido del nodo para devolverlo como
retorno, recuerda que la operacin de lectura en colas
implican tambin borrar.
Liberamos la memoria asignada al primer nodo, el que
queremos eliminar.
Si primero es NULL, hacemos que ultimo tambin apunte a
NULL, ya que la lectura ha dejado la cola vaca

LISTAS
DEFINICION:
En una lista podemos almacenar datos del mismo tipo, con la
caracterstica que puede contener un nmero indeterminado
de elementos y que, mantienen un orden explcito, porque
cada elemento, se une a otro mediante un puntero, como ya
se ha dicho anteriormente, los elementos constitutivos de las
listas se denominan nodos.
Las listas son estructuras de datos dinmicos, por tanto,
pueden cambiar de tamao durante la ejecucin del
programa, aumentando o disminuyendo el nmero de nodos.

SINTAXIS
Estructura del Nodo
Por ejemplo, la podemos definir as:
struct nodo{
int x;
struct nodo *sig;
};

typedef struct nodo *Lista; /* Sinnimo para el tipo de dato*/
Lista p; /* Aqu guardaremos la direccin del primer nodo */

p=getnodo();

Esta funcin, se utiliza para pedirle memoria a la
computadora, lo cual puede realizarse en las misma funcin
de insertar, pero para tener un mekor orden, es mejor hacerlo
por aparte.
Por tanto, es evidente que, sta funcin lo que devuelve es
una direccin de memoria.

Lista getnodo()
{
Lista p;
p=(Lista)malloc(sizeof(struct nodo));
return p;
}