Hola a todos!!
Soy nuevo en estos lares escribiendo, aunque la verdad es que aprendí mucho leyendo otros post y demás.
Tengo un problema, no soy capaz de solventar una función de una práctica de Programación y Estructuras de Datos.
La función debe añadirse a la parte pública de TAVLCalendario y es:
TVectorCalendario* VectorLista(const TListaCalendario &)
La función en particular debe devolver un vector de TVectorCalendario del mismo tamaño que una lista que se le pasa como parámetro. La lista es recorrida de izquierda a derecha, siendo el primer elemento i=0, luego i=1...
Para cada TCalendario de la lista de entrada, se busca en el AVL y se escribe en la posición correspondiente del vector v
, el TVectorCalendario que contiene el camino desde la raíz hasta dicho TCalendario (de no existir el TCalendario en el AVL se devolverá un TVectorCalendario vacío).
Adicional: Si el árbol está vacío se devuelve un vector del mismo tamaño que la lista con todos sus TVectorCalendarios vacíos. Si la lista está vacía se devolverá un vector apuntando a NULL.
Adjunto una imagen de lo que se pide:
Voy a ver si puedo agregar las funciones que tengo de las distintas partes. Sobretodo me hago un lío porque el tipo de la función es puntero de TVectorCalendario, y eso me dificulta mucho o algo se me escapa... Llevo mucho trabajando en esto y sólo me queda esta función para terminar, así que una ayuda me vendría genial. Muchas gracias de antemano ^^!!!
tavlcalendario.h
======================================
#ifndef __TAVLCALENDARIO__
#define __TAVLCALENDARIO__
#include "tcalendario.h"
#include "tvectorcalendario.h"
#include "tlistacalendario.h"
class TAVLCalendario;
class TNodoAVL;
class TAVLCalendario {
friend class TNodoAVL;
friend ostream & operator<<(ostream &, const TAVLCalendario &);
public:
TAVLCalendario ();
TAVLCalendario (const TAVLCalendario &);
~TAVLCalendario ();
TAVLCalendario & operator=(const TAVLCalendario &);
bool operator==(const TAVLCalendario &);
bool operator!=(const TAVLCalendario &);
bool EsVacio();
bool Insertar(const TCalendario &);
bool Buscar(const TCalendario &);
int Altura();
int Nodos();
int NodosHoja();
TVectorCalendario Inorden();
TVectorCalendario Preorden();
TVectorCalendario Postorden();
bool Borrar(const TCalendario &);
TVectorCalendario Niveles();
TCalendario Raiz();
int ActualizarFe();
void EscogerRotacionIns();
void EscogerRotacionBor();
void RotacionII();
void RotacionDD();
void RotacionID();
void RotacionDI();
TVectorCalendario* VectorLista(const TListaCalendario &);
private:
TNodoAVL *raiz;
void InordenAux(TVectorCalendario &, int &);
void PreordenAux(TVectorCalendario &, int &);
void PostordenAux(TVectorCalendario &, int &);
};
class TNodoAVL {
friend class TAVLCalendario;
public:
TNodoAVL ();
TNodoAVL (const TNodoAVL &);
~TNodoAVL ();
TNodoAVL & operator=(const TNodoAVL &);
private:
TCalendario item;
TAVLCalendario iz, de;
int fe;
};
tcalendario.h
======================
#ifndef __TCALENDARIO__
#define __TCALENDARIO__
#include <iostream>
#include <string.h>
using namespace std;
/*! \brief Clase TCalendario.
*
* Clase que incluye todos los metodos y atributos de TCalendario utilizados para crear un calendario
* y así poder trabajar con él.
*/
class TCalendario
{
//!FUNCIONES AMIGAS
/*! Sobrecarga del operador salida y declaracion de amistas de esta.
* \param os salida del calendario.
* \param calen calendario a mostrar
* \return devuelve la salida.
*/
friend ostream& operator<<(ostream &,const TCalendario &);
//! FORMA CANÓNICA
public:
//!Constructor por defecto de TCalendario
TCalendario ();
/*! Constructor que inicializa un calendario con parametros pasados
* \param dia dia de la fecha
* \param mes mes de la fecha
* \param anyo año de la fecha
* \param mens cadena con el texto de la fecha
*/
TCalendario (int dia,int mes,int anyo,char *mens);
/*! Constructor copia de TCalendario
* \param calen calendario a copiar
*/
TCalendario (const TCalendario &);
//! Destructor de TCalendario
~TCalendario ();
/*! Sobrecarga del operador asignacion
* \param calen calendario a copiar
* \return calendario copiado
*/
TCalendario& operator= (const TCalendario &);
//!MÉTODOS
/*! Sobrecarga del operador suma.
* \param dia el dia de la fecha que sumamos al dia actual.
* \return devolvemos un calendario válido con la fecha nueva.
*/
TCalendario operator+ (const int);
/*! Sobrecarga del operador resta.
* \param dia el dia de la fecha que restamos al dia actual.
* \return devolvemos un calendario válido con la fecha nueva.
*/
TCalendario operator- (const int);
/*! Sobrecarga del operador incremento (postincremento)
* \param a entero para diferenciar postincremento de preincremento
* \return devolvemos un calendario válido con la fecha nueva
*/
TCalendario operator++ (int);
/*! Sobrecarga del operador incremento (preincremento)
* \return devolvemos un calendario válido con la fecha nueva
*/
TCalendario& operator++ ();
/*! Sobrecarga del operador decremento (posdecremento)
* \param a entero para diferenciar posdecremento de predecremento
* \return devolvemos un calendario válido con la fecha nueva
*/
TCalendario operator-- (int);
/*! Sobrecarga del operador decremento (predecremento)
* \return devolvemos un calendario válido con la fecha nueva
*/
TCalendario& operator-- ();
/*! Método que modifica el mensaje de la fecha actual.
* \param dia el nuevo dia de la fecha.
* \param mes el nuevo mes de la fecha.
* \param anyo el el nuevo año de la fecha.
* \return devolvemos TRUE si no modificamos la fecha, y FALSE en caso contrario.
*/
bool ModFecha (int,int,int);
/*! Método que modifica el mensaje del calendario actual.
* \param char mensaje nuevo.
*/
void ModMensaje (char *);
/*! Sobrecarga del operador igualdad.
* \param calen el calendario que comparamos con el actual.
* \return devuelve TRUE si son calendarios idénticos, y FALSE en caso contrario.
*/
bool operator== (const TCalendario &);
/*! Sobrecarga del operador desigualdad.
* \param calen el calendario que comparamos con el actual.
* \return devuelve TRUE si son calendarios distintos, y FALSE en caso contrario.
*/
bool operator!= (const TCalendario &);
/*! Sobrecarga del operador mayor.
* \param calen el calendario que comparamos con el actual.
* \return devuelve TRUE si el calendario actual es mayor que el que le pasas, y FALSE en caso contrario.
*/
bool operator> (const TCalendario &);
/*! Sobrecarga del operador menos.
* \param calen el calendario que comparamos con el actual.
* \return devuelve TRUE si el calendario actual es menor que el que le pasas, y FALSE en caso contrario.
*/
bool operator< (const TCalendario &);
/*! Método que devuelve TRUE si el calendario esta vacío, y FALSE en caso contrario.
* \return vacio según el contenido del calendario
*/
bool EsVacio ();
/*! Método que devuelve el dia del calendario.
* \return dia
*/
int Dia () const;
/*! Método que devuelve el mes del calendario
* \return mes
*/
int Mes () const;
/*! Método que devuelve el año del calendario
* \return anyo
*/
int Anyo () const;
/*! Método que devuelve el mensaje del calendario
* \return mens
*/
char * Mensaje ();
/*! Método que devuelve TRUE si el año es bisiesto, y FALSE en caso contrario.
* \param calen el calen del que queremos saber si es bisiesto o no
* \return bool según sea bisiesto o no
*/
bool Bisiesto(TCalendario);
/*! Metodo que devuelve TRUE si la fecha es correcta (incluyendo que sea mayor a 1/1/1900), y FALSE en caso contrario.
* \param calen el calen del que queremos conocer su validez
* \return novalido si el calendario cumple los requisitos o no
*/
bool ValidarFecha(const TCalendario);
//!PARTE PRIVADA
private:
//! Atributo de tipo entero que contiene el dia de una fecha.
int dia;
//! Atributo de tipo entero que contiene el mes de una fecha.
int mes;
//! Atributo de tipo entero que contiene el año de una fecha.
int anyo;
//! Atributo de tipo puntero char que apunta al mensaje del calendario.
char *mens;
};
#endif
tlistacalendario.h
=========================
#include "tcalendario.h"
#ifndef __TLISTACALENDARIO__
#define __TLISTACALENDARIO__
class TListaCalendario;
class TListaPos;
/*! \brief Clase TNodoCalendario.
*
* Clase que incluye todos los metodos y atributos de TNodoCalendario utilizados para crear un nodo con un calendario
* y así trabajar con él.
*/
class TNodoCalendario
{
//! FUNCIONES AMIGAS
/*! Sobrecarga del operador salida y declaracion de amistas de esta.
* \param los salida de la lista.
* \param lista lista a mostrar
* \return devuelve la salida.
*/
friend ostream& operator<<(ostream &, const TListaCalendario &);
//! Declaración de funcion amiga TListaCalendario
friend class TListaCalendario;
//! Declaración de funcion amiga TListaPos
friend class TListaPos;
//! FORMA CANÓNICA
public:
//! Constructor por defecto de TNodoCalendario.
TNodoCalendario();
/*! Constructor de copia de TNodoCalendario.
* \param nodo nodo a copiar
*/
TNodoCalendario(const TNodoCalendario &);
//! Destructor de TNodoCalendario.
~TNodoCalendario();
/*! Sobrecarga del operador asignación.
* \param nodo nodo a copiar
* \return nodo copiado
*/
TNodoCalendario & operator=(const TNodoCalendario &);
//! PARTE PRIVADA
private:
//! Atributo de TCalendario que almacena la información del nodo.
TCalendario c;
//! Atributo de tipo puntero a TNodoCalendario que apunta al siguiente nodo.
TNodoCalendario *siguiente;
};
/*! \brief Clase TListaCalendario.
*
* Clase que incluye todos los metodos y atributos de TListaCalendario utilizados para crear una lista formada por
* calendarios y así poder trabajar con ella.
*/
class TListaCalendario
{
//! FUNCIONES AMIGAS
/*! Sobrecarga del operador salida y declaracion de amistas de esta.
* \param los salida de la lista.
* \param lista lista a mostrar
* \return devuelve la salida.
*/
friend ostream& operator<<(ostream &, const TListaCalendario &);
//! Declaración de funcion amiga TListaPos
friend class TListaPos;
//! Declaración de funcion amiga TNodoCalendario
friend class TNodoCalendario;
//! FORMA CANÓNICA
public:
//! Constructor por defecto de TListaCalendario.
TListaCalendario();
/*! Constructor de copia de TListaCalendario.
* \param lista lista a copiar
*/
TListaCalendario(const TListaCalendario &);
//! Destructor de TListaCalendario.
~TListaCalendario();
/*! Sobrecarga del operador asignación.
* \param lista lista a copiar
* \return lista copiada
*/
TListaCalendario & operator=(const TListaCalendario &);
//! -Métodos-
/*! Sobrecarga del operador igualdad.
* \param lista la lista que comparamos con la actual.
* \return devuelve TRUE si son listas identicas, y FALSE si no.
*/
bool operator==(const TListaCalendario &);
/*! Sobrecarga del operador suma, une los elementos únicos de la segunda lista en la primera.
* \param lista la lista que queremos sumar a la actual.
* \return la lista resultante de la unión de los elementos de la lista actual y la pasada por parámetro.
*/
TListaCalendario operator+(const TListaCalendario &);
/*! Sobrecarga del operador resta, excluye de la primera lista los elementos de la segunda.
* \param lista la lista que queremos restar a la actual.
* \return la lista resultante de la exclusión de los elementos de la lista pasada por parámetro en la actual.
*/
TListaCalendario operator-(const TListaCalendario &);
/*! Método que inserta de forma ordenada un calendario en la posición que le corresponde en la lista.
* \param calen el calendario que se pretende incluir en la lista.
* \return devuelve TRUE si se inserta el calendario, y FALSE en caso contrario.
*/
bool Insertar(const TCalendario &);
/*! Método que busca y borra un calendario que le pasas por parámetro.
* \param calen calendario que pretendemos buscar y borrar.
* \return devuelve TRUE si se ha borrado el calendario, y FALSE en caso contrario.
*/
bool Borrar(const TCalendario &);
/*! Método que borra un calendario desde una posición pasada por parámetro.
* \param ptE posición que queremos borrar de la lista.
* \return devuelve TRUE si se ha borrado el calendario, y FALSE en caso contrario.
*/
bool Borrar(const TListaPos &);
/*! Método que borra todos los calendarios anteriores a la fecha dada por parámetro.
* \param dia el dia de la fecha hasta la que queremos borrar.
* \param mes el mes de la fecha hasta la que queremos borrar.
* \param anyo el año de la fecha hasta la que queremos borrar.
* \return devuelve TRUE si se ha borrado algún calendario de la lista, y FALSE en caso contrario.
*/
bool Borrar(int, int, int);
/*! Método que devuelve TRUE si la lista está vTNodoCalendarioacia, y FALSE en caso contrario.
* \return indica si hay contenido o no
*/
bool EsVacia();
/*! Método que devuelve el calendario de una posición dada.
* \param ptE posición de la que queremos obtener un calendario.
* \return devuelve el calendario que ocupa la posición pasada por parámetro.
*/
TCalendario Obtener(const TListaPos &);
/*! Método que indica si un calendario está en la lista.
* \param calen calendario que queremos buscar en la lista.
* \return devuelve TRUE si el calendario está en la lista, y FALSE en caso contrario.
*/
bool Buscar(const TCalendario &);
/*! Método que devuelve la longitud de la lista.
* \return entero con la longitud.
*/
int Longitud();
/*! Método que devuelve la primera posición de la lista.
* \return devuelve la primera posicion.
*/
TListaPos Primera();
/*! Método que devuelve la última posición de la lista.
* \return devuelve la ultima posicion.
*/
TListaPos Ultima();
/*! Método que suma los elementos de dos listas indicados en un rango determinado para cada una de ellas.
* \param I_L1 entero que indica desde que posición de la lista actual sumar (incluido).
* \param F_L1 entero que indica hasta que posición de la lista actual sumar (incluido).
* \param L2 la lista pasada por parametro que sumamos a la actual.
* \param I_L2 entero que indica desde que posición de la lista pasada por parámetro sumar (incluido).
* \param F_L2 entero que indica hasta que posición de la lista pasada por parámetro sumar (incluido).
* \return devuelve una tercera lista formada por los rangos de las listas anteriores.
*/
TListaCalendario SumarSubl(int, int, const TListaCalendario &, int, int);
/*! Método que extrae de la lista los elementos contenidos en un rango, con los que crear una nueva lista.
* \param n1 entero que indica desde que posición de la lista extraer los calendarios (incluido).
* \param n2 entero que indica hasta que posición de la lista extraer los calendarios (incluido).
* \return devuelve una nueva lista con los elementos extraidos de la lista actual.
*/
TListaCalendario ExtraerRango (int, int);
private:
//! Atributo de tipo puntero de TNodoCalendario, que apunta al primer nodo de la lista.
TNodoCalendario *primero;
};
class TListaPos
{
//! FUNCIONES AMIGAS
/*! Sobrecarga del operador salida y declaracion de amistas de esta.
* \param los salida de la lista.
* \param lista lista a mostrar
* \return devuelve la salida.
*/
friend ostream& operator<<(ostream &, const TListaCalendario &);
//! Declaración de funcion amiga TNodoCalendario
friend class TNodoCalendario;
//! Declaración de funcion amiga TListaCalendario
friend class TListaCalendario;
//! FORMA CANÓNICA
public:
//! Constructor por defecto de TListaPos.
TListaPos();
/*! Constructor de copia de TListaPos.
* \param ptE posicion a copiar
*/
TListaPos(const TListaPos &);
//! Destructor de TListaPos.
~TListaPos();
/*! Sobrecarga del operador asignación.
* \param ptE posicion a copiar
* \return posicion copiada
*/
TListaPos & operator=(const TListaPos &);
//! -Métodos-
/*! Sobrecarga del operador igualdad.
* \param ptE posición que comparamos con la actual.
* \return devuelve TRUE si son identicas, y FALSE en caso contrario.
*/
bool operator==(const TListaPos &);
/*! Sobrecarga del operador desigualdad.
* \param ptE posición que compraramos con la actual.
* \return devuelve TRUE si son diferentes, y FALSE en caso contrario.
*/
bool operator!=(const TListaPos &);
/*! Método que devuelve la posición siguiente a la actual.
* \return posicion siguiente.
*/
TListaPos Siguiente();
/*! Método que devuelve TRUE si la posición no apunta a un elemento de la lista, y FALSE en caso contrario.
* \return vacio según el contenido.
*/
bool EsVacia();
private:
//! Atributo de tipo puntero de TNodoCalendario, que apunta al primer nodo de la lista.
TNodoCalendario *pos;
};
#endif
tvectorcalendario.h
==============================
#include "tcalendario.h"
#ifndef __TVECTORCALENDARIO__
#define __TVECTORCALENDARIO__
/*! \brief Clase TNodoCalendario.
*
* Clase que incluye todos los metodos y atributos de TVectorCalendario utilizados para crear un vector de
* calendarios y así poder trabajar con él.
*/
class TVectorCalendario
{
//! FUNCIONES AMIGAS
/*! Sobrecarga del operador salida y declaracion de amistas de esta.
* \param vos salida del vector.
* \param vcalen vector a mostrar
* \return devuelve la salida.
*/
friend ostream& operator<<(ostream &, const TVectorCalendario &);
//! FORMA CANÓNICA
public:
//! Constructor por defecto de TVectorCalendario.
TVectorCalendario();
/*! Constructor de TVectorCalendario con el tamaño pasado por parámetro.
* \param dim entero del vector
*/
TVectorCalendario(int);
/*! Constructor de copia de TVectorCalendario.
* \param vector vector a copiar
*/
TVectorCalendario(const TVectorCalendario &);
//! Destructor de TVectorCalendario.
~TVectorCalendario();
/*! Sobrecarga del operador asignación.
* \param vector vector a copiar
* \return vector copiado
*/
TVectorCalendario & operator=(const TVectorCalendario &);
//! -Métodos-
/*! Sobrecarga del operador igualdad.
* \param vec vector que comparamos con la actual.
* \return devuelve TRUE si los vectores son identicos, y FALSE si no.
*/
bool operator==(const TVectorCalendario &);
/*! Sobrecarga del operador desigualdad.
* \param vec vector que comparamos con la actual.
* \return devuelve TRUE si los vectores son distintos, y FALSE en caso contrario.
*/
bool operator!=(const TVectorCalendario &);
/*! Sobrecarga del operador corchete (parte izquierda).
* \param pos identifica la parte izquierda de la derecha
* \return calendario de la posicion en el vector
*/
TCalendario & operator[](int);
/*! Sobrecarga del operador corchete (parte derecha).
* \param pos identifica la parte derecha de la izquierda
* \return calendario de la posicion en el vector
*/
TCalendario operator[](int) const;
/*! Método que devuelve el tamaño del vector.
* \return entero con el tamaño.
*/
int Tamano() const;
/*! Método que devuelve la cantidad de posiciones no vacias del vector
* \return entero con el numero de posiciones ocupadas.
*/
int Ocupadas() const;
/*! Método que devuelve TRUE si existe el calendario pasado por parametro.
* \param calen calendario que queremos buscar en el vector.
* \return devuelve TRUE si existe el calendario en el vector, y FALSE en caso contrario.
*/
bool ExisteCal(const TCalendario &);
/*!Método que muestra por pantalla los calendarios del vector, a partir de la fecha dada.
* \param dia el dia de la fecha que buscamos en el vector.
* \param mes el mes de la fecha que buscamos en el vector.
* \param anyo el año de la fecha que buscamos en el vector.
*/
void MostrarMensajes(int,int,int);
/*! Método que modifica el tamaño del vector al entero pasado por parámetro
* \param tam entero con el que indicamos que tamaño queremos que tenga en vector.
* \return devuelve TRUE si se ha cambiado el tamaño del vector, y FALSE en caso contrario.
*/
bool Redimensionar(int);
//PARTE PRIVADA
private:
//! Atributo de tipo puntero TCalendario, que apunta a un calendario del vector.
TCalendario *c;
//! Atriubuto de tipo TCalendario utilizado cuando hay que devolver algo en caso de error.
TCalendario error;
//! Atributo de tipo entero que indica el tamaño del vector.
int tamano;
};
#endif
Repito, muchísimas gtracias, quería poner el código en spoilers, pero no me deja con el clásico [spoiler][/spoiler], como se hace aquí?? Un saludo!!