TAD - Comparação entre Lista e Árvore (Dúvida)

[cyberguy]

Olá pessoal, estou com uma dúvida em um exercício que pede o seguinte: criar um programa que faça uma comparação entre uma lista e uma árvore, e exibir o resultado. Porém o main.cpp deve conter apenas uma biblioteca .h, com os protótipos das funções da lista e da árvore. O problema é que eu só estou conseguindo fazer inserindo ‘#includes’ da lista e da árvore no arquivo .h, pois quando eu tento inserir os protótipos das funções, dá erro.

Se alguém puder me ajudar e me mostrar aonde eu estou errando, eu agradeço.

Segue abaixo os códigos que desenvolvi:

ListaApo.cpp

//Implementação de Lista com Apontador
#include <stdlib.h>
#include <stdio.h>
#include "elemento.h"

int contL;

struct Celula	{
	Elemento Item;
	Celula *Prox;
};

struct TipoLista	{
	Celula *Primeiro, *Ultimo;
};

void FLVazia(TipoLista &Lista)	{
	Lista.Primeiro = (Celula*)malloc(sizeof(Celula));
	Lista.Ultimo = Lista.Primeiro;
	(*Lista.Ultimo).Prox = NULL;
}

int Vazia(TipoLista Lista)	{
	return(Lista.Ultimo == Lista.Primeiro);
}

void Insere(Elemento x, TipoLista &Lista)	{
	(*Lista.Ultimo).Prox = (Celula*)malloc(sizeof(Celula));
	Lista.Ultimo = (*Lista.Ultimo).Prox;
	(*Lista.Ultimo).Item = x;
	(*Lista.Ultimo).Prox = NULL;
}

void InsereInicio(Elemento x, TipoLista &Lista)	{
	Celula *p = (Celula*)malloc(sizeof(Celula));
	(*p).Item = x;
	(*p).Prox = (*Lista.Primeiro).Prox;
	(*Lista.Primeiro).Prox = p;
}

void Limpa(TipoLista &Lista)	{
	Celula *aux = (*Lista.Primeiro).Prox;
	Celula *aux_prox;

	while (aux != NULL)	{
		aux_prox = (*aux).Prox;
		free(aux);
		aux = aux_prox;
	}

	Lista.Ultimo = Lista.Primeiro;
	(*Lista.Ultimo).Prox = NULL;
}

Celula *Localiza(TipoLista Lista, int Valor)	{
	Celula *p = Lista.Primeiro;

	while ((*p).Prox != NULL)	{
		contL++;
		if ((*(*p).Prox).Item.Valor == Valor)
			return(p);
		p = (*p).Prox;
	}
	return(NULL);
}

void Retira(Celula *p, TipoLista &Lista, Elemento &Item)	{
	Celula *q;

	if (Vazia(Lista) || p == NULL || (*p).Prox == NULL)
		printf("\nErro\n");

	else	{
		q = (*p).Prox;
		Item = (*q).Item;
		(*p).Prox = (*q).Prox;
		if ((*p).Prox == NULL)
			Lista.Ultimo = p;
		free(q);
	}
}

void Imprime(TipoLista Lista)	{
	Celula *aux = (*Lista.Primeiro).Prox;
	int cont = 1;

	printf(">> Elementos da Lista <<\n");

	while (aux != NULL)	{
		printf("Elemento %d = ", cont++);
		printf("%d\n", (*aux).Item.Valor);
		aux = (*aux).Prox;
	}

	printf("-----------------------\n");
}

Arvore.cpp

//Implementação de Árvore Binária de Busca
#include <stdlib.h>
#include <stdio.h>
#include "elemento.h"

int contA;

typedef struct Nodo{
	Elemento Item;
	Nodo *Esq, *Dir;
}*TipoArvore;

void Inicializa(TipoArvore &Tree)  {
	Tree = NULL;
}

void Pesquisa(Elemento x, TipoArvore p)  {
	if (p == NULL)
		;//printf("\nRegistro não esta na arvore\n");
	else {
		contA++;
		if (x.Valor <= (*p).Item.Valor)
			Pesquisa(x, (*p).Esq);
		else
			Pesquisa(x, (*p).Dir);
	}
}

void Insere(Elemento x, TipoArvore &p)  {
	if (p == NULL)  {
		p = (Nodo*)malloc(sizeof(Nodo));
		(*p).Item = x;
		(*p).Esq = NULL;
		(*p).Dir = NULL;
	}
	else
	if (x.Valor <= (*p).Item.Valor)
		Insere(x, (*p).Esq);
	else
	if (x.Valor > (*p).Item.Valor)
		Insere(x, (*p).Dir);
}

void Antecessor(Nodo *q, TipoArvore &r)  {
	if ((*r).Dir != NULL)
		Antecessor(q, (*r).Dir);
	else  {
		(*q).Item = (*r).Item;
		q = r;
		r = (*r).Esq;
		free(q);
	}
}

void Retira(Elemento x, TipoArvore &p)  {
	Nodo* Aux;
	if (p == NULL)
		printf("\nRegistro não esta na arvore\n");
	else
	if (x.Valor < (*p).Item.Valor)
		Retira(x, (*p).Esq);
	else
	if (x.Valor >(*p).Item.Valor)
		Retira(x, (*p).Dir);
	else
	if ((*p).Dir == NULL)  {
		Aux = p;
		p = (*p).Esq;
		free(Aux);
	}
	else
	if ((*p).Esq != NULL)
		Antecessor(p, (*p).Esq);
	else  {
		Aux = p;
		p = (*p).Dir;
		free(Aux);
	}
}

elemento.h

#ifndef __elemento_h
#define __elemento_h

struct Elemento	{
	int Valor;
};

#include "Arvore.cpp"
#include "ListaApo.cpp"

#endif

Main.cpp (Arquivo principal que fará as comparações)

#include <iostream>
#include "elemento.h"

using namespace std;

int nu,con;
Elemento e;
float mediaTree, mediaList;

int main(){
	cout << "NUMERO ******** ARVORE ******** LISTA" << endl;

	for (nu = 100; nu <= 2000; nu += 100){
        contA = 0;
		contL = 0;
		TipoArvore tree;
		TipoLista lst;
		Inicializa(tree);
		FLVazia(lst);

		for (con = 1; con <= nu; con++){
			e.Valor = 1 + rand() % nu;
			Insere(e, tree);
			Insere(e, lst);
		}

		for (con = 1; con <= (2 * nu); con++){
			e.Valor = 1 + rand() % (2 * nu);
			Pesquisa(e, tree);
			Localiza(lst, e.Valor);
		}

		mediaTree = contA / (2.0 * nu);
		mediaList = contL / (2.0 * nu);

		cout << nu << "\t\t" << mediaTree << "\t\t" << mediaList << endl;
    }
    cout<<"***************************************";
}