Redefinição de Struct em C

[Edu Valente]

Boa tarde gente. Eu estou tentando desenvolver uma árvore binária que tenha números complexos inseridos nela. Num certo trecho do código, tentei comparar a representação string de dois complexos sem êxito e agora não sei como fazer para comparar as duas strings propriamente ditas a fim de que eu possa localizar um complexo previamente inserido na árvore. Irei colocar os headers, os .c do código e um comentário em bintree.c indicando o problema. Obrigado pela ajuda proporcionada.

complex.h

typedef struct Complex
{
  double r;
  double i;

} complex;

// cria um número complexo
complex set(double x, double y);

// retorna a parte real de um número complexo
double getR(complex x);

// retorna a parte imaginária de um número complexo
double getI(complex x);

// Retorna uma string que representa
// o número complexo
char* notation(complex x);

bintree.h

#include "complex.h"

typedef struct Tree 
{ 
  complex info;
  struct Tree* left;
  struct Tree* right;
} tree;

// inicializa a árvore
tree* initialize(void);

// cria uma árvore com duas folhas (uma à esquerda e outra à direita)
tree* create(complex c, tree* sae, tree* sad);

// verifica se a árvore se encontra vazia
int emptyTree(tree* a);

// imprime os dados da árvore binária
void printTreeData(tree* a);

// libera a memória alocada à árvore binária
tree* freeTree(tree* a);

// obtém a altura da árvore
int getTreeHeight(tree* t);

// obtém o maior nodo da árvore
int highestNode(int a, int b);

// faz uma busca pelos elementos da árvore 
int searchElem(tree* t, complex c);

complex.c

#include <string.h>
#include "complex.h"

complex set(double x, double y)
{ 
  complex z; 
  z.r = x;
  z.i= y;      
  return z;      
}

double getR(complex x)
{
  return x.r;                
}

double getI(complex x)
{
  return x.i;               
} 

char* notation(complex x)
{
  static char s[30];
  // printf é uma função que insere os caracteres formatados
  // na variável de destino (neste caso, s)
  sprintf(s, "%g + %gi", getR(x), getI(x));
  return s; 
}

bintree.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "bintree.h"
#include "complex.h"
  
  tree* initialize(void)
  {
    return NULL;
  }
  
  tree* create(complex c, tree* sae, tree* sad){
    tree* p=(tree*)malloc(sizeof(tree));
    p->info = c;
    p->left = sae;
    p->right = sad;
    return p;
  }
  
  int empty(tree* t)
  {
     return t == NULL;
  }
  
  void printTreeData(tree* t)
  {
    if (!emptyTree(t)){
     printf("%s", t->info); /* mostra raiz */
     printTreeData(t->left); /* mostra sae */
     printTreeData(t->right); /* mostra sad */
    }
  }
  
  tree* freeTree(tree* t){
    if (!emptyTree(t)){
     freeTree(t->left); /* libera sae */
     freeTree(t->right); /* libera sad */
     free(t); /* libera raiz */
    }
    return NULL;
  }
  
  int getTreeHeight(tree* t) 
  {
    if((t == NULL) || (t->left == NULL && t->right == NULL))
    {
      return 0;     
    }
    else 
    {
      return 1 + highestLeaf(getTreeHeight(t->left), getTreeHeight(t->right));                     
    }
  }     
  int highestNode(int a, int b)
  {
    if(a > b) 
     return a; 
    else 
     return b;      
  }        
      
  int searchElem(tree* t, complex c){
   char* s1; 
   // primeira variável para guardar a notação String de t->info
   char* s2;
   // segunda variável para guardar a notação String do complexo c 
   
   if (emptyTree(t))
    return 0; /* árvore vazia: não encontrou */
   else
     s1 = notation(t->info);
     s2 = notation(c);   
     return s1 == s2 || searchElem(t->left,c) || searchElem(t->right,c);
     
     /* ******************************************
      * O problema se encontra nesse return: o compilador
      * retorna os seguintes erros para complex.h: 
      * Linha 2 - redefinition of 'struct Complex'
      * Linha 6 - redefinition of 'typedef Complex'
      * Linha 6 - previous declaration of 'complex' was here
      * quando eu tento comparar essas duas representações
      * de string.
      * *******************************************/

 }

main.c

#include <stdio.h>
#include <stdlib.h>
#include "complex.h"
#include "bintree.h"

int main(void)
{
  complex a = set(4, 3);
  complex b = set(1, 2);
  complex c = set(5, 6);
  complex d = set(7, 8);
  complex e = set(9, 10);
  complex f = set(11, 12);
  complex g = set(13, 14);
  puts(notation(a));
  int height, search;
  tree* t = create(a,
              create(b,
               initialize(),
                  create(d, initialize(), initialize())),
              create(c,
                  create(e, initialize(), initialize()),
                  create(f, create(g,initialize(),initialize()), initialize())
                    )
              );    
   
   height = getTreeHeight(t);
   search = searchElem(t, g);
   printf("Altura da arvore: %d\n", height);
   if(search == 1)
    printf("o elemento procurado se encontra na arvore.\n");
   else 
    printf("o elemento procurado não se encontra na arvore.\n"); 
  system("PAUSE");
  return 0;
}

[William Rodrigues]

Saudações,

Quanto ao problema de comparação, utilize a função strcmp().

Aqui (VS 2010) seu código não compilou. Para fazê-lo compilar foi necessário, entre outros pontos corrigidos, comentar a linha com a chamada do "complex.h" no arquivo "main.c".

Abraços,

William Rodrigues.