Как удалить класс из кода и все еще заставить его работать?

Question

так что для школы я сделал код и использовал классы, но учитель сказал, что я не должен был использовать классы. Есть ли способ изменить мой текущий код, чтобы я был бесклассовым? это двоичное дерево поиска, которое сделано с классом, и мне нужно удалить его. Информация о том, что делать, что удалять или изменять, поможет вам, вам не нужно редактировать мой код.

    #include <iostream>
    #include <cstdlib>

using namespace std;
class BST
{
    private:
        struct tree_node
        {
           tree_node* left;
           tree_node* right;
           int data;
        };


    public:
        BST()
        {
           root = NULL;
           parent = NULL;
        }
        tree_node* root;
        tree_node* parent;

        bool isEmpty() const { return root==NULL; }
        void print_inOrder();
        void inOrder(tree_node*);
        void print_preOrder();
        void preOrder(tree_node*);
        void print_postOrder();
        void postOrder(tree_node*);
        void search(tree_node*,int,tree_node*);
        void insert(int);
        void create(int);
        void remove(int);
};

void BTS::search(tree_node* root,int k,tree_node* parent)
{

    if (root == nullptr)
    {
        cout << "Element not found"<<endl;
        return;
    }
    if (root->data == k)
    {
        if (parent == nullptr)
            cout << "element " << k << " found "; //jeigu ieskomas skaicius medzio virsune

        else cout << "element "<<k<<" found "<<endl;
        return;
    }
    if (k < root->data)
        return searcch(root->left,k, root); // rekursija jeigu reiksme mazesne uz sakny einame i kaire

    return search(root->right,k,root);// rekursija jeigu reiksme mazesne uz sakny einame i desine
}

void BTS::create(int d)
{
    for(int i=0;i<d;i++)
    {
    tree_node* t = new tree_node;
    tree_node* parent;
    cout<<"enter element"<<endl;
    cin>>t->data;
    t->left = NULL;
    t->right = NULL;
    parent = NULL;

    if(isEmpty()) root = t;
    else
    {
        tree_node* current;
        current = root;
        while(current)
        {
            parent = current;
            if(t->data > current->data) current = current->right;
            else current = current->left;
        }

        if(t->data < parent->data)
           parent->left = t;
        else
           parent->right = t;
    }
    }
}

void BTS::remove(int d)
{
    bool found = false;
    if(isEmpty())
    {
        cout<<" tree is empty "<<endl;
        return;
    }
    tree_node* curr;
    tree_node* parent;
    curr = root;

    while(curr != NULL)
    {
         if(curr->data == d)
         {
            found = true;
            break;
         }
         else
         {
             parent = curr;
             if(d>curr->data) curr = curr->right;
             else curr = curr->left;
         }
    }
    if(!found)
         {
        cout<<" element not found"<<endl;
        return;
    }


    if((curr->left == NULL && curr->right != NULL)|| (curr->left != NULL
&& curr->right == NULL))
    {
       if(curr->left == NULL && curr->right != NULL)
       {
           if(parent->left == curr)
           {
             parent->left = curr->right;
             delete curr;
           }
           else
           {
             parent->right = curr->right;
             delete curr;
           }
       }
       else
       {
          if(parent->left == curr)
           {
             parent->left = curr->left;
             delete curr;
           }
           else
           {
             parent->right = curr->left;
             delete curr;
           }
       }
     return;
    }
         if( curr->left == NULL && curr->right == NULL)
    {
        if(parent->left == curr) parent->left = NULL;
        else parent->right = NULL;
                 delete curr;
                 return;
    }
    if (curr->left != NULL && curr->right != NULL)
    {
        tree_node* chkr;
        chkr = curr->right;
        if((chkr->left == NULL) && (chkr->right == NULL))
        {
            curr = chkr;
            delete chkr;
            curr->right = NULL;
        }
        else
        {
            if((curr->right)->left != NULL)
            {
                tree_node* lcurr;
                tree_node* lcurrp;
                lcurrp = curr->right;
                lcurr = (curr->right)->left;
                while(lcurr->left != NULL)
                {
                   lcurrp = lcurr;
                   lcurr = lcurr->left;
                }
        curr->data = lcurr->data;
                delete lcurr;
                lcurrp->left = NULL;
           }
           else
           {
               tree_node* tmp;
               tmp = curr->right;
               curr->data = tmp->data;
           curr->right = tmp->right;
               delete tmp;
           }

        }
         return;
    }

}

void BTS::print_inOrder()
{
  inOrder(root);
}

void BTS::inOrder(tree_node* p)// naudojant rekursija atspausdinu medi vidniu apejimu
{
    if(p != NULL)
    {
        if(p->left) inOrder(p->left);
        cout<<" "<<p->data<<" ";
        if(p->right) inOrder(p->right);
    }
    else return;
}


void BTS::print_preOrder()
{
    preOrder(root);
}

void BTS::preOrder(tree_node* p)// naudojant rekursija atspausdinu medi tiesioginu apejimu
{
    if(p != NULL)
    {
        cout<<" "<<p->data<<" ";
        if(p->left) preOrder(p->left);
        if(p->right) preOrder(p->right);
    }
    else return;
}

void BTS::print_postOrder()
{
    postOrder(root);
}

void BTS::postOrder(tree_node* p) // naudojant rekursija atspausdinu medi atvikstiniu apejiu
{
    if(p != NULL)
    {
        if(p->left) postOrder(p->left);
        if(p->right) postOrder(p->right);
        cout<<" "<<p->data<<" ";
    }
    else return;
}
void BTS::insert(int d)
{
    tree_node* t = new tree_node;
    tree_node* parent;
    t->data = d;
    t->left = NULL;
    t->right = NULL;
    parent = NULL;

    if(isEmpty()) root = t;
    else
    {
        tree_node* current;
        current = root;
        while(current)
        {
            parent = current;
            if(t->data > current->data) current = current->right;
            else current = current->left;
        }

        if(t->data < parent->data)
           parent->left = t;
        else
           parent->right = t;
    }
}

int main()
{
    BTS b;
    int punktas=0,c,d;

       cout<<endl<<endl;
       cout<<" MENU "<<endl;
       cout<<" ----------------------------- "<<endl;
       cout<<" 1) sukurti "<<endl;
       cout<<" 2) tiesioginis elementu spausdinimas "<<endl;
       cout<<" 3) vidinis elementu spausdinimas "<<endl;
       cout<<" 4) atvirkstinis elementu spausdinimas "<<endl;
       cout<<" 5) iterpti nauja elementa "<<endl;
       cout<<" 6) reiksmes trinimas "<<endl;
       cout<<" 7) reiksmes paieska "<<endl;
       cout<<" 0) Iseiti "<<endl;
       cout<<" Iveskite norima punkta"<<endl;
       cin>>punktas;
       int tikrinimas = 1;

       while(punktas!=0)
       {

           if(punktas==1)
           {cout<<"Kiek reiksmiu bus sarase?"<<endl;
                    cin>>c;
                    b.sukurti(c); //panaudojam klases sukurti funckija
                    tikrinimas = 0;
           }
           else if(punktas==2 && tikrinimas == 0)
                    {
                    cout<<" tiesioginis atspausdinimas "<<endl;
                    cout<<" -------------------"<<endl;
                    b.print_tiesioginis();// panaudojam klases tiesioginis atspausdinias funckija
                    }
           else if(punktas==3 && tikrinimas == 0)
                    {
                    cout<<" vidinis atspausdinimas "<<endl;
                    cout<<" -------------------"<<endl;
                    b.print_vidinis();// panaudoja klases funkcija
                    }
           else if(punktas==4 && tikrinimas == 0)
                    {
                    cout<<" atvirkstinis atspausdinimas "<<endl;
                    cout<<" --------------------"<<endl;
                    b.print_atvirkstinis();// panaudoja klases funkcija
                    }
           else if(punktas==5 && tikrinimas == 0)
                    {cout<<"elemento iterpimas"<<endl;
                     cout<<" --------------------"<<endl;
                     cin>>c;
                     b.iterpti(c);// panaudoja klases funkcija
                    }
           else if(punktas==6 && tikrinimas == 0)
                    {
                    cout<<" iveskite elementa kuri norite istrinti "<<endl;
                    cin>>d;
                    b.salinti(d);// panaudoja klases funkcija
                    }
           else if(punktas==7 && tikrinimas == 0)
                    {
                    cout<<"iveskite reiksme kuria norite surasti"<<endl;
                    cin>>c;
                    b.paieska(b.root,c,b.tevas);
                    }
                    else if(punktas<8){cout<<"sukurkyte medi norit atlikti punktus"<<endl;}
         cout<<"iveskite kita punkta"<<endl;
         cin>>punktas;
       }
}

Answer 1

Спасибо за помощь, и извините, если я вас раздражал. исправить это, переместив функции-члены в свободные функции.

Answer 2

Вы не используете много классов здесь.

Вы создали один paieskosMedis с именем b и поместили некоторые логи приложения c в его члены-данные и функции-члены.

Так что вместо этого просто переместите их в свободные функции и глобальные переменные. Это, вероятно, то, что хочет ваш учитель.

Например, это:

class Foo
{
public:
   Foo() { m = 3; }
   void bar() { m = 4; }
private:
   int m;
};

int main()
{
   Foo f;
   f.bar();
}

становится:

int m;

void bar() { m = 4; }

int main()
{
   m = 3;
   bar();
}

И, ура, вы, вероятно, уже решили задачу Вы получите следующую неделю. 101

Обратите внимание, что tree_node по-прежнему будет классом, потому что struct вводит классы, но ваш учитель может не знать об этом и думает о них как о чем-то отдельном "struct". Поэтому мы проигнорируем это.