c++二叉树

#pragma once
template<class T>struct binaryNode {
    binaryNode() = default;
    binaryNode(T data, binaryNode<T>* father = NULL, binaryNode<T>* lson = NULL, binaryNode<T>* rson = NULL) :
        father(father), lson(lson), rson(rson), data(data) {}
    binaryNode<T>* father;
    binaryNode<T>* lson;
    binaryNode<T>* rson;
    T data;
    size_t height() {
        size_t height = 1;
        if (lson == NULL && rson == NULL);
        else
            height++;
        return height;
    }
    size_t size() {
        size_t sz = 1;
        lson == NULL ? sz : sz++;
        rson == NULL ? sz : sz++;
        return sz;
    };
    auto insertls(T data) {
        return lson = new binaryNode<T>(data, this);
    }
    auto insertrs(T data) {
        return rson = new binaryNode<T>(data, this);
    }
    auto remove() {
        delete rson;
        delete lson;
        delete this;
    }
    bool operator<(const binaryNode<T>* node) { return node->data < data ? true : false; }
    bool operator>(const binaryNode<T>* node) { return !(node < this); }
    bool operator==(const binaryNode<T>* node) { return data == node->data; }

};

#include <iostream>
#include<queue>
#include<binaryTree.hpp>
#include<vector>
#include<cassert>


using namespace std;

template<class T>binaryNode<T>* getNode(T num)
{
    return new binaryNode<T>(num);

};

vector<size_t> getvec(size_t num) {
    vector<size_t>s;
    while (num > 1) {
        s.push_back(num % 2);
        num /= 2;
    }
    return s;
}

template<class T>class binaryTree {
public:

    binaryNode<T>* top = nullptr, * curr;

    binaryTree() = default;

    binaryTree(T data, binaryNode<T>* node = new binaryNode<T>()) :top(node)
    {
        sz = 0;
        curr = top;
        sz++;
        top->data = data;
        que.push(top);
        vec.push_back(0);
        vec.push_back(top);
    }

    binaryNode<T>* operator[](size_t num) {
        if (num == 1)return top;
        else
        {
            return vec[num];
        }
        
    
    }

    size_t size() const { return sz; }

    size_t height()const {
        return hi;
    }

    void insertls(int num, T data) { insertls(num, new binaryNode<T>(data)); }

    void insertrs(int num, T data) { insertrs(num, new binaryNode<T>(data)); }

    void insertls(int num, binaryNode<T>* node) {
        binaryNode<T>* get = this->operator[](num);
        assert(get != nullptr);
        if (get->rson == NULL)hi++;
        sz += node->size();
        get->lson = node;
        vec.push_back(get->lson);
    }

    void insertrs(int num, binaryNode<T>*node) {
        binaryNode<T>* get = this->operator[](num);
        assert(get != nullptr);
        if (get->lson == NULL)hi++;
        sz += node->size();
        get->rson = node;
        vec.push_back(get->rson);
    }


    void insertaslstree(int num, const binaryTree<T>& tree) {
        sz += tree.size() - tree.top->size();
        insertls(num, tree.top);
        hi--;
        hi += tree.height();
    }

    void insertasrstree(int num, const binaryTree<T>& tree) {
        sz += tree.size() - tree.top->size();

        insertrs(num, tree.top);
        hi--;
        hi += tree.height();
    }
    auto root() { return top; }

    void preorder_traverse(binaryNode<T>*node) {
        if (!node)return;
        cout << node->data<<" ";
        preorder_traverse(node->lson);
        preorder_traverse(node->rson);
    }

    void inorder_traverse(binaryNode<T>* node) {
        if (!node)return;
        inorder_traverse(node->lson);
        cout << node->data << " ";
        inorder_traverse(node->rson);
    }

    void postorder_traverse(binaryNode<T>* node) {
        if (!node)return;
        postorder_traverse(node->lson);
        postorder_traverse(node->rson);
        cout << node->data << " ";
    }

    void remove(int num) {
        binaryNode<T>* get = this->operator[](num);
        binaryNode<T>* father = this->operator[](num / 2);
        if (get->lson || get->rson)
        {
            cout << "不允许remove" << endl;
        }
        else {
            if (father->lson && father->rson);
            else hi--;
            sz--;
            get->remove();
        }
    }

    bool empty() { return top == nullptr ? true : false; }

    void traverse_level() {
        if (!que.empty()) {
            binaryNode<T>* node = que.front();
            cout << que.front()->data<<" ";
            que.pop();
            if (!node)
                return;
            if (node->lson)
                que.push(node->lson);
            if (node->rson)
                que.push(node->rson);
            traverse_level();
        }
    }


private:
    size_t sz;
    size_t hi = top->height();
    queue<binaryNode<T>*>que;
    vector<binaryNode<T>*>vec;
    
};
int main() {
    
    binaryTree<char>s('i');
    s.insertls(1, getNode('d'));
    s.insertls(2, getNode('c'));
    s.insertls(3, getNode('a'));
    s.insertrs(4, getNode('b'));
    s.insertrs(2, getNode('h'));
    s.insertls(6, getNode('f'));
    s.insertls(7, getNode('e'));
    s.insertrs(7, getNode('g'));
    s.insertrs(1, getNode('l'));
    s.insertls(10, getNode('k'));
    s.insertrs(10, getNode('n'));
    s.insertls(11, getNode('j'));
    s.insertls(12, getNode('m'));
    s.insertrs(12, getNode('p'));
    s.insertrs(15, getNode('o'));
    /*s.insertls(4, getNode('a'));
    s.insertrs(8, getNode('b'));
    s.insertls(5, getNode('f'));
    s.insertls(10, getNode('e'));
    s.insertrs(10, getNode('g'));
    s.insertls(3, getNode('k'));
    s.insertls(6, getNode('j'));
    s.insertrs(3, getNode('n'));
    s.insertrs(7, getNode('p'));
    s.insertls(7, getNode('m'));
    s.insertls(15, getNode('o'));*/
    //cout << s.size();
    //cout << s[18]->data;
    //cout << "size:" << s.size();
    //s.traverse_level();
    s.preorder_traverse(s.top);
    cout << s.size();
}