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<string>
#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)
        //binaryTree()
    {
        sz = 0;
        curr = top;
        sz++;
        top->data = data;
    }

    binaryNode<T>* operator[](size_t num) {
        if (num == 1)return top;
        vector<size_t>s = getvec(num);
        binaryNode<T>* cp = curr;
        for (int i = static_cast<int>(s.size() - 1); i >= 0; --i) {
            if (s[i] && cp->rson)
                cp = cp->rson;
            else if (!s[i] && cp->lson)
                cp = cp->lson;
            else return nullptr;
        }
        return cp;
    }

    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;
    }

    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;
    }


    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; }



private:
    size_t sz;
    size_t hi = top->height();
};
int main() {
    binaryTree<char>s('i');
    s.insertls(1, getNode('d'));
    s.insertrs(1, getNode('l'));
    s.insertls(2, getNode('c'));
    s.insertrs(2, getNode('h'));
    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.inorder_traverse(s.top);
}