Question

Hello guys can you t help me with writing a c++ program using classes to for doing a program about BINARY SEARCH TREES (BST) which would be capable of these things :

1.insert data to the current place in the tree with the ability to add same data many times in the tree

2.delete data from the tree

3.list the data according to *Preorder*-*Inorder*-Postorder* ways

4.count the data in the tree in two ways  , first with counting the data that is repeated and second with out counting the data that’s is repeated

5. check the balance of the tree

6. display the tree structure of the program on the screen

Answer 1

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <iomanip>
#include <math.h>

using namespace std;

struct Node{
int key;
Node* left, *right;
};

class BinarySearchTree{
public:
BinarySearchTree(){
    root = nullptr;
}

~BinarySearchTree(){
    deleteTree(&root);
}

void insert(int key){
    doInsert(&root, key);
}

void display(){
    cout<<"Preorder: ";
    preOrder(root);
    cout<<endl;
    cout<<"Inorder: ";
    inOrder(root);
    cout<<endl;
    cout<<"Postorder: ";
    postOrder(root);
    cout<<endl;
}

int countWithRepeated(){
    return doCountWithRepeated(root);
}

int countWithNotRepeated(){
    vector<int> keys;
    doCountWithNotRepeated(root, keys);
    return keys.size();
}

bool isBalanced(){
    return isBalanced(root);
}

void printTreeStructure(){
    printTreeStructure("", root, false);
}

private:
Node* getNewNode(int key){
    Node* newnode = new Node;
    newnode->key = key;
    newnode->left = nullptr;
    newnode->right = nullptr;
    return newnode;
}

void doInsert(Node** r, int key){
    if(*r == nullptr){
      *r = getNewNode(key);
      return;
    }
    if(key <= (*r)->key){
      if((*r)->left == nullptr){
        (*r)->left = getNewNode(key);
      }else{
        doInsert(&(*r)->left, key);
        return;
      }
    }
    if(key > (*r)->key){
      if((*r)->right == nullptr){
        (*r)->right = getNewNode(key);
      }else{
        doInsert(&(*r)->right, key);
        return;
      }
    }
}

void inOrder(Node* r){
    if(r != nullptr){
      inOrder(r->left);
      cout<<r->key<<" ";
      inOrder(r->right);
    }
}

void preOrder(Node* r){
    if(r != nullptr){
      cout<<r->key<<" ";
      preOrder(r->left);
      preOrder(r->right);
    }
}

void postOrder(Node* r){
    if(r != nullptr){
      postOrder(r->left);
      postOrder(r->right);
      cout<<r->key<<" ";
    }
}

int doCountWithRepeated(Node* r){
    if(r == nullptr){
      return 0;
    }
    return 1+doCountWithRepeated(r->left)+doCountWithRepeated(r->right);
}

void doCountWithNotRepeated(Node* r, vector<int>& keys){
    if(r == nullptr)
      return;
    if(find(keys.begin(), keys.end(), r->key) == keys.end()){
      keys.push_back(r->key);
    }
    doCountWithNotRepeated(r->left, keys);
    doCountWithNotRepeated(r->right, keys);
}

int height(Node* r){
    if(r == nullptr) return 0;
    return 1 + max(height(r->left), height(r->right));
}

bool isBalanced(Node* r){
    int lh;
    int rh;
    if(r == nullptr) return 1;
    lh = height(root->left);
    rh = height(root->right);
    if(abs(lh - rh) <= 1 && isBalanced(r->left) && isBalanced(r->right))
        return 1;
    return 0;
}

void printTreeStructure(const std::string& prefix, Node* r, bool isLeft){
    if(r != nullptr){
      std::cout << prefix;
      std::cout << (isLeft ? "├──" : "└──" );
      std::cout << r->key << std::endl;
      printTreeStructure(prefix + (isLeft ? "│   " : "    "), r->left, true);
      printTreeStructure(prefix + (isLeft ? "│   " : "    "), r->right, false);
    }
}

void deleteTree(Node** r){
    if(*r != nullptr){
      deleteTree(&(*r)->left);
      deleteTree(&(*r)->right);
      delete *r;
    }
}

private:
Node* root;
};

int main()
{
BinarySearchTree bst;
bst.insert(10);
bst.insert(20);
bst.insert(30);
bst.insert(80);
bst.insert(50);
bst.insert(70);
bst.insert(10);
bst.insert(40);
bst.display();
cout<<"Count: "<<bst.countWithRepeated()<<endl;
cout<<"Count not repeated: "<<bst.countWithNotRepeated()<<endl;
cout<<"is balanced: "<<bst.isBalanced()<<endl;
bst.printTreeStructure();
return 0;
}