Thread: BST addword function

Hi!
I'm building a Tree that reads words in from a text file and adds it to the tree in sibling or child branches. Everything is being scanned in ok, but something is wrong with Addaword. It seems to not be getting past the first word of the array, and just winds up repeating it. Does anyone know how I would increment it correctly?

*added more code to clarify*

Code:

class Node     
{
   private:
   Node *sibling;
   Node *child;
   int occurs;
   int letters;

   public:
   AddAWord(char word[], int i);
   Search(char request[]);
   Node(char l) {occurs=0; sibling=0; child=0; letters=l;}
};

void main(void)
{        
        Node *root=new Node('-');
        Node* new_node;
        char* word[80];
        int len;
        FILE*input;
        char* request[10];
        char str[80];
        int i = 0, k=0, l=0;
        ifstream b_file("abook.txt", ios::in);

                b_file>>str;
                for(int j=0; j < strlen(str); j++)
                {
                        str[j] = tolower((int)str[j]); 
			}
               len = strlen(str);
                word[i] = new (char[len+1]);

               strcpy(word[i++], str);
                root->AddAWord(*word, l);
       while(b_file.eof()==0 || i<80)
        {
                b_file>>str;
                for(int j=0; j < strlen(str); j++)
                {                                   
					str[j] = tolower((int)str[j]);
                }
                len = strlen(str);
                word[i] = new (char[len+1]);
                strcpy(word[i++], str);
                new_node->AddAWord(word[i], l);
        }
        cout<<"What word would you like to search for: "<<endl;
        cin>>str;
        len = strlen(str);            
  request[k] = new (char[len+1]);
        strcpy(request[k++], str);
}
{
 cout<<word;

  if(letters!=word[0])
  {
    if(sibling==0)
    {               
 sibling=new Node(*word);
          i++;
      sibling->AddAWord(word, i);
    }
        else
        {
                sibling->AddAWord(word, i++);
        }
  }
  else if(word[i] != '\0')
  {
          if(child == 0)
          {           
child=new Node(*word);
                  printf("%c", word[i]);
                  i++;
                  child->AddAWord(word, i);
          }
         else
         {
                  child->AddAWord(word, i++);
        }
}
}

It would help to see some more code. Like what is the line above that opening brace? And where is letters declared? And you shouldn't mix cout<< and printf...Just stick with one

You should work on your data structure. A BST is meant to simplify the manipulation of data, not make it more complicated. A little more organization might help, too...

>A BST is meant to simplify the manipulation of data, not make it more complicated.
Not really. A binary search tree is meant to improve the efficiency of operations that involve searching. If we wanted to simplify data manipulation, everything would either use arrays or simple linked lists. A basic binary search tree is simple, but definitely more complicated than a linked list, and when you introduce balancing to guarantee logarithmic performance, you lose that simplicity.

Case in point: there is no memory management to speak of in the code posted by the OP. A data structure has to be stable at any given moment, birth through destruction, to be considered good enough for use - right? If memory leaks or pointers dangle - how useful is that? Just seems illogical to me - that's all.

Dude, post more of your code; afterall how are we supposed to help if we can't see the engine of the car?? (i.e. AddAWord itself)
Or you can chechk one of my early posts with attached code that does something similar.. ('bout 10-15 pages down I thinks)

>A data structure has to be stable at any given moment
Different people will have different ideas of a stable data structure. I see a stable data structure as one that can have any legal operation performed on it without breaking or causing future legal operations to break. This definition says nothing about memory management because I often write data structures that do not manage their own memory.

>If memory leaks or pointers dangle - how useful is that?
Memory leakage isn't a problem with programs that don't run for long on systems that reclaim memory allocated to them. Dangling pointers are only a problem if they are referenced or actually break the data structure. This isn't to say that allowing either is good style, but it isn't actually wrong.

>Just seems illogical to me
Sadly, real-world programming is often illogical.