Something

//---------------------------------------------------------------------------

#ifndef Unit1H
#define Unit1H
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>

#include <fstream.h>
#include <iostream.h>
#include <iomanip.h>

using namespace std;

const int CPavadinimas = 0;
const int CDestytojas = 1;
const int CTrukme = 2;
const int CKreditai = 3;

const int CDydis = 255;
const int CKiekis = 100;

String Pavadinimai[4] = {
        " Pavadinimas ", " Destytojas ",
        " Trukme ",  " Kreditai "
};

struct TDuomenys
{
   String Pavadinimas;
   String Destytojas;
   String Trukme;
   String Kreditai;

   TDuomenys() {};

   TDuomenys(String pav, String dest, String trukme, String kred){
        Nustatyti(pav, dest, trukme, kred);
   }

   char* Gauti(int i)
   {
        if (i == CPavadinimas) return Pavadinimas.c_str();
        else if (i == CDestytojas) return Destytojas.c_str();
        else if (i == CTrukme) return Trukme.c_str();
        else if (i == CKreditai) return Kreditai.c_str();
        return NULL;
   }

   void Nustatyti(TDuomenys duom){
        Nustatyti(duom.Pavadinimas, duom.Destytojas, duom.Trukme, duom.Kreditai);
   }

   void Nustatyti(String pav, String dest, String trukme, String kred){
        Pavadinimas = pav;
        Destytojas = dest;
        Trukme = trukme;
        Kreditai = kred;
   }
};

int kiekis;
TDuomenys Masyvas[CKiekis];

//mantelis001@gmail.com

struct TElementas
{
        TDuomenys duomenys;
        TElementas *left, *right, *back;

        TElementas(){
                back = right = left = NULL;
        }

        TElementas(TDuomenys duom){
                duomenys.Nustatyti(duom);
        }

        TElementas(TDuomenys duom,TElementas* b){
                back = b; right = left = NULL;
                duomenys.Nustatyti(duom);
        }

        ~TElementas(){
                Naikinti();
        }

        void Iterpti(TElementas* data,int formatas)
        {
                int rez = strcmp(duomenys.Gauti(formatas), data->duomenys.Gauti(formatas));

                if (rez > 0)
                {
                        if(right)   right->Iterpti(data, formatas);
                        else{
                                right = data;
                                right->back = this;
                        }
                }
                else
                {
                        if(left)   left->Iterpti(data, formatas);
                        else{
                                left = data;
                                left->back = this;
                        }
                }

        }

        void Iterpti(TDuomenys duom, int formatas){
                Iterpti(new TElementas(duom), formatas);
        }

        void Rasti(char* str,int formatas)
        {
                int sk = strcmp(duomenys.Gauti(formatas),str);

                if(sk == 0)
                {
                        Masyvas[kiekis].Nustatyti(duomenys);

                        if(CKiekis > kiekis)
                                kiekis++;
                }

                if((sk > 0) && right) right->Rasti(str,formatas);
                if((sk < 0) && left) left->Rasti(str,formatas);
        }

        void Spausdinti(ofstream& f,int k,int formatas)
        {
                int prideti = 4;
                
                if(right)
                        right->Spausdinti(f, prideti+k,formatas);

                for(int j = 0;k > j;j++)
                        f << " ";

                f << "| " << duomenys.Gauti(formatas) << " | ";
                for(int i=0; 4 > i;i++)
                        if(formatas != i)
                                f << duomenys.Gauti(i) << " |";

                f << endl;

                if(left)
                        left->Spausdinti(f,prideti+k,formatas);

        }

        bool NaikintiElementa(char* str,int formatas,int formatas2,TElementas* head)
        {
                int sk = strcmp(duomenys.Gauti(formatas),str);

                if (sk == 0)
                {
                        if(!left && !right)
                        {
                                if(back)
                                {
                                        if(back->left == this) back->left = NULL;
                                                          else back->right = NULL;
                                        delete this;
                                }
                                else
                                {
                                        delete this;
                                        return true;
                                }
                        }

                        if(left && !right)
                        {
                                TElementas* l = left;
                                duomenys.Nustatyti(l->duomenys);
                                left = l->left;
                                right= l->right;
                                return false;
                        }

                        if(!left && right)
                        {
                                TElementas* r = right;
                                duomenys.Nustatyti(r->duomenys);
                                left = r->left;
                                right= r->right;
                                return false;
                        }

                        if(right && left)
                        {
                                TElementas* l = left;
                                TElementas* r = right;
                                duomenys.Nustatyti(l->duomenys);
                                left = l->left;
                                right = l->right;

                                head->Iterpti(r,formatas);
                                return false;
                        }
                }

                if(sk > 0 && right)
                        return right->NaikintiElementa(str, formatas, formatas2, head);

                if(sk < 0 && left)
                        return left->NaikintiElementa(str, formatas, formatas2, head);
        }

        void Naikinti()
        {
                if (right)
                {
                        right->Naikinti();
                        delete right;
                }
                if (left)
                {
                        left->Naikinti();
                        delete left;
                }
        }
};

struct TMedis
{
        int formatas;
        TElementas* top;

        TMedis()
        {
                top = NULL;
                formatas = 0;
        }

        ~TMedis()
        {
                Naikinti();
        }

        void Ivesti()
        {
                 TDuomenys D;
                 ifstream fd("duom.txt");

                 char str0[255];
                 char str1[255];
                 char str2[255];
                 char str3[255];

                 while (!fd.eof())
                 {
                        fd >> str0 >> str1 >> str2 >> str3;
                        D.Nustatyti(str0, str1, str2, str3);

                        Iterpti(D);
                 }
                 fd.close();
        }

        void Spausdinti()
        {
                ofstream f("rez.txt");

                if(top) top->Spausdinti(f, 0, formatas);

                f.close();
        }

        void Iterpti(TDuomenys duom)
        {
                if(top) top->Iterpti(duom, formatas);
                   else top = new TElementas(duom, NULL);
        }

        void Rasti(char* str,int formatas)
        {
                kiekis = 0;

                if(top)
                        top->Rasti(str,formatas);
        }

        void NaikintiElementa(char* str,int formatas)
        {
                if(top)
                {
                        if(top->NaikintiElementa(str, formatas, top))
                                top = NULL;
                }
        }

        void Naikinti()
        {
                if (top)
                        top->Naikinti();
                delete top;
                top = NULL;
        }

};

class TForm1 : public TForm
{
__published:	// IDE-managed Components
        TMemo *Memo1;
        TButton *Button1;
        TButton *Button2;
        TEdit *Edit1;
        TEdit *Edit2;
        TEdit *Edit3;
        TEdit *Edit4;
        TButton *Button3;
        TButton *Button4;
        TEdit *Edit5;
        TButton *Button5;
        TEdit *Edit6;
        TButton *Button6;
        TButton *Button7;
        TEdit *Edit7;
        void __fastcall Button1Click(TObject *Sender);
        void __fastcall Button2Click(TObject *Sender);
        void __fastcall Button3Click(TObject *Sender);
        void __fastcall Button4Click(TObject *Sender);
        void __fastcall Button5Click(TObject *Sender);
        void __fastcall Button6Click(TObject *Sender);
        void __fastcall Button7Click(TObject *Sender);
private:	// User declarations
public:		// User declarations

        TMedis medis;
        
        __fastcall TForm1(TComponent* Owner);
};
//---------------------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
//---------------------------------------------------------------------------
#endif