Question

In C++ and use functions that are asked for, thanks!

Implement the BinarySearchTree ADT in a file BinarySearchTree.h exactly as shown below.

// BinarySearchTree.h
// after Mark A. Weiss, Chapter 4, Dr. Kerstin Voigt

#ifndef BINARY_SEARCH_TREE_H
#define BINARY_SEARCH_TREE_H

#include <cassert>
#include <iostream>
using namespace std;      

template <typename C>
class BinarySearchTree
{
  public:
    BinarySearchTree( ) : root{ nullptr }
    {
    }

    ~BinarySearchTree( ) 
    { 
        makeEmpty();
    }

    const C & findMin( ) const
    {
      assert(!isEmpty());
      return findMin( root )->element;
    }

    const C & findMax( ) const
    {
      assert(!isEmpty());
      return findMax( root )->element;
    }

    bool contains( const C & x ) const
    {
        return contains( x, root );
    }

    bool isEmpty( ) const
    {
        return root == nullptr;
    }

    void printTree( ) const
    {
        if( isEmpty( ) )
            out << "Empty tree" << endl;
        else
            printTree( root );
    }

    void makeEmpty( )
    {
        makeEmpty( root );
    }
    
    void insert( const C & x )
    {
        insert( x, root );
    }     

    void remove( const C & x )
    {
        remove( x, root );
    }

  private:
    
    struct BinaryNode
    {
        C element;
        BinaryNode* left;
        BinaryNode* right;

        BinaryNode( const C & theElement, BinaryNode* lt, BinaryNode* rt )
          : element{ theElement }, left{ lt }, right{ rt } { }
    };

    BinaryNode* root;
    
    // Internal method to insert into a subtree.
    // x is the item to insert.
    // t is the node that roots the subtree.
    // Set the new root of the subtree.    
    void insert( const C & x, BinaryNode* & t )
    {
        if( t == nullptr )
            t = new BinaryNode{ x, nullptr, nullptr };
        else if( x < t->element )
            insert( x, t->left );
        else if( t->element < x )
            insert( x, t->right );
        else
            ;  // Duplicate; do nothing
    }
    
    // Internal method to remove from a subtree.
    // x is the item to remove.
    // t is the node that roots the subtree.
    // Set the new root of the subtree.    
    void remove( const C & x, BinaryNode* & t )
    {
        if( t == nullptr )
            return;   // Item not found; do nothing
        if( x < t->element )
            remove( x, t->left );
        else if( t->element < x )
            remove( x, t->right );
        else if( t->left != nullptr && t->right != nullptr ) // Two children
        {
            t->element = findMin( t->right )->element;
            remove( t->element, t->right );
        }
        else
        {
            BinaryNode* oldNode = t;
            t = ( t->left != nullptr ) ? t->left : t->right;
            delete oldNode;
        }
    }

    // Internal method to find the smallest item in a subtree t.
    // Return node containing the smallest item.    
    BinaryNode* findMin( BinaryNode* t ) const
    {
        if( t == nullptr )
            return nullptr;
        if( t->left == nullptr )
            return t;
        return findMin( t->left );
    }
    
    // Internal method to find the largest item in a subtree t.
    // Return node containing the largest item.
    BinaryNode* findMax( BinaryNode* t ) const
    {
        if( t != nullptr )
            while( t->right != nullptr )
                t = t->right;
        return t;
    }

    // Internal method to test if an item is in a subtree.
    // x is item to search for.
    // t is the node that roots the subtree.    
    bool contains( const C & x, BinaryNode* t ) const
    {
        if( t == nullptr )
            return false;
        else if( x < t->element )
            return contains( x, t->left );
        else if( t->element < x )
            return contains( x, t->right );
        else
            return true;    // Match
    }

    void makeEmpty( BinaryNode* & t )
    {
        if( t != nullptr )
        {
            makeEmpty( t->left );
            makeEmpty( t->right );
            delete t;
        }
        t = nullptr;
    }

    void printTree( BinaryNode* t) const
    {
        if( t != nullptr )
        {
            printTree( t->left);
            cout << t->element << " - ";
            printTree( t->right);
        }
    }
};
#endif

Program your own file lab07.cpp in which your main() function will test the new data structure.

• The main function is contained in the file lab07.cpp.
• Declare an instance of BinarySearchTree (short: BST) suitable to hold integer values.
• Prompt user to enter a random sequence of integer values, insert these values into the data structure (the entered values should NOT be in sorted order).
• Call the printTree() member function in order to print out the values of the BST structure.
• Prompt user to enter a random sequence of integer values, remove these values from your BST. Print out the reduced BST.

• Add the following member function in your BinarySearchTree class template.

  public:
  
  void printInternal() 
  {
     print_Internal(root,0);
  }
  
  private:
  
  void printInternal(BinaryNode* t, int offset)
  {
     if (t == nullptr)
         return;
  
     for(int i = 1; i <= offset; i++) 
         cout << "...";
     cout << t->element << endl;
     printInternal(t->left, offset + 1);
     printInternal(t->right, offset + 1);
  }
  

• Go back to your program lab07.cpp and call printInternal. Compile and run your program, and see what you get.

The expected result:

insert the values (stop when entering 0):
10 5 20 3 22 6 18 7 9 13 15 4 2 1 19 30 8 0
print the values:
1 - 2 - 3 - 4 - 5 - 6 - 7 - 8 - 9 - 10 - 13 - 15 - 18 - 19 - 20 - 22 - 30 - 
Print the tree:
10
...5
......3
.........2
............1
.........4
......6
.........7
............9
...............8
...20
......18
.........13
............15
.........19
......22
.........30
remove the values (stop when entering 0):
1 11 2 12 3 13 0
print the values:
4 - 5 - 6 - 7 - 8 - 9 - 10 - 15 - 18 - 19 - 20 - 22 - 30 - 
Print the tree:
10
...5
......4
......6
.........7
............9
...............8
...20
......18
.........15
.........19
......22
.........30

Answer 1

Screenshot of the code for lab07.cpp with a brief explanation:

Output Obtained:

Screenshot of the BinarySearchTree.h file where the two functions were inserted:

There were a few minor bug and errors with the name of the method I have fixed them and Below is the code of both BinarySearchTree.h and lab07.cpp

BinarySearchTree.h code:

#ifndef BINARY_SEARCH_TREE_H
#define BINARY_SEARCH_TREE_H

#include <cassert>
#include <iostream>
using namespace std;

template <typename C>
class BinarySearchTree
{
public:
BinarySearchTree( ) : root{ nullptr }
{
}

~BinarySearchTree( )
{
makeEmpty();
}

const C & findMin( ) const
{
assert(!isEmpty());
return findMin( root )->element;
}

const C & findMax( ) const
{
assert(!isEmpty());
return findMax( root )->element;
}

bool contains( const C & x ) const
{
return contains( x, root );
}

bool isEmpty( ) const
{
return root == nullptr;
}

void printTree( ) const
{
if( isEmpty( ) )
cout << "Empty tree" << endl;
else
printTree( root );
}

void makeEmpty( )
{
makeEmpty( root );
}
  
void insert( const C & x )
{
insert( x, root );
}   

void remove( const C & x )
{
remove( x, root );
}
  
void print_Internal() //This method was added in the public section of BinarySearchTree.h
   {
   printInternal(root,0);
   }

private:
  
struct BinaryNode
{
C element;
BinaryNode* left;
BinaryNode* right;

BinaryNode( const C & theElement, BinaryNode* lt, BinaryNode* rt )
: element{ theElement }, left{ lt }, right{ rt } { }
};

BinaryNode* root;
  
// Internal method to insert into a subtree.
// x is the item to insert.
// t is the node that roots the subtree.
// Set the new root of the subtree.
void insert( const C & x, BinaryNode* & t )
{
if( t == nullptr )
t = new BinaryNode{ x, nullptr, nullptr };
else if( x < t->element )
insert( x, t->left );
else if( t->element < x )
insert( x, t->right );
else
; // Duplicate; do nothing
}
  
// Internal method to remove from a subtree.
// x is the item to remove.
// t is the node that roots the subtree.
// Set the new root of the subtree.
void remove( const C & x, BinaryNode* & t )
{
if( t == nullptr )
return; // Item not found; do nothing
if( x < t->element )
remove( x, t->left );
else if( t->element < x )
remove( x, t->right );
else if( t->left != nullptr && t->right != nullptr ) // Two children
{
t->element = findMin( t->right )->element;
remove( t->element, t->right );
}
else
{
BinaryNode* oldNode = t;
t = ( t->left != nullptr ) ? t->left : t->right;
delete oldNode;
}
}

// Internal method to find the smallest item in a subtree t.
// Return node containing the smallest item.
BinaryNode* findMin( BinaryNode* t ) const
{
if( t == nullptr )
return nullptr;
if( t->left == nullptr )
return t;
return findMin( t->left );
}
  
// Internal method to find the largest item in a subtree t.
// Return node containing the largest item.
BinaryNode* findMax( BinaryNode* t ) const
{
if( t != nullptr )
while( t->right != nullptr )
t = t->right;
return t;
}

// Internal method to test if an item is in a subtree.
// x is item to search for.
// t is the node that roots the subtree.
bool contains( const C & x, BinaryNode* t ) const
{
if( t == nullptr )
return false;
else if( x < t->element )
return contains( x, t->left );
else if( t->element < x )
return contains( x, t->right );
else
return true; // Match
}

void makeEmpty( BinaryNode* & t )
{
if( t != nullptr )
{
makeEmpty( t->left );
makeEmpty( t->right );
delete t;
}
t = nullptr;
}

void printTree( BinaryNode* t) const
{
if( t != nullptr )
{
printTree( t->left);
cout << t->element << " - ";
printTree( t->right);
}
}
void printInternal(BinaryNode* t, int offset) //This method was added in to private section of BinarySearchTree.h
   {
   if (t == nullptr)
   return;
  
   for(int i = 1; i <= offset; i++)
   cout << "...";
   cout << t->element << endl;
   printInternal(t->left, offset + 1);
   printInternal(t->right, offset + 1);
   }
};
#endif

lab07.cpp code:

#include<iostream>
#include "BinarySearchTree.h"
using namespace std;
int main()
{
   int input; //Variable to store the input from the user.
  
   BinarySearchTree<int> tree; //Creating an object of BinarySearchTree, which can hold integer values.
   //Message to the user to enter values from insertion into the tree.
   cout<<"Enter random integer values(unsorted) for inserting into the BST(to stop enter 0):"<<endl;
   cin>>input;
   while(input!=0) //we will stop taking input from the user on occurance of 0.
   {
       tree.insert(input);
       cin>>input;
   }
   //Printing the value in the BST in sorted order and Also we are printing the tree.
   cout<<"The values in the BST in sorted sorted:"<<endl;
   tree.printTree();
   cout<<"The tree representation:"<<endl;
   tree.print_Internal(); //The new funtion that was added.
   //Asking the user to enter the numbers to be removed from the BST.
   cout<<"Enter the values to be removed from the tree(to stop enter 0):"<<endl;
   cin>>input;
   while(input!=0)//Here also, we will stop taking input from the user on occurance of 0.
   {
       tree.remove(input);
       cin>>input;
   }
   //Printing the value in the BST in sorted order and Also we are printing the tree.
   cout<<"The values in the BST in sorted sorted:"<<endl;
   tree.printTree();
   cout<<"The tree representation:"<<endl;
   tree.print_Internal();
  
   return 0;  
}

I hope you like the solution. In case of any doubts regarding the solution feel free to ask it in the comment section. If you like the solution please give a thumbs up.