152 lines
3.4 KiB
C++
152 lines
3.4 KiB
C++
#include <iostream>
|
|
#include <vector>
|
|
#include <string>
|
|
#include <sstream>
|
|
using namespace std;
|
|
|
|
template <class T>
|
|
struct Node {
|
|
T element;
|
|
Node<T>* left;
|
|
Node<T>* right;
|
|
Node<T>* parent;
|
|
|
|
Node(const T& e, Node<T>* p) : element(e), parent(p), left(nullptr), right(nullptr) {}
|
|
};
|
|
|
|
template <class T>
|
|
class BinTree {
|
|
public:
|
|
Node<T>* root;
|
|
int height;
|
|
vector<T> arr;
|
|
|
|
BinTree() : root(nullptr), height(0) {}
|
|
BinTree(const vector<T>& arrs) : arr(arrs), height(0) {}
|
|
void test() {
|
|
for (auto x : arr) {
|
|
cout << x << " ";
|
|
}
|
|
}
|
|
Node<T>* returnroot() {
|
|
return this->root;
|
|
}
|
|
|
|
Node<T>* build(int& index, Node<T>* parent) {
|
|
if (index >= arr.size() || arr[index] == 0) {
|
|
index++;
|
|
return nullptr;
|
|
}
|
|
|
|
Node<T>* node = new Node<T>(arr[index], parent);
|
|
index++;
|
|
node->left = build(index, node);
|
|
node->right = build(index, node);
|
|
|
|
return node;
|
|
}
|
|
|
|
void buildTree() {
|
|
int index = 0;
|
|
this->root = build(index, nullptr);
|
|
}
|
|
|
|
//Êä³ö
|
|
void preorder(Node<T>* node) {
|
|
if (node == nullptr) return;
|
|
|
|
cout << node->element << " ";
|
|
preorder(node->left);
|
|
preorder(node->right);
|
|
}
|
|
void inorder(Node<T>* node) {
|
|
if (node == nullptr) return;
|
|
|
|
inorder(node->left);
|
|
cout << node->element << " ";
|
|
//cout << ( node->parent == nullptr ? 0 : node->parent->element) << endl;
|
|
inorder(node->right);
|
|
}
|
|
void postorder(Node<T>* node) {
|
|
if (node == nullptr) return;
|
|
|
|
postorder(node->left);
|
|
postorder(node->right);
|
|
cout << node->element << " ";
|
|
}
|
|
Node<T>* inorder2(Node<T>* node, const T& x) {
|
|
if (node == nullptr) return nullptr;
|
|
|
|
if (node->element == x) {
|
|
return node;
|
|
}
|
|
|
|
Node<T>* leftResult = inorder2(node->left, x);
|
|
if (leftResult != nullptr) {
|
|
return leftResult;
|
|
}
|
|
|
|
Node<T>* rightResult = inorder2(node->right, x);
|
|
return rightResult;
|
|
}
|
|
void findparent(const T& e) {
|
|
auto x = inorder2(this->root, e);
|
|
if (x == nullptr || x->parent == nullptr) cout << 0 << endl;
|
|
else cout << x->parent->element << endl;
|
|
}
|
|
void deletesub(Node<T>* node) {
|
|
if (node == nullptr) return;
|
|
deletesub(node->left);
|
|
deletesub(node->right);
|
|
delete node;
|
|
}
|
|
|
|
bool deletenode(const T& e) {
|
|
auto x = inorder2(this->root, e);
|
|
if (x == nullptr) return false;
|
|
|
|
if (x == this->root) {
|
|
deletesub(x);
|
|
this->root = nullptr;
|
|
return true;
|
|
}
|
|
|
|
if (x->parent->left == x) {
|
|
x->parent->left = nullptr;
|
|
} else {
|
|
x->parent->right = nullptr;
|
|
}
|
|
deletesub(x);
|
|
return true;
|
|
}
|
|
};
|
|
|
|
int main() {
|
|
int x = 0;
|
|
vector<int> arr;
|
|
string line;
|
|
getline(cin, line);
|
|
stringstream ss(line);
|
|
int num;
|
|
|
|
while (ss >> num) {
|
|
arr.push_back(num);
|
|
}
|
|
BinTree<int> tree(arr);
|
|
tree.buildTree();
|
|
|
|
int m;
|
|
cin >> m;
|
|
for (int i = 0; i < m; i++) {
|
|
int t;
|
|
cin >> t;
|
|
bool flag = tree.deletenode(t);
|
|
if (flag) {
|
|
tree.inorder(tree.root);
|
|
cout << endl;
|
|
}
|
|
else cout << "0" << endl;
|
|
}
|
|
return 0;
|
|
}
|