Сформировать бинарное дерево, посчитать количество листьев

int getTreeSize(node*root){
  if (!root) return 0;
  return getTreeSize(root->left)+getTreeSize(root->right);
}

#include <iostream>
#include <cstdlib>
 
using namespace std;
 
template<typename Type>
class node {
    public:
        Type key;
        
        unsigned int size, height;
        
        node<Type> *left, *right;
        
        node() {
            size = 0;
            height = 0;
        }
        
        node(Type val) {
            key = val;
            size = 1;
            height = 1;
        }
        
        void add(const Type& val) {
            if (size == 0) {
                key = val;
                size++;
                height++;
                left = new node<Type>();
                right = new node<Type>();
            } else {
                if (val < key)
                    left->add(val);
                else
                    if (val > key)
                        right->add(val);
                height = max(left->height, right->height) + 1;
                size = left->size + right->size + 1;
            }
        }
 
        Type kth(unsigned int k) {
            if (left->size > k)
                return left->kth(k);
            if (left->size == k)
                return key;
            return right->kth(k - left->size - 1);
        }
 
        void dfs(void f(node<Type>*)) {
            if (left->size) {
                f(left);
                left->dfs(f);
            }
            if (right->size) {
                f(right);
                right->dfs(f);
            }
        }
};
 
template<typename Type>
class binary_search_tree {
    public:
        binary_search_tree() {
            root = new node<Type>();
        }
        
        void add(const Type& val) {
            root->add(val);
        }
        
        unsigned int height() {
            return root->height;
        }
        
        unsigned int size() {
            return root->size;
        }
        
        Type kth(unsigned int k) {
            if (root->size)
                return root->kth(k);
            else {
                cerr << "can't execute kth for an empty tree\n";
                exit(-1);
            }
        }
 
        void dfs(void f(node<Type>*)) {
            if (root->size) {
                f(root);
                root->dfs(f);
            }
        }
 
    private:
        node<Type> *root;
};
 
template<typename Type>
void f(node<Type>* v) {
    if (v->left->size == 0 && v->right->size == 0)
        cout << v->key << " ";
}
 
int main() {
    binary_search_tree<int> BST;
    while (true) {
        int buf;
        cin >> buf;
        if (buf == 0)
            break;
        BST.add(buf);
    }
    BST.dfs(f);
    cout << endl;
    return 0;
}

#include <conio.h>

getch();
return 0;