c++ Посчитать количество элементов в левой половине двоичного дерева

Необходимо подсчитать количество элементов, находящихся в левой половине двоичного дерева. Помогите пожалуйста составить для этого функцию tree_count() внутри структуры Tree. Скорее всего тут не обойтись без рекурсии. Код:

#include <iostream>
using namespace std;

struct Node
{
    int data;
    Node* left, * right;
    Node(int N)
    {
        data = N;
        left = right = 0;
    }
    void print()
    {
        cout << data << ' ';
    }
};
struct Tree
{
    Node* root;
    Tree() : root(0) {}
    void insert(int N)
    {
        Node* newNode = new Node(N);
        if (!root)
        {
            root = newNode;
            return;
        }
        Node* current = root;
        Node* parent;
        while (true)
        {
            parent = current;
            if (N < current->data)
            {
                current = current->left;
                if (!current)
                {
                    parent->left = newNode;
                    return;
                }
            }
            else
            {
                current = current->right;
                if (!current)
                {
                    parent->right = newNode;
                    return;
                }
            }
        }
    }
    bool find(int N)
    {
        Node* current = root;
        while (current != 0)
        {
            if (N == current->data)return true;
            current = N < current->data ? current->left : current->right;
        }
        return false;
    }
    void recprint(Node* n)
    {
        if (!n)return;
        recprint(n->left);
        n->print();
        recprint(n->right);
    }
    void print()
    {
        recprint(root);
        cout << endl;
    }
    Node* getSuccessor(Node* del)
    {
        Node* successor = del, * parent = del, * current = del->right;
        while (current != 0)
        {
            parent = successor;
            successor = current;
            current = current->left;
        }
        if (successor != del->right)
        {
            parent->left = successor->right;
            successor->right = del->right;
        }
        return successor;
    }
    bool erase(int N)
    {
        Node* current = root;
        Node* parent = root;
        bool isLeft;
        while (current->data != N)
        {
            parent = current;
            if (N < current->data)
            {
                current = current->left;
                isLeft = true;
            }
            else
            {
                current = current->right;
                isLeft = false;
            }
            if (!current)return false;
        }
        if (!current->left && !current->right)
        {
            if (current == root)root = 0;
            else if (isLeft)parent->left = 0;
            else parent->right = 0;
        }
        else if (!current->right)
        {
            if (current == root)root = current->left;
            else if (isLeft)parent->left = current->left;
            else parent->right = current->left;
        }
        else if (!current->left)
        {
            if (current == root)root = current->right;
            else if (isLeft)parent->left = current->right;
            else parent->right = current->right;
        }
        else
        {
            Node* successor = getSuccessor(current);
            if (current == root)root = successor;
            else if (isLeft)parent->left = successor;
            else parent->right = successor;
            successor->left = current->left;
        }
        delete current;
        return true;
    }
    bool isEmpty()
    {
        return !root;
    }

    int tree_count() {}

};




void main()
{
    int a;
    Tree t;
    for (int i = 0; i < 9; i++)t.insert(rand() % 33);
    t.print();
    a = t.tree_count(t.root);
    cout << a;


}