172 lines
3.7 KiB
C++
172 lines
3.7 KiB
C++
#include <iostream>
|
|
#include <vector>
|
|
#include <string>
|
|
#include <deque>
|
|
#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;
|
|
deque<Node<T>*> level;
|
|
|
|
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] == '#') {
|
|
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;
|
|
}
|
|
|
|
void flatten(){
|
|
level.push_back(root);
|
|
while(!level.empty()){
|
|
int floor = level.size();
|
|
int tmp = floor;
|
|
int cnt = 0;
|
|
int js = 0;
|
|
while(tmp--){
|
|
cnt = 0;
|
|
auto head = level.begin();
|
|
auto node = *head;
|
|
if(node->left) {
|
|
level.push_back(node->left);
|
|
cnt++;
|
|
}
|
|
if(node->right) {
|
|
level.push_back(node->right);
|
|
cnt++;
|
|
}
|
|
level.pop_front();
|
|
|
|
if(cnt == 1){
|
|
js++;
|
|
}
|
|
}
|
|
|
|
cout << js << endl;
|
|
}
|
|
}
|
|
};
|
|
|
|
int main() {
|
|
int x = 0;
|
|
vector<char> arr;
|
|
string line;
|
|
getline(cin, line);
|
|
stringstream ss(line);
|
|
char num;
|
|
|
|
while (ss >> num) {
|
|
arr.push_back(num);
|
|
}
|
|
BinTree<char> tree(arr);
|
|
tree.buildTree();
|
|
|
|
tree.flatten();
|
|
return 0;
|
|
} |