烦死人的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;
}