【二叉树】

烦死人的g++系列，root会自动初始化为野指针？

#include <iostream>
#include <iostream>
#include <vector>
#include <queue>
#include <stack>

#define EMPTY_ELE '#'

class BinaryTree {
public:
    struct Node {
        char val;
        Node* left;
        Node* right;
        Node(char v, Node* l = NULL, Node* r = NULL):
        val(v), left(l), right(r) {
        }
    };
    BinaryTree(const BinaryTree&);
    BinaryTree(std::vector<char>&);
    // created by preorder and inorder
    BinaryTree(const std::vector<char>& preOrder,
               const std::vector<char>& inOrder);
    ~BinaryTree();
    BinaryTree& operator=(const BinaryTree&);
    Node* getRoot() const;
    void clear();
    
    static void preOrder(void (*visite)(BinaryTree::Node*), Node*);
    static void inOrder(void (*visite)(BinaryTree::Node*), Node*);
    static void postOrder(void (*visite)(BinaryTree::Node*), Node*);
    
    
private:
    Node * copyNode(Node * oldNode, Node * newNode);
    
    Node * root;
};

BinaryTree::Node* BinaryTree::copyNode(Node * oldNode, Node * newNode) {
    if (oldNode == NULL) return newNode = NULL;
    if (oldNode->left != NULL) {
        newNode->left = new Node(oldNode->left->val);
        copyNode(oldNode->left, newNode->left);
    }
    if (oldNode->right != NULL) {
        newNode->right = new Node(oldNode->right->val);
        copyNode(oldNode->right, newNode->right);
    }
    return newNode;
}

BinaryTree::BinaryTree(const BinaryTree& a) {
    if (a.root == NULL) return;
    root = new Node(a.root->val);
    if (a.root->left != NULL) {
        root->left = new Node(a.root->left->val);
        copyNode(a.root->left, root->left);
    }
    if (a.root->right != NULL) {
        root->right = new Node(a.root->right->val);
        copyNode(a.root->right, root->right);
    }
}

BinaryTree::BinaryTree(std::vector<char>& v) {
    if (v.empty()) { root = NULL; return; }
    std::queue<BinaryTree::Node**> q;
    q.push(&root);
    for (int i = 0; q.size() && i < v.size(); ++ i) {
        if (v[i] != '#') {
            *q.front() = new Node(v[i]);
            q.push(&(*q.front())->left);
            q.push(&(*q.front())->right);
        }
        q.pop();
    }
    return;
}

void build(BinaryTree::Node *rt, int L, int R, int l, int r,
           const std::vector<char>& preOrder, const std::vector<char>& inOrder) {
    int mid = L;
    for (int i = L; i < R; ++ i) if (inOrder[i] == rt->val) {
        mid = i; break;
    }
    
    int leftN = mid - L, rightN = R - mid - 1;
    if (leftN) {
        rt->left = new BinaryTree::Node(preOrder[l + 1]);
        build(rt->left, L, mid, l + 1, l + 1 + leftN, preOrder, inOrder);
    }
    if (rightN) {
        rt->right = new BinaryTree::Node(preOrder[l + 1 + leftN]);
        build(rt->right, mid + 1, R, l + 1 + leftN, r, preOrder, inOrder);
    }
    
}

BinaryTree::BinaryTree(const std::vector<char>& preOrder, const std::vector<char>& inOrder) {
    if (preOrder.empty()) return;
    root = new Node(preOrder[0]);
    build(root, 0, (int)preOrder.size(), 0, (int)preOrder.size(), preOrder, inOrder);
}

void del(BinaryTree::Node* &p) {
    if (p == NULL) return;
    del(p->left); del(p->right);
    delete p;
}

BinaryTree::~BinaryTree() {
    if (root == NULL) return;
    if (root->left != NULL) del(root->left);
    if (root->right != NULL) del(root->right);
    delete root; root = NULL;
}

BinaryTree& BinaryTree::operator=(const BinaryTree& a) {
    if (this == &a) return *this;
    if (this->root != NULL) clear();
    if (a.root == NULL) return *this;
    root = new Node(a.root->val);
    if (a.root->left != NULL) {
        root->left = new Node(a.root->left->val);
        copyNode(a.root->left, root->left);
    }
    if (a.root->right != NULL) {
        root->right = new Node(a.root->right->val);
        copyNode(a.root->right, root->right);
    }
    return *this;
}

BinaryTree::Node* BinaryTree::getRoot() const {
    return root;
}

void BinaryTree::clear() {
    if (root == NULL) return;
    del(root); root = NULL;
}

void BinaryTree::preOrder(void (*visite)(BinaryTree::Node*), Node* p) {
    if (p == NULL) return;
    visite(p);
    preOrder(visite, p->left);
    preOrder(visite, p->right);
}

void BinaryTree::inOrder(void (*visite)(BinaryTree::Node *), Node * p) {
    if (p == NULL) return;
    inOrder(visite, p->left);
    visite(p);
    inOrder(visite, p->right);
    
}
void BinaryTree::postOrder(void (*visite)(BinaryTree::Node *), Node * p) {
    if (p == NULL) return;
    postOrder(visite, p->left);
    postOrder(visite, p->right);
    visite(p);
}

using namespace std;

void print(BinaryTree::Node * temp) {
    cout << temp->val << " ";
}

std::vector<char> pre;
std::vector<char> in;

void getPreOrder(BinaryTree::Node * temp) {
    pre.push_back(temp->val);
}

void getInOrder(BinaryTree::Node * temp) {
    in.push_back(temp->val);
}

void testTree() {
    cout << "test Tree" << endl;
    int n = 1;
    std::vector<char> tree;
    cin >> n;
    while (n--) {
        char temp = '\0';
        cin >> temp;
        tree.push_back(temp);
    }
    BinaryTree x = BinaryTree(tree);
    x = x;
    BinaryTree::preOrder(print, x.getRoot());
    cout << endl;
    BinaryTree::inOrder(print, x.getRoot());
    cout << endl;
    BinaryTree::postOrder(print, x.getRoot());
    cout << endl;
    
    BinaryTree::preOrder(getPreOrder, x.getRoot());
    BinaryTree::inOrder(getInOrder, x.getRoot());
    
    BinaryTree t = BinaryTree(pre, in);
    t = t;
    BinaryTree::postOrder(print, t.getRoot());
    cout << endl;
    
    BinaryTree y = BinaryTree(t);
    y = y;
    BinaryTree::preOrder(print, y.getRoot());
    cout << endl;
    BinaryTree::inOrder(print, y.getRoot());
    cout << endl;
    BinaryTree::postOrder(print, y.getRoot());
    
    BinaryTree::preOrder(getPreOrder, y.getRoot());
    BinaryTree::inOrder(getInOrder, y.getRoot());
}

int main() {
    testTree();
}

class RHTree {
public:
    struct Node {
        Node *lc, *rc;
        int val;
        Node(int v = 0, Node* left = nullptr, Node* right = nullptr) : val(v), lc(left), rc(right) {}
    };
    RHTree();
    ~RHTree();
    void insert(int x);
    Node* getRoot();
    void inOrder(Node *p);
    void preOrder(Node *p);
    void postOrder(Node *p);
private:
    Node *root;
    void del(Node *p);
    void add(Node* &p, const int &x);
};

RHTree::RHTree() {
    root = nullptr;
}

void RHTree::del(Node *p) {
    if (p == nullptr) return;
    del(p->lc); del(p->rc);
    delete(p);
}

RHTree::~RHTree() {
    del(root);
}

void RHTree::add(Node* &p, const int &x) {
    if (p == nullptr) {
        p = new Node(x);
        return;
    }
    if (x <= p->val) add(p->lc, x);
    else add(p->rc, x);
}

void RHTree::insert(int x) {
    if (root == nullptr) {
        root = new Node(x);
        return;
    }
    add(root, x);
}

RHTree::Node* RHTree::getRoot() {
    return root;
}

#include <cstdio>
void RHTree::inOrder(Node *p) {
    if (p == nullptr) return;
    inOrder(p->lc);
    printf(" %d", p->val);
    inOrder(p->rc);
}

void RHTree::preOrder(Node *p) {
    if (p == nullptr) return;
    printf(" %d", p->val);
    preOrder(p->lc);
    preOrder(p->rc);
}

void RHTree::postOrder(Node *p) {
    if (p == nullptr) return;
    postOrder(p->lc);
    postOrder(p->rc);
    printf(" %d", p->val);
}

#include <iostream>

int main() {
    int count;
    std::cin >> count;
    int x;
    RHTree tree;
    while (count--) {
        std::cin >> x;
        tree.insert(x);
    }
    
    std::cout << "Inorder:";
    tree.inOrder(tree.getRoot());
    std::cout << std::endl;
    std::cout << "Preorder:";
    tree.preOrder(tree.getRoot());
    std::cout << std::endl;
    std::cout << "Postorder:";
    tree.postOrder(tree.getRoot());
    std::cout << std::endl;
    return 0;
}