Trabajo Prctico N6

En este trabajo prctico vamos a crear nuevas estructuras, pero esta vez utilizando punteros.
Esto nos permitir construir objetos ms potentes, como ser Listas, Pilas y Colas.
Para almacenar datos vamos a utilizar la estructura Nodo (de int), que se define como sigue:
struct Nodo{
Nodo* siguiente_nodo;
int elemento;
}
Un nodo es un elemento que permite almacenar datos y adems se puede conectar a otro Nodo,
utilizando el puntero siguiente_nodo. En principio, si no se quiere conectar a otro Nodo, dicho
puntero contendr el valor NULL. ste ser el elemento fundamental de las estructuras que
implementaremos a continuacin.

Lista enlazada: Como su nombre lo indica, es una lista de elementos que estn puestos de
forma que uno est despus que el otro. Los elementos de una lista sern los nodos (que a su
vez, dentro de cada uno de ellos habr un dato de tipo int almacenado). La estructura de la lista
se define como sigue:
struct ListaEnlazada{
Nodo* primer_nodo;
Nodo* ultimo_nodo;
int cantidad_elementos;
};
En un principio, la lista empezara vaca (con todos los punteros en NULL y cantidad_elementos
en 0).
A medida que se agreguen elementos, se pondrn al final de la lista, y el nodo que estaba ltimo
(antes de ese momento) ahora pasar a tener como siguiente_nodo al nuevo nodo que se
agrega. Adems, la lista tendr un puntero al primer nodo (que siempre se mantendra fijo, salvo
que se lo borre) y al ltimo (que cambiar todo el tiempo, cada vez que se agregue un nuevo
nodo).
Para aprobar, se pide implementar para la ListaEnlazada:

Una funcin ListaEnlazada* crearListaEnlazada(), que pida espacio para una lista,
inicialice todos sus atributos y devuelva un puntero a la misma.
Una funcin void AgregarElemento(ListaEnlazada* L, int dato), que reciba un
puntero a una ListaEnlazada y agregue un nodo al final de L, conteniendo dato.
Una funcin int devolverElemento(ListaEnlazada* L, int posicion), que devuelva el
contenido del nodo posicin dentro de la lista (si posicin vale 0, devolver el contenido
del primer nodo, y as).

Una funcin bool existeElemento(ListaEnlazada* L, int dato), que responda si dato

aparece en la lista.
Una funcin void borrarElemento(ListaEnlazada* L, int posicion), que borre el nodo
posicin dentro de la lista y actualice todo lo necesario para que la lista siga funcionando.
Debe liberar correctamente la memoria del nodo.
Como puntos adicionales para la nota mxima, se pide lo siguiente:

Una funcin void borrarLista(ListaEnlazada* L), que libera correctamente la memoria

de todos sus nodos y la lista en cuestin.
Una funcin void insertarEnOrden(ListaEnlazada* L, int dato), que toma una lista
que se asume ordenada y agrega un nodo conteniendo dato en la posicin
correspondiente tal que siga ordenada.
Una funcin void insertarEn(ListaEnlazada* L, int posicion, Nodo* elem), que busca
el nodo en posicin, lo reemplaza por elem y libera la memoria del nodo que estaba
originalmente.

Pila ("LIFO"): es una estructura que permite apilar y desapilar elementos. Es LIFO en el sentido
"last in first out", es decir, el ltimo que se apil ser el primero a desapilar. Una posible forma
de implementarla es usando un arreglo de elementos (que en nuestro caso sern ints).

struct Pila{
int* elementos;
int size_max;
int cantidad_actual;
}
Las operaciones bsicas de una pila son top, push y pop.
Para aprobar, se pide implementar para la Pila:

Una funcin Pila* crearPila(int size_max), que pide espacio para una pila e inicializa
todos sus atributos correctamente.
Una funcin void push(Pila* P, int elem), que agrega un elemento en el tope de la pila
si todava hay espacio.
Una funcin void pop(Pila* P), que desapila el elemento que haba en el tope (de
haberlo) y libera su espacio.
Una funcin int top(Pila* P), que retorna el elemento que est en el tope, sin desapilar.
Una funcin int tamanio(Pila* P), que retorna el tamao actual de la pila.

Como puntos adicionales para la nota mxima, se pide hacer que la pila tenga tamao variable
en funcin a la cantidad de veces que se apil y desapil. Para esto se deber implementar:
Una funcin Pila* crearPila_dinamica(), que pide espacio para una pila e inicializa todos
sus atributos, comenzando el arreglo con tamao size_max 1.
Una funcin void push_dinamico(Pila* P, int elem), que hace lo mismo que el push
normal, pero de no haber espacio, genera un nuevo arreglo del doble del tamao que se

tena como mximo, copiarle todos los elementos que haban en el anterior array y liberar
el espacio de este ltimo.
Una funcin void pop_dinamico(Pila* P), que hace lo mismo que el pop normal, pero si
luego de desapilar el elemento del tope la pila quedan menos elementos que size_max / 2,
entonces pedir otro arreglo de tamao size_max / 2, copiarle los elementos y liberar el
espacio del array ms grande.
Una funcin void pop_N(Pila* P, int cantidad), que hace pop de los N elementos ms al
tope de la pila.

Cola simple (FIFO): es una estructura que permite encolar y desencolar elementos, al igual
que sucede en un banco.
Es FIFO en el sentido "first in first out", es decir, se encola al final de la fila y siempre se
desencola al elemento ms viejo que fue encolado. A diferencia de la pila, esta estructura no
tiene inanicin.
La implementacin puede utilizar el mismo concepto de Nodo que la ListaEnlazada:
struct ColaSimple{
Nodo* primer_nodo;
Nodo* ultimo_nodo;
int cantidad_elementos;
}
Se quiere siempre "atender" primero a quien est en el primer nodo.
Como mnimo, se pide implementar:

Una funcin ColaSimple* crearColaSimple(), que pide espacio para una cola e inicializa
todos sus atributos correctamente.
Una funcin void encolar(ColaSimple* C, int elem), que agrega un nuevo elemento al
final de la cola.
Una funcin void desencolar(ColaSimple* C), que saca de la cola el primer elemento (el
ms viejo) y libera su espacio.
Una funcin int proximoElemento(ColaSimple* C),
Una funcin int tamanio(ColaSimple* C), que retorna el tamao actual de la cola.

Como puntos adicionales para la nota mxima, se pide implementar:

Una funcin void desencolar_N(ColaSimple* C, int cantidad), que desencola los N
primeros elementos.

Fecha de Entrega: Jueves 1 de Septiembre a las 23:59hs.