Member Avatar for schoolboy2010

Hi

My program is supposed to implement a binary tree with an insert, remove, copy, pre-order, post-order and in-order views.

Problem is that my code compiles... but doesnt work. Could someone help me out.
Thanks.

I attached the code...

brownt7.h

a7.cpp

brownt7.cpp

#include "brownt7.h"
#include<iostream>
#include<cstring>
#include <cstdlib>

using namespace std;

//function for the menu
int menu();

int main()
{
    int choice;
    //do while loop loops the program except the user's choice is a '6'
    BSTF10 tree;
    
    ElementF10 store;
        
    do
    {
        choice = menu();
        
        //BSTF10 q1;
        //BSTF10 e1;
    
        if (choice == 1)
        {
            system ("clear");
            cout << "\nInsert an element.\n\n";
            cin >> store;
            
            tree.insertBSTNode(store);
        }

        if (choice == 2)
        {
            system ("clear");
            cout << "\nRemove an element.\n\n";
            cin >> store;
            tree.removeBSTNode(store);
        }

        if (choice == 3)
        {
            system ("clear");
            cout << "\nTree from top to bottom: \n\n";
            tree.preOrderBST();
            cout << "\n\nPress any key to continue.\n\n";
            cin.ignore();
            cin.get();
        }
        
        if (choice == 4)
        {
            system ("clear");
            cout << "\nTree in ascending order: \n\n";
            tree.inOrderBST();
            cout << "\n\nPress any key to continue.\n\n";
            cin.ignore();
            cin.get();
        }
        
        if (choice == 5)
        {
            system ("clear");
            cout << "\nTree from bottom to top: \n\n";
            tree.postOrderBST();
            cout << "\n\nPress any key to continue.\n\n";
            cin.ignore();
            cin.get();
        }
        
        if (choice == 6)
        {
            system ("clear");
            cout << "\nCopying BST Tree... : \n\n";
            tree.postOrderBST();
            cout << "\n\nPress any key to continue.\n\n";
            cin.ignore();
            cin.get();
        }
        

    }while (choice != 7);

    if (choice == 7)//exits the program if the choice variable holds 6
    {
         system ("clear");
         //system ("clear");
         cout << "\nYou chose to exit. Good bye.\nPress any key to exit.\n\n";
         cin.ignore();
         cin.get();
         exit(0);
    }

    return 0;
}
#include "brownt7.h"
#include <iostream>
#include <iomanip>
#include <cstdlib>

using namespace std;

typedef bool BoolF10;

BSTF10 queue;
int menu()
{
     system("clear");
     cout << "__________________________________________________________________________\n";
     cout << "What do you want to do?\n";
     cout << "__________________________________________________________________________\n";
     cout << " 1. Insert a new element\n";
     cout << " 2. Remove an element\n";
     cout << " 3. Display the BST tree from top to bottom\n";
     cout << " 4. Display the BST tree in ascending order\n";
     cout << " 5. Display the BST tree from bottom to top\n";
     cout << " 6. Copy the BST tree from one to another\n";
     cout << " 7. Exit\n";
     cout << "__________________________________________________________________________\n";
     cout << " \n\nYour choice: ";
     int option;
     cin >> option;
     while (option < 1 || option > 7)
     {
           cout << "\a\nYou entered an invalid choice. \nEnter a number from 1 to 6.\n";
           cin >> option;
     }
     return option;
}


BSTF10::BSTF10()//: queueArray(NULL), QUEUE_CAPACITY(5)//constructor
{
      initializeBST(rootBST);
}


BSTF10::BSTF10( const BSTF10 & old )//copy constructor
{
     BSTF10 current;
     current.copyBST(rootBST);
}


void BSTF10::insertBSTNode(const ElementF10 num)
{
    insertBSTNode(num, rootBST);
}


void BSTF10::insertBSTNode(const ElementF10 number, BSTPtr &holdNode)
{
    
     
   if (isEmptyBST(holdNode)){
       BSTPtr node = new(nothrow) BSTNode;
   
       if(node != NULL)
       {
          node->element = number;
          holdNode = node;
       }
   }              
   else if (number < holdNode->element)
      insertBSTNode(number, holdNode->left);   
   else 
      insertBSTNode(number, holdNode->right);    
}


BSTPtr BSTF10::searchBST(const ElementF10 holdNum) const
{
     searchBST(holdNum, rootBST);         
}


BSTPtr BSTF10::searchBST(const ElementF10 theNumber,  BSTPtr holdTree) const
{
    BSTPtr node = rootBST;
    if(isEmptyBST(holdTree)){
        return holdTree;
    }
    BSTNode *nodePtr = rootBST;

    while (nodePtr)
    {
       if (nodePtr->element == theNumber)
          return holdTree;
       else if (theNumber < nodePtr->element)
          nodePtr = nodePtr->left;
       else
          nodePtr = nodePtr->right;
    }
    return holdTree;
}


void BSTF10::removeBSTNode(const ElementF10 number)
{
     BSTNode *nnode; 
     nnode = new BSTNode;
     removeBSTNode(number, nnode);
}

void BSTF10::removeBSTNode(const ElementF10 hNum, BSTPtr &hNode)
{
     if(isEmptyBST(hNode)){
          cout << endl << "The Binary Tree is empty" << endl;
          cout << "Press enter to continue" << endl;
          cin.get();
     }
     
     else
     {
        if (hNode->element == hNum)
            deleteBSTNode(hNum, hNode);
        else if (hNum < hNode->element)
            hNode = hNode->left;
        else
            hNode = hNode->right;
     }
}


void BSTF10::preOrderBST() const
{
    BSTNode *nNode;
    nNode = new BSTNode; 
    
    cout << endl << "START" << endl;
    preOrderBST(nNode);
    cout << "FINISH" << endl;
}


void BSTF10::preOrderBST( const BSTPtr holdPtr ) const
{
    if(holdPtr != NULL)
    {
        cout << holdPtr->element << " -> ";
        if(holdPtr->left) 
            preOrderBST(holdPtr->left);
        if(holdPtr->right) 
            preOrderBST(holdPtr->right);
    }
}


void BSTF10::inOrderBST() const
{
    inOrderBST(rootBST);
}


void BSTF10::inOrderBST( const BSTPtr holdPtr ) const
{
   if (holdPtr)
   {
      inOrderBST(holdPtr->left);
      cout << holdPtr->element << endl;
      inOrderBST(holdPtr->right);
   }    
}


void BSTF10::postOrderBST() const
{
    postOrderBST(rootBST);
}

void BSTF10::postOrderBST( const BSTPtr holdPtr ) const
{
   if (holdPtr)
   {
      postOrderBST(holdPtr->left);    
      postOrderBST(holdPtr->right);
      cout << holdPtr->element << endl;
   }
}


void BSTF10::initializeBST( BSTPtr &holdBSTPTR )
{
    holdBSTPTR = NULL;    
}


bool BSTF10::isEmptyBST( const BSTPtr holdPTR) const
{
    if(rootBST == NULL)
        return true;
    else
        return false;   
}


void BSTF10::copyBST( const BSTPtr copy)
{
    if (isEmptyBST(copy))
	{
	        return;
    }
	else
    {
	        BSTF10 second;
	        second.copyBST(copy->left);
	        second.copyBST(copy->right);
	}   
}


void BSTF10::destroyBST( BSTPtr &nodePtr )
{
    if (nodePtr)
    {
       if (nodePtr->left)
          destroyBST(nodePtr->left);
       if (nodePtr->right)
          destroyBST(nodePtr->right);
       delete nodePtr;
   }
}


void BSTF10::deleteBSTNode( const ElementF10 holdsVal, BSTPtr &holdsNd )
{
   BSTNode *tempNodePtr;

   if (isEmptyBST(holdsNd)){
      cout << "This node in the Binary tree is empty.\n";
      cout << "Press enter to continue" << endl;
      cin.ignore();
      cin.get();
   }
   else if (holdsNd->right == NULL)
   {
      tempNodePtr = holdsNd;
      holdsNd = holdsNd->left; 
      delete tempNodePtr;
   }
   else if (holdsNd->left == NULL)
   {
      findMinBSTNode(holdsNd->right, tempNodePtr);
      tempNodePtr->element = holdsNd->element;
      
      holdsNd = holdsNd->right;
      delete tempNodePtr;
   }
   else
   {
      tempNodePtr = holdsNd->right;
      while (tempNodePtr->left)
         tempNodePtr = tempNodePtr->left;
      tempNodePtr->left = holdsNd->left;
      tempNodePtr = holdsNd;
      holdsNd = holdsNd->right;
      delete tempNodePtr;
   }
}


void BSTF10::findMinBSTNode( BSTPtr &holdNode, BSTPtr &holdTNode )
{
    if(holdNode->left == NULL){
         holdTNode = rootBST;
         holdNode = holdNode->right;
    }
    else
         holdNode = holdNode->left;
}


BSTF10::~BSTF10()//destructor
{      
    destroyBST(rootBST);
}
/********************************************************************
*** NAME : Tonye B. Brown ***
*** CLASS : CSC 300 ***
*** ASSIGNMENT : THREE ***
*** DUE DATE : October 27, 2010 ***
*** INSTRUCTOR : GAMRADT ***
*********************************************************************
*** DESCRIPTION : This program will allow the user to enter & remove
                  characters from A circularly implelmented queue and 
                  display them to the user using the insert and remove
                  functions***
********************************************************************/

// Specification file for the class
// This version uses some inline member functions.
#ifndef _BROWNT7_H
#define _BROWNT7_H

#include <iostream>

typedef signed int ElementF10;
struct BSTNode;
typedef BSTNode *BSTPtr;
struct BSTNode 
{
      ElementF10 element;//holds the value to be added
      BSTPtr left;
      BSTPtr right;
};        

//defining class with name QueueF10
class BSTF10 {
    public:
        BSTF10( );
        BSTF10( const BSTF10 & );
        ~BSTF10( );
        void insertBSTNode(const ElementF10);
        void removeBSTNode(const ElementF10);
        BSTPtr searchBST( const ElementF10 ) const;
        void preOrderBST( ) const;
        void inOrderBST( ) const;
        void postOrderBST( ) const;
        
                
    private:
        BSTPtr rootBST;
        void initializeBST( BSTPtr & );
        bool isEmptyBST( const BSTPtr ) const;
        void copyBST( const BSTPtr );
        void destroyBST( BSTPtr & );
        void insertBSTNode( const ElementF10,  BSTPtr & );
        void removeBSTNode( const ElementF10, BSTPtr & );
        void deleteBSTNode( const ElementF10, BSTPtr & );
        void findMinBSTNode( BSTPtr &, BSTPtr & );
        BSTPtr searchBST( const ElementF10, const BSTPtr ) const;
        void preOrderBST( const BSTPtr ) const;
        void inOrderBST( const BSTPtr ) const;
        void postOrderBST( const BSTPtr ) const;
};

#endif
  • 2 Contributors
  • 2 Replies
  • 158 Views
  • 1 Day Discussion Span
  • Latest Post Latest Post by schoolboy2010
elsiekins commented: inlcude your code in code tag not as download as they could be carrying virus that you do not know about +0

Recommended Answers

All 2 Replies

Member Avatar for daviddoria

I suggest coming up with a very simple test case. Then you can compare the behavior to the expected behavior and hopefully track down your problem. If you still can't find the problem, you will be able to ask here with much more information of what is going wrong.

Be a part of the DaniWeb community

We're a friendly, industry-focused community of developers, IT pros, digital marketers, and technology enthusiasts meeting, networking, learning, and sharing knowledge.