Бинарные деревья

#include <iostream>
#include <string>
#include <sstream>
#include <vector>
#include <set>;
using namespace std;
template < class any > class BinaryTree
{
private:
  template < class any > class Node
  {
  public:
    Node * point_right;
    Node *point_left;
    any data;
    Node (any value, Node * p_right = nullptr, Node * p_left = nullptr)
    {
      data = value;
      point_right = p_right;
      point_left = p_left;
    }
  };
  bool IsExist;
  int NodeCount;
  Node < any > *root;
public:
  Node < any > *Get_Root ()
  {
    return root;
  }
  BinaryTree ();//конструктор
  void Add (any data);//добавление данных
  void Delete ();//удаление
  Node < any > *Find (any data, Node < any > *root_node);//поиск элемента
  any GetElement (Node < any > *obj);//получение элемента
  void Edit (any data, any data_edit);//изменение данных
  any *FindAll ();//?
  void Print (Node < any > *root_node);//вывод
  any Min ();
  any Max ();
  const int GetNodeCount ()//размер узлов древа?
  {
    return NodeCount;
  }
};
 
template < class any > BinaryTree < any >::BinaryTree ()//конструктор
{
  NodeCount = 0;
  IsExist = false;
  root = nullptr;
}
 
template < class any > void BinaryTree < any >::Add (any data)//добавление элементов
{
  Node < any > *new_node = new Node < any > (data);
  Node < any > *current;
  if (IsExist == false)
    {
      root = new_node;
      NodeCount++;
      IsExist = true;
      return;
    }
  else
    {
      current = root;
      while (true)
    {
      if (data > current->data)
        {
          if (current->point_right != nullptr)
        {
          current = current->point_right;
        }
          else
        {
          current->point_right = new_node;
          NodeCount++;
          return;
        }
        }
      else if (data < current->data)
        {
          if (current->point_left != nullptr)
        {
          current = current->point_left;
        }
          else
        {
          current->point_left = new_node;
          NodeCount++;
          return;
        }
        }
      else
        {
          current->data = current->data + data;
          break;
        }
    }
      return;
    }
}
 
template < class any >
  BinaryTree < any >::Node < any > *BinaryTree < any >::Find (any f_data,
                                  BinaryTree <
                                  any >::Node <
                                  any >
                                  *f_root_node)
{
  Node < any > *root_node = f_root_node;
  if (root_node != nullptr && f_data < root_node->data)
    {
      if (root_node->point_left != nullptr)
    {
      if (root_node->point_left->data == f_data)
        {
          return root_node->point_left;
        }
      else
        {
          root_node = root_node->point_left;
          return Find (f_data, root_node);
        }
    }
    }
  else if (root_node->data == f_data)
    {
      return root_node;
    }
  else if (root_node->point_right != nullptr)
    {
      if (root_node->point_right->data == f_data)
    {
      return root_node->point_right;
    }
      else
    {
      root_node = root_node->point_right;
      return Find (f_data, root_node);
    }
    }
  else
    {
      return nullptr;
    }
}
 
template < class any > any BinaryTree < any >::GetElement (Node < any > *obj)
{
  return obj->data;
}
 
template < class any > void BinaryTree < any >::Edit (any data, any data_edit)
{
  Find (data, Get_Root ())->data = data_edit;
}
 
template < class any > any * BinaryTree < any >::FindAll ()
{
  Node < any > *current, *pre;
  any *arr = new any[NodeCount];
  if (root == nullptr)
    return nullptr;
  current = root;
  int i = 0;
  while (current != nullptr)
    {
      if (current->point_left == nullptr)
    {
      arr[i] = current->data;
      i++;
      current = current->point_right;
    }
      else
    {
      pre = current->point_left;
      while (pre->point_right != nullptr && pre->point_right != current)
        {
          pre = pre->point_right;
        }
      if (pre->point_right == nullptr)
        {
          pre->point_right = current;
          current = current->point_left;
        }
      else
        {
          pre->point_right = nullptr;
          arr[i] = current->data;
          i++;
          current = current->point_right;
        }
    }
    }
  return arr;
}
 
template < class any >
  void BinaryTree < any >::Print (Node < any > *root_node)
{
  if (root_node == nullptr)
    {
      return;
    }
  Print (root_node->point_left);
  cout << root_node->data;
  Print (root_node->point_right);
}
 
class Police
{
private:
  int CarsCount;
  struct Cars
  {
    unsigned long long int number = 0;
    string *Violations = nullptr;
    int ViolationCount = 0;
    int number_lenght = 0;
  } CarsViolations;
    BinaryTree < Cars > lst;
  string *split (const string & s, char separator);
  int split_counter (const string & s, char separator);
public:
    Police ();
  //Police(int C_Count, string* number, int* V_Count, string** Violatios);
  void AddCar (string number, string Violations, char v_sep = ';');
  void Print ()
  {
    lst.Print (lst.Get_Root ());
  }
  Cars GetCar (string number);
  Cars *GetCarsByViolation (string Violations, char v_sep = ';');
  Cars *GetCarsByDiapason (string number_low, string number_high);
  unsigned long long int convert_to_code (string number);
  void Test ();
  friend ostream & operator<< (ostream & out, Cars obj);
  friend bool operator== (Cars obj1, Cars obj2);
  friend bool operator> (unsigned long long int number, Cars obj1)
  {
    return obj1.number > number;
  }
  friend bool operator> (Cars obj1, Cars obj2)
  {
    return obj1.number > obj2.number;
  }
  friend bool operator< (Cars obj1, Cars obj2)
  {
    return obj1.number < obj2.number;
  }
  friend bool operator< (Cars obj1, unsigned long long int number)
  {
    return obj1.number < number;
  }
  friend bool operator!= (Cars obj1, Cars obj2)
  {
    return obj1.number != obj2.number;
  }
  friend Police::Cars & operator+ (Cars obj1, Cars obj2);
};
 
string *
Police::split (const string & s, char separator)
{
  if (split_counter (s, separator) == 0)
    {
      string *result = new string[1];
      result[0] = s;
      return result;
    }
  string *result = new string[split_counter (s, separator)];
  stringstream ss (s);
  string item;
  int count = 0;
  while (getline (ss, item, separator))
    {
      result[count] = item;
      count++;
    }
  return result;
}
 
int
Police::split_counter (const string & s, char separator)
{
  int count = 0;
  for (int i = 0; i < s.length (); i++)
    {
      if (s[i] == separator)
    {
      count++;
    }
    }
  return count;
}
 
Police::Police ()
{
  CarsCount = 0;
}
 
//Police::Police(int C_Count, string* number, int* V_Count, string** Violatios)
//{
// Size = C_Count;
// CarsViolations = new Cars[C_Count];
// for (int i = 0; i < C_Count; i++) {
// int power = 14;
// for (int j = 0; j < number[i].length(); j++) {
// CarsViolations[i].number += number[i][j] * pow(10, power);
// power-=2;
// }
// CarsViolations[i].ViolationCount = V_Count[i];
// CarsViolations[i].Violations = Violatios[i];
// }
//}
void
Police::AddCar (string number, string Violations, char v_sep)
{
  CarsViolations.number = 0;
  int power = number.length () * 2 - 2;
  CarsViolations.number_lenght = number.length ();
  for (int i = 0; i < CarsViolations.number_lenght; i++)
    {
      CarsViolations.number += number[i] * pow (10, power);
      power -= 2;
    }
  CarsViolations.Violations = split (Violations, v_sep);
  CarsViolations.ViolationCount = split_counter (Violations, v_sep);
  CarsCount++;
  lst.Add (CarsViolations);
}
 
Police::Cars Police::GetCar (string s_number)
{
  Cars
    buf;
  int
    power = s_number.length () * 2 - 2;
  for (int i = 0; i < s_number.length (); i++)
    {
      buf.number += s_number[i] * pow (10, power);
      power -= 2;
    }
  return lst.GetElement (lst.Find (buf, lst.Get_Root ()));
 
}
 
Police::Cars * Police::GetCarsByViolation (string Violations, char v_sep)
{
  Cars
    Viol;
  Viol.Violations = split (Violations, v_sep);
  Viol.ViolationCount = split_counter (Violations, v_sep);
  Cars *
    obj = lst.FindAll ();
  for (int i = 0; i < lst.GetNodeCount (); i++)
    {
      if (obj[i] == Viol)
    {
      cout << obj[i];
    }
    }
  return obj;
}
 
Police::Cars * Police::GetCarsByDiapason (string number_low,
                      string number_high)
{
  Cars
    AllCars;
  Cars *
    obj = lst.FindAll ();
  unsigned long long int
    n_low = convert_to_code (number_low), n_high =
    convert_to_code (number_high);
  for (int i = 0; i < lst.GetNodeCount (); i++)
    {
      if (n_low > obj[i] && obj[i] < n_high)
    {
      cout << obj[i];
    }
    }
  return obj;
}
 
unsigned long long int
Police::convert_to_code (string s_number)
{
  unsigned long long int number = 0;
  int power = s_number.length () * 2 - 2;
  for (int i = 0; i < s_number.length (); i++)
    {
      number += s_number[i] * pow (10, power);
      power -= 2;
    }
  return number;
}
 
void
Police::Test ()
{
  cout << endl << "PP>P;P8QP5Q
QP2P> QP7P;P>P2:" << endl;
  cout << lst.GetNodeCount () << endl;
}
 
ostream & operator<< (ostream & out, Police::Cars obj)
{
  string str_buf = "", str_num = "", str1 = to_string (obj.number);
 
  out << "PP>P4 QQQ