upload
This commit is contained in:
commit
810a9654a4
GPG key ID:
B97F30FDC4636357
50 changed files with 4450 additions and 0 deletions
144
5/A.cpp
Normal file
144
5/A.cpp
Normal file
|
|
@ -0,0 +1,144 @@
|
|||
#include <iostream>
|
||||
#include <vector>
|
||||
#include <cstddef>
|
||||
|
||||
template<typename T>
|
||||
struct Node {
|
||||
Node<T>* left_child = nullptr;
|
||||
Node<T>* right_child = nullptr;
|
||||
T value;
|
||||
|
||||
Node(T value) : value(value){};
|
||||
|
||||
bool operator==(T rhs) {
|
||||
return value == rhs;
|
||||
}
|
||||
|
||||
bool operator<(T rhs) {
|
||||
return value < rhs;
|
||||
}
|
||||
|
||||
bool operator>(T rhs) {
|
||||
return value > rhs;
|
||||
}
|
||||
|
||||
bool operator<=(T rhs) {
|
||||
return (*this < rhs) || (*this == rhs);
|
||||
}
|
||||
|
||||
bool operator>=(T rhs) {
|
||||
return (*this > rhs) || (*this == rhs);
|
||||
}
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
class BinarySearchTree {
|
||||
public:
|
||||
void PreorderTraversal() {
|
||||
if (!root) {
|
||||
return;
|
||||
}
|
||||
PreorderTraversal(root);
|
||||
}
|
||||
|
||||
void InorderTraversal() {
|
||||
if (!root) {
|
||||
return;
|
||||
}
|
||||
InorderTraversal(root);
|
||||
}
|
||||
|
||||
void PostorderTraversal() {
|
||||
if (!root) {
|
||||
return;
|
||||
}
|
||||
PostorderTraversal(root);
|
||||
}
|
||||
|
||||
void AddChild(T value) {
|
||||
if (!root) {
|
||||
root = new Node(value);
|
||||
return;
|
||||
}
|
||||
AddChild(root, value);
|
||||
}
|
||||
|
||||
void Construct(const std::vector<T>& array) {
|
||||
root = Construct(array, 0, array.size() - 1);
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
Node<T>* AddChild(Node<T>* node, T value) {
|
||||
if (!node) return new Node(value);
|
||||
|
||||
if (*node < value) {
|
||||
node->left_child = AddChild(node->left_child, value);
|
||||
} else if (*node >= value) {
|
||||
node->right_child = AddChild(node->right_child, value);
|
||||
}
|
||||
|
||||
return node;
|
||||
}
|
||||
|
||||
void PreorderTraversal(Node<T>* node) {
|
||||
if (!node) {
|
||||
return;
|
||||
}
|
||||
std::cout << node->value << ' ';
|
||||
PreorderTraversal(node->left_child);
|
||||
PreorderTraversal(node->right_child);
|
||||
}
|
||||
|
||||
void InorderTraversal(Node<T>* node) {
|
||||
if (!node) {
|
||||
return;
|
||||
}
|
||||
InorderTraversal(node->left_child);
|
||||
std::cout << node->value << ' ';
|
||||
InorderTraversal(node->right_child);
|
||||
}
|
||||
|
||||
void PostorderTraversal(Node<T>* node) {
|
||||
if (!node) {
|
||||
return;
|
||||
}
|
||||
PostorderTraversal(node->left_child);
|
||||
PostorderTraversal(node->right_child);
|
||||
std::cout << node->value << ' ';
|
||||
}
|
||||
|
||||
Node<T>* Construct(const std::vector<T>& array, long long start, long long end) {
|
||||
if (start > end)
|
||||
return nullptr;
|
||||
|
||||
size_t mid = (start + end) / 2;
|
||||
Node<T>* node = new Node<T>(array[mid]);
|
||||
|
||||
node->left_child = Construct(array, start, mid - 1);
|
||||
node->right_child = Construct(array, mid + 1, end);
|
||||
|
||||
return node;
|
||||
}
|
||||
|
||||
private:
|
||||
Node<T>* root = nullptr;
|
||||
};
|
||||
|
||||
int main() {
|
||||
BinarySearchTree<int> bst;
|
||||
int n;
|
||||
std::cin >> n;
|
||||
|
||||
std::vector<int> arr;
|
||||
arr.reserve(n);
|
||||
|
||||
for (int i = 0; i < n; ++i) {
|
||||
int tmp;
|
||||
std::cin >> tmp;
|
||||
arr.push_back(tmp);
|
||||
}
|
||||
|
||||
bst.Construct(arr);
|
||||
bst.PreorderTraversal();
|
||||
}
|
||||
276
5/B.cpp
Normal file
276
5/B.cpp
Normal file
|
|
@ -0,0 +1,276 @@
|
|||
#include <cstddef>
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
typedef long long ll;
|
||||
|
||||
struct Node {
|
||||
Node* left_child = nullptr;
|
||||
Node* right_child = nullptr;
|
||||
ll value;
|
||||
|
||||
Node(ll value) : value(value){};
|
||||
|
||||
bool operator==(ll rhs) {
|
||||
return value == rhs;
|
||||
}
|
||||
|
||||
bool operator<(ll rhs) {
|
||||
return value < rhs;
|
||||
}
|
||||
|
||||
bool operator>(ll rhs) {
|
||||
return value > rhs;
|
||||
}
|
||||
|
||||
bool operator<=(ll rhs) {
|
||||
return (*this < rhs) || (*this == rhs);
|
||||
}
|
||||
|
||||
bool operator>=(ll rhs) {
|
||||
return (*this > rhs) || (*this == rhs);
|
||||
}
|
||||
};
|
||||
|
||||
class BinarySearchTree {
|
||||
public:
|
||||
~BinarySearchTree() {
|
||||
DeleteNodes(root);
|
||||
}
|
||||
void PreorderTraversal() {
|
||||
if (!root) {
|
||||
return;
|
||||
}
|
||||
PreorderTraversal(root);
|
||||
}
|
||||
|
||||
void InorderTraversal() {
|
||||
if (!root) {
|
||||
return;
|
||||
}
|
||||
InorderTraversal(root);
|
||||
}
|
||||
|
||||
void PostorderTraversal() {
|
||||
if (!root) {
|
||||
return;
|
||||
}
|
||||
PostorderTraversal(root);
|
||||
}
|
||||
|
||||
void AddChild(ll value) {
|
||||
if (!root) {
|
||||
root = new Node(value);
|
||||
return;
|
||||
}
|
||||
AddChild(root, value);
|
||||
}
|
||||
|
||||
void Construct(const std::vector<ll>& array) {
|
||||
root = Construct(array, 0, array.size() - 1);
|
||||
}
|
||||
|
||||
void GetNextValue(ll number) {
|
||||
Node* node = root;
|
||||
Node* next = nullptr;
|
||||
|
||||
while (node) {
|
||||
if (*node > number) {
|
||||
next = node;
|
||||
node = node->left_child;
|
||||
} else {
|
||||
node = node->right_child;
|
||||
}
|
||||
}
|
||||
|
||||
if (!next) {
|
||||
std::cout << "none" << std::endl;
|
||||
} else {
|
||||
std::cout << next->value << std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void GetPrevValue(ll number) {
|
||||
Node* node = root;
|
||||
Node* next = nullptr;
|
||||
|
||||
while (node) {
|
||||
if (*node < number) {
|
||||
next = node;
|
||||
node = node->right_child;
|
||||
} else {
|
||||
node = node->left_child;
|
||||
}
|
||||
}
|
||||
|
||||
if (!next) {
|
||||
std::cout << "none" << std::endl;
|
||||
} else {
|
||||
std::cout << next->value << std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void Find(ll value) {
|
||||
std::cout << Find(root, value)->value << std::endl;
|
||||
}
|
||||
|
||||
void Exists(ll value) {
|
||||
std::cout << (Find(root, value) ? "true" : "false") << std::endl;
|
||||
}
|
||||
|
||||
void Delete(ll value) {
|
||||
root = Delete(root, value);
|
||||
}
|
||||
|
||||
private:
|
||||
void DeleteNodes(Node* node) {
|
||||
if (!root) {
|
||||
return;
|
||||
}
|
||||
DeleteNodes(node->left_child);
|
||||
DeleteNodes(node->right_child);
|
||||
delete node;
|
||||
}
|
||||
|
||||
Node* AddChild(Node* node, ll value) {
|
||||
if (!node) return new Node(value);
|
||||
|
||||
if (*node > value) {
|
||||
node->left_child = AddChild(node->left_child, value);
|
||||
} else if (*node < value) {
|
||||
node->right_child = AddChild(node->right_child, value);
|
||||
}
|
||||
|
||||
return node;
|
||||
}
|
||||
|
||||
void PreorderTraversal(Node* node) {
|
||||
if (!node) {
|
||||
return;
|
||||
}
|
||||
std::cout << node->value << ' ';
|
||||
PreorderTraversal(node->left_child);
|
||||
PreorderTraversal(node->right_child);
|
||||
}
|
||||
|
||||
void InorderTraversal(Node* node) {
|
||||
if (!node) {
|
||||
return;
|
||||
}
|
||||
InorderTraversal(node->left_child);
|
||||
std::cout << node->value << ' ';
|
||||
InorderTraversal(node->right_child);
|
||||
}
|
||||
|
||||
void PostorderTraversal(Node* node) {
|
||||
if (!node) {
|
||||
return;
|
||||
}
|
||||
PostorderTraversal(node->left_child);
|
||||
PostorderTraversal(node->right_child);
|
||||
std::cout << node->value << ' ';
|
||||
}
|
||||
|
||||
Node* Construct(const std::vector<ll>& array, ll start, ll end) {
|
||||
if (start > end) return nullptr;
|
||||
|
||||
size_t mid = (start + end) / 2;
|
||||
Node* node = new Node(array[mid]);
|
||||
|
||||
node->left_child = Construct(array, start, mid - 1);
|
||||
node->right_child = Construct(array, mid + 1, end);
|
||||
|
||||
return node;
|
||||
}
|
||||
|
||||
Node* Find(Node* node, ll value) {
|
||||
if (!node || *node == value) {
|
||||
return node;
|
||||
}
|
||||
|
||||
if (*node > value) {
|
||||
return Find(node->left_child, value);
|
||||
} else {
|
||||
return Find(node->right_child, value);
|
||||
}
|
||||
}
|
||||
|
||||
Node* Delete(Node* node, ll value) {
|
||||
if (!node) {
|
||||
return node;
|
||||
}
|
||||
|
||||
if (*node > value) {
|
||||
node->left_child = Delete(node->left_child, value);
|
||||
return node;
|
||||
} else if (*node < value) {
|
||||
node->right_child = Delete(node->right_child, value);
|
||||
return node;
|
||||
}
|
||||
|
||||
if (!node->left_child && !node->right_child) {
|
||||
delete node;
|
||||
return nullptr;
|
||||
} else if (!node->left_child) {
|
||||
Node* tmp = node->right_child;
|
||||
delete node;
|
||||
return tmp;
|
||||
} else if (!node->right_child) {
|
||||
Node* tmp = node->left_child;
|
||||
delete node;
|
||||
return tmp;
|
||||
} else {
|
||||
Node* next_parent = nullptr;
|
||||
Node* next = node->right_child;
|
||||
|
||||
while (next->left_child) {
|
||||
next_parent = next;
|
||||
next = next->left_child;
|
||||
}
|
||||
|
||||
if (next_parent) {
|
||||
next_parent->left_child = next->right_child;
|
||||
} else {
|
||||
node->right_child = next->right_child;
|
||||
}
|
||||
node->value = next->value;
|
||||
|
||||
delete next;
|
||||
return node;
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
Node* root = nullptr;
|
||||
};
|
||||
|
||||
ll GetValueFromStdin() {
|
||||
ll temp;
|
||||
std::cin >> temp;
|
||||
return temp;
|
||||
}
|
||||
|
||||
int main() {
|
||||
BinarySearchTree bst;
|
||||
|
||||
std::string command;
|
||||
while (std::cin >> command) {
|
||||
if (command == "insert") {
|
||||
ll value = GetValueFromStdin();
|
||||
bst.AddChild(value);
|
||||
} else if (command == "exists") {
|
||||
ll value = GetValueFromStdin();
|
||||
bst.Exists(value);
|
||||
} else if (command == "next") {
|
||||
ll value = GetValueFromStdin();
|
||||
bst.GetNextValue(value);
|
||||
} else if (command == "prev") {
|
||||
ll value = GetValueFromStdin();
|
||||
bst.GetPrevValue(value);
|
||||
} else if (command == "delete") {
|
||||
ll value = GetValueFromStdin();
|
||||
bst.Delete(value);
|
||||
}
|
||||
}
|
||||
}
|
||||
297
5/C.cpp
Normal file
297
5/C.cpp
Normal file
|
|
@ -0,0 +1,297 @@
|
|||
#include <cstddef>
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
typedef long long ll;
|
||||
|
||||
struct Node {
|
||||
Node* left_child = nullptr;
|
||||
Node* right_child = nullptr;
|
||||
ll right_count = 0;
|
||||
ll value;
|
||||
|
||||
Node(ll value) : value(value){};
|
||||
|
||||
bool operator==(ll rhs) {
|
||||
return value == rhs;
|
||||
}
|
||||
|
||||
bool operator<(ll rhs) {
|
||||
return value < rhs;
|
||||
}
|
||||
|
||||
bool operator>(ll rhs) {
|
||||
return value > rhs;
|
||||
}
|
||||
|
||||
bool operator<=(ll rhs) {
|
||||
return (*this < rhs) || (*this == rhs);
|
||||
}
|
||||
|
||||
bool operator>=(ll rhs) {
|
||||
return (*this > rhs) || (*this == rhs);
|
||||
}
|
||||
};
|
||||
|
||||
class BinarySearchTree {
|
||||
public:
|
||||
~BinarySearchTree() {
|
||||
DeleteNodes(root);
|
||||
}
|
||||
void PreorderTraversal() {
|
||||
if (!root) {
|
||||
return;
|
||||
}
|
||||
PreorderTraversal(root);
|
||||
}
|
||||
|
||||
void InorderTraversal() {
|
||||
if (!root) {
|
||||
return;
|
||||
}
|
||||
InorderTraversal(root);
|
||||
}
|
||||
|
||||
void PostorderTraversal() {
|
||||
if (!root) {
|
||||
return;
|
||||
}
|
||||
PostorderTraversal(root);
|
||||
}
|
||||
|
||||
void AddChild(ll value) {
|
||||
if (!root) {
|
||||
root = new Node(value);
|
||||
return;
|
||||
}
|
||||
AddChild(root, value);
|
||||
}
|
||||
|
||||
void Construct(const std::vector<ll>& array) {
|
||||
root = Construct(array, 0, array.size() - 1);
|
||||
}
|
||||
|
||||
void GetNextValue(ll number) {
|
||||
Node* node = root;
|
||||
Node* next = nullptr;
|
||||
|
||||
while (node) {
|
||||
if (*node > number) {
|
||||
next = node;
|
||||
node = node->left_child;
|
||||
} else {
|
||||
node = node->right_child;
|
||||
}
|
||||
}
|
||||
|
||||
if (!next) {
|
||||
std::cout << "none" << std::endl;
|
||||
} else {
|
||||
std::cout << next->value << std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void GetPrevValue(ll number) {
|
||||
Node* node = root;
|
||||
Node* next = nullptr;
|
||||
|
||||
while (node) {
|
||||
if (*node < number) {
|
||||
next = node;
|
||||
node = node->right_child;
|
||||
} else {
|
||||
node = node->left_child;
|
||||
}
|
||||
}
|
||||
|
||||
if (!next) {
|
||||
std::cout << "none" << std::endl;
|
||||
} else {
|
||||
std::cout << next->value << std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void Find(ll value) {
|
||||
std::cout << Find(root, value)->value << std::endl;
|
||||
}
|
||||
|
||||
void Exists(ll value) {
|
||||
std::cout << (Find(root, value) ? "true" : "false") << std::endl;
|
||||
}
|
||||
|
||||
void Delete(ll value) {
|
||||
root = Delete(root, value);
|
||||
}
|
||||
void KthMax(ll value) {
|
||||
KthMax(root, value);
|
||||
}
|
||||
|
||||
private:
|
||||
void DeleteNodes(Node* node) {
|
||||
if (!node) {
|
||||
return;
|
||||
}
|
||||
DeleteNodes(node->left_child);
|
||||
DeleteNodes(node->right_child);
|
||||
delete node;
|
||||
}
|
||||
|
||||
Node* AddChild(Node* node, ll value) {
|
||||
if (!node) return new Node(value);
|
||||
|
||||
if (*node > value) {
|
||||
node->left_child = AddChild(node->left_child, value);
|
||||
} else if (*node < value) {
|
||||
node->right_child = AddChild(node->right_child, value);
|
||||
node->right_count++;
|
||||
}
|
||||
|
||||
return node;
|
||||
}
|
||||
|
||||
void PreorderTraversal(Node* node) {
|
||||
if (!node) {
|
||||
return;
|
||||
}
|
||||
std::cout << node->value << ' ';
|
||||
PreorderTraversal(node->left_child);
|
||||
PreorderTraversal(node->right_child);
|
||||
}
|
||||
|
||||
void InorderTraversal(Node* node) {
|
||||
if (!node) {
|
||||
return;
|
||||
}
|
||||
InorderTraversal(node->left_child);
|
||||
std::cout << node->value << ' ';
|
||||
InorderTraversal(node->right_child);
|
||||
}
|
||||
|
||||
void PostorderTraversal(Node* node) {
|
||||
if (!node) {
|
||||
return;
|
||||
}
|
||||
PostorderTraversal(node->left_child);
|
||||
PostorderTraversal(node->right_child);
|
||||
std::cout << node->value << ' ';
|
||||
}
|
||||
|
||||
Node* Construct(const std::vector<ll>& array, ll start, ll end) {
|
||||
if (start > end) return nullptr;
|
||||
|
||||
size_t mid = (start + end) / 2;
|
||||
Node* node = new Node(array[mid]);
|
||||
|
||||
node->left_child = Construct(array, start, mid - 1);
|
||||
node->right_child = Construct(array, mid + 1, end);
|
||||
|
||||
return node;
|
||||
}
|
||||
|
||||
Node* Find(Node* node, ll value) {
|
||||
if (!node || *node == value) {
|
||||
return node;
|
||||
}
|
||||
|
||||
if (*node > value) {
|
||||
return Find(node->left_child, value);
|
||||
} else {
|
||||
return Find(node->right_child, value);
|
||||
}
|
||||
}
|
||||
|
||||
Node* Delete(Node* node, ll value) {
|
||||
if (!node) {
|
||||
return node;
|
||||
}
|
||||
|
||||
if (*node > value) {
|
||||
node->left_child = Delete(node->left_child, value);
|
||||
return node;
|
||||
} else if (*node < value) {
|
||||
node->right_child = Delete(node->right_child, value);
|
||||
node->right_count = node->right_child ? node->right_child->right_count + 1 : 0;
|
||||
return node;
|
||||
}
|
||||
|
||||
if (!node->left_child && !node->right_child) {
|
||||
delete node;
|
||||
return nullptr;
|
||||
} else if (!node->left_child) {
|
||||
Node* tmp = node->right_child;
|
||||
delete node;
|
||||
return tmp;
|
||||
} else if (!node->right_child) {
|
||||
Node* tmp = node->left_child;
|
||||
delete node;
|
||||
return tmp;
|
||||
} else {
|
||||
Node* next_parent = nullptr;
|
||||
Node* next = node->right_child;
|
||||
|
||||
while (next->left_child) {
|
||||
next_parent = next;
|
||||
next = next->left_child;
|
||||
}
|
||||
|
||||
if (next_parent) {
|
||||
next_parent->left_child = next->right_child;
|
||||
} else {
|
||||
node->right_child = next->right_child;
|
||||
}
|
||||
node->value = next->value;
|
||||
node->right_count = next->right_count;
|
||||
|
||||
delete next;
|
||||
return node;
|
||||
}
|
||||
}
|
||||
|
||||
void KthMax(Node* node, ll k) {
|
||||
if (!node) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (k == node->right_count + 1) {
|
||||
std::cout << node->value << '\n';
|
||||
return;
|
||||
}
|
||||
if (k < node->right_count + 1) {
|
||||
KthMax(node->right_child, k);
|
||||
} else {
|
||||
KthMax(node->left_child, k - node->right_count - 1);
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
Node* root = nullptr;
|
||||
};
|
||||
|
||||
ll GetValueFromStdin() {
|
||||
ll temp;
|
||||
std::cin >> temp;
|
||||
return temp;
|
||||
}
|
||||
|
||||
int main() {
|
||||
BinarySearchTree bst;
|
||||
|
||||
ll n;
|
||||
std::cin >> n;
|
||||
|
||||
for (ll i = 0; i < n; ++i) {
|
||||
int command;
|
||||
std::cin >> command;
|
||||
if (command == 1) {
|
||||
ll value = GetValueFromStdin();
|
||||
bst.AddChild(value);
|
||||
} else if (command == -1) {
|
||||
ll value = GetValueFromStdin();
|
||||
bst.Delete(value);
|
||||
} else if (command == 0) {
|
||||
ll value = GetValueFromStdin();
|
||||
bst.KthMax(value);
|
||||
}
|
||||
}
|
||||
}
|
||||
301
5/D.cpp
Normal file
301
5/D.cpp
Normal file
|
|
@ -0,0 +1,301 @@
|
|||
#include <cstddef>
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
typedef long long ll;
|
||||
|
||||
struct Node {
|
||||
Node* left_child = nullptr;
|
||||
Node* right_child = nullptr;
|
||||
ll value;
|
||||
|
||||
Node(ll value) : value(value){};
|
||||
|
||||
bool operator==(ll rhs) {
|
||||
return value == rhs;
|
||||
}
|
||||
|
||||
bool operator<(ll rhs) {
|
||||
return value < rhs;
|
||||
}
|
||||
|
||||
bool operator>(ll rhs) {
|
||||
return value > rhs;
|
||||
}
|
||||
|
||||
bool operator<=(ll rhs) {
|
||||
return (*this < rhs) || (*this == rhs);
|
||||
}
|
||||
|
||||
bool operator>=(ll rhs) {
|
||||
return (*this > rhs) || (*this == rhs);
|
||||
}
|
||||
};
|
||||
|
||||
class BinarySearchTree {
|
||||
public:
|
||||
~BinarySearchTree() {
|
||||
DeleteNodes(root);
|
||||
}
|
||||
void PreorderTraversal() {
|
||||
if (!root) {
|
||||
return;
|
||||
}
|
||||
PreorderTraversal(root);
|
||||
}
|
||||
|
||||
void InorderTraversal() {
|
||||
if (!root) {
|
||||
return;
|
||||
}
|
||||
InorderTraversal(root);
|
||||
}
|
||||
|
||||
void PostorderTraversal() {
|
||||
if (!root) {
|
||||
return;
|
||||
}
|
||||
PostorderTraversal(root);
|
||||
}
|
||||
|
||||
void AddChild(ll value) {
|
||||
if (!root) {
|
||||
root = new Node(value);
|
||||
return;
|
||||
}
|
||||
AddChild(root, value);
|
||||
}
|
||||
|
||||
void Construct(const std::vector<ll>& array) {
|
||||
root = Construct(array, 0, array.size() - 1);
|
||||
}
|
||||
|
||||
void GetNextValue(ll number) {
|
||||
Node* node = root;
|
||||
Node* next = nullptr;
|
||||
|
||||
while (node) {
|
||||
if (*node > number) {
|
||||
next = node;
|
||||
node = node->left_child;
|
||||
} else {
|
||||
node = node->right_child;
|
||||
}
|
||||
}
|
||||
|
||||
if (!next) {
|
||||
std::cout << "none" << std::endl;
|
||||
} else {
|
||||
std::cout << next->value << std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void GetPrevValue(ll number) {
|
||||
Node* node = root;
|
||||
Node* next = nullptr;
|
||||
|
||||
while (node) {
|
||||
if (*node < number) {
|
||||
next = node;
|
||||
node = node->right_child;
|
||||
} else {
|
||||
node = node->left_child;
|
||||
}
|
||||
}
|
||||
|
||||
if (!next) {
|
||||
std::cout << "none" << std::endl;
|
||||
} else {
|
||||
std::cout << next->value << std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void Find(ll value) {
|
||||
std::cout << Find(root, value)->value << std::endl;
|
||||
}
|
||||
|
||||
void Exists(ll value) {
|
||||
std::cout << (Find(root, value) ? "true" : "false") << std::endl;
|
||||
}
|
||||
|
||||
void Delete(ll value) {
|
||||
root = Delete(root, value);
|
||||
}
|
||||
|
||||
void PrintRightElement() {
|
||||
ll height = FindHeight(root);
|
||||
for (ll i = 1; i <= height; ++i) {
|
||||
PrintRightElement(root, i);
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
void DeleteNodes(Node* node) {
|
||||
if (!root) {
|
||||
return;
|
||||
}
|
||||
// DeleteNodes(node->left_child);
|
||||
// DeleteNodes(node->right_child);
|
||||
delete node;
|
||||
}
|
||||
|
||||
Node* AddChild(Node* node, ll value) {
|
||||
if (!node) return new Node(value);
|
||||
|
||||
if (*node > value) {
|
||||
node->left_child = AddChild(node->left_child, value);
|
||||
} else if (*node < value) {
|
||||
node->right_child = AddChild(node->right_child, value);
|
||||
}
|
||||
|
||||
return node;
|
||||
}
|
||||
|
||||
void PreorderTraversal(Node* node) {
|
||||
if (!node) {
|
||||
return;
|
||||
}
|
||||
std::cout << node->value << ' ';
|
||||
PreorderTraversal(node->left_child);
|
||||
PreorderTraversal(node->right_child);
|
||||
}
|
||||
|
||||
void InorderTraversal(Node* node) {
|
||||
if (!node) {
|
||||
return;
|
||||
}
|
||||
InorderTraversal(node->left_child);
|
||||
std::cout << node->value << ' ';
|
||||
InorderTraversal(node->right_child);
|
||||
}
|
||||
|
||||
void PostorderTraversal(Node* node) {
|
||||
if (!node) {
|
||||
return;
|
||||
}
|
||||
PostorderTraversal(node->left_child);
|
||||
PostorderTraversal(node->right_child);
|
||||
std::cout << node->value << ' ';
|
||||
}
|
||||
|
||||
Node* Construct(const std::vector<ll>& array, ll start, ll end) {
|
||||
if (start > end) return nullptr;
|
||||
|
||||
size_t mid = (start + end) / 2;
|
||||
Node* node = new Node(array[mid]);
|
||||
|
||||
node->left_child = Construct(array, start, mid - 1);
|
||||
node->right_child = Construct(array, mid + 1, end);
|
||||
|
||||
return node;
|
||||
}
|
||||
|
||||
Node* Find(Node* node, ll value) {
|
||||
if (!node || *node == value) {
|
||||
return node;
|
||||
}
|
||||
|
||||
if (*node > value) {
|
||||
return Find(node->left_child, value);
|
||||
} else {
|
||||
return Find(node->right_child, value);
|
||||
}
|
||||
}
|
||||
|
||||
Node* Delete(Node* node, ll value) {
|
||||
if (!node) {
|
||||
return node;
|
||||
}
|
||||
|
||||
if (*node > value) {
|
||||
node->left_child = Delete(node->left_child, value);
|
||||
return node;
|
||||
} else if (*node < value) {
|
||||
node->right_child = Delete(node->right_child, value);
|
||||
return node;
|
||||
}
|
||||
|
||||
if (!node->left_child && !node->right_child) {
|
||||
delete node;
|
||||
return nullptr;
|
||||
} else if (!node->left_child) {
|
||||
Node* tmp = node->right_child;
|
||||
delete node;
|
||||
return tmp;
|
||||
} else if (!node->right_child) {
|
||||
Node* tmp = node->left_child;
|
||||
delete node;
|
||||
return tmp;
|
||||
} else {
|
||||
Node* next_parent = nullptr;
|
||||
Node* next = node->right_child;
|
||||
|
||||
while (next->left_child) {
|
||||
next_parent = next;
|
||||
next = next->left_child;
|
||||
}
|
||||
|
||||
if (next_parent) {
|
||||
next_parent->left_child = next->right_child;
|
||||
} else {
|
||||
node->right_child = next->right_child;
|
||||
}
|
||||
node->value = next->value;
|
||||
|
||||
delete next;
|
||||
return node;
|
||||
}
|
||||
}
|
||||
|
||||
ll FindHeight(Node* node) {
|
||||
if (!node)
|
||||
return 0;
|
||||
else {
|
||||
ll left = FindHeight(node->left_child);
|
||||
ll right = FindHeight(node->right_child);
|
||||
|
||||
return std::max(left, right) + 1;
|
||||
}
|
||||
}
|
||||
|
||||
bool PrintRightElement(Node* node, ll level) {
|
||||
bool ret_val = false;
|
||||
if (!node) {
|
||||
return false;
|
||||
}
|
||||
if (level == 1) {
|
||||
std::cout << node->value << ' ';
|
||||
return true;
|
||||
} else if (level > 1) {
|
||||
ret_val = PrintRightElement(node->right_child, level - 1);
|
||||
if (!ret_val) {
|
||||
ret_val = PrintRightElement(node->left_child, level - 1);
|
||||
}
|
||||
}
|
||||
return ret_val;
|
||||
}
|
||||
|
||||
private:
|
||||
Node* root = nullptr;
|
||||
};
|
||||
|
||||
ll GetValueFromStdin() {
|
||||
ll temp;
|
||||
std::cin >> temp;
|
||||
return temp;
|
||||
}
|
||||
|
||||
int main() {
|
||||
BinarySearchTree bst;
|
||||
|
||||
ll n;
|
||||
std::cin >> n;
|
||||
|
||||
for (ll i = 0; i < n; ++i) {
|
||||
ll tmp;
|
||||
std::cin >> tmp;
|
||||
bst.AddChild(tmp);
|
||||
}
|
||||
bst.PrintRightElement();
|
||||
}
|
||||
124
5/E.cpp
Normal file
124
5/E.cpp
Normal file
|
|
@ -0,0 +1,124 @@
|
|||
#include <iostream>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
typedef long long ll;
|
||||
|
||||
struct Node {
|
||||
Node* left_child = nullptr;
|
||||
Node* right_child = nullptr;
|
||||
int count;
|
||||
std::string value;
|
||||
|
||||
Node(std::string value) : value(value), count(1){};
|
||||
|
||||
bool operator<(std::string& rhs) {
|
||||
return value < rhs;
|
||||
}
|
||||
|
||||
bool operator>(std::string& rhs) {
|
||||
return value > rhs;
|
||||
}
|
||||
|
||||
bool operator==(std::string& rhs) {
|
||||
return value == rhs;
|
||||
}
|
||||
};
|
||||
|
||||
class BinarySearchTree {
|
||||
public:
|
||||
~BinarySearchTree() {
|
||||
DeleteNodes(root);
|
||||
}
|
||||
|
||||
void AddChild(std::string& value) {
|
||||
if (!root) {
|
||||
root = new Node(value);
|
||||
return;
|
||||
}
|
||||
AddChild(root, value);
|
||||
}
|
||||
|
||||
int Find(std::string& value) {
|
||||
return Find(root, value)->count;
|
||||
}
|
||||
|
||||
private:
|
||||
void DeleteNodes(Node* node) {
|
||||
if (!node) {
|
||||
return;
|
||||
}
|
||||
DeleteNodes(node->left_child);
|
||||
DeleteNodes(node->right_child);
|
||||
delete node;
|
||||
}
|
||||
|
||||
Node* AddChild(Node* node, std::string& value) {
|
||||
if (!node) return new Node(value);
|
||||
|
||||
if (*node == value) {
|
||||
node->count++;
|
||||
}
|
||||
|
||||
if (*node > value) {
|
||||
node->left_child = AddChild(node->left_child, value);
|
||||
} else if (*node < value) {
|
||||
node->right_child = AddChild(node->right_child, value);
|
||||
}
|
||||
|
||||
return node;
|
||||
}
|
||||
|
||||
Node* Find(Node* node, std::string& value) {
|
||||
if (!node || *node == value) {
|
||||
return node;
|
||||
}
|
||||
|
||||
if (*node > value) {
|
||||
return Find(node->left_child, value);
|
||||
} else {
|
||||
return Find(node->right_child, value);
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
Node* root = nullptr;
|
||||
};
|
||||
|
||||
std::string GetValueFromStdin() {
|
||||
std::string temp;
|
||||
std::cin >> temp;
|
||||
return temp;
|
||||
}
|
||||
|
||||
int main() {
|
||||
BinarySearchTree bst;
|
||||
|
||||
std::vector<std::vector<std::string>> values(3);
|
||||
|
||||
ll n;
|
||||
std::cin >> n;
|
||||
|
||||
for (int i = 0; i < 3; ++i) {
|
||||
values[i].reserve(n);
|
||||
for (int j = 0; j < n; ++j) {
|
||||
std::string value = GetValueFromStdin();
|
||||
values[i].push_back(value);
|
||||
bst.AddChild(value);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
for (int i = 0; i < 3; ++i){
|
||||
int ans = 0;
|
||||
for (int j = 0; j < n; ++j){
|
||||
int count = bst.Find(values[i][j]);
|
||||
if (count == 1) {
|
||||
ans += 3;
|
||||
} else if (count == 2) {
|
||||
++ans;
|
||||
}
|
||||
}
|
||||
std::cout << ans << " ";
|
||||
}
|
||||
}
|
||||
381
5/F.cpp
Normal file
381
5/F.cpp
Normal file
|
|
@ -0,0 +1,381 @@
|
|||
#include <cstddef>
|
||||
#include <iostream>
|
||||
#include <vector>
|
||||
#include <stack>
|
||||
|
||||
typedef long long ll;
|
||||
|
||||
struct Node {
|
||||
Node* left_child = nullptr;
|
||||
Node* right_child = nullptr;
|
||||
ll value;
|
||||
|
||||
Node(ll value) : value(value){};
|
||||
|
||||
bool operator==(ll rhs) {
|
||||
return value == rhs;
|
||||
}
|
||||
|
||||
bool operator!=(ll rhs) {
|
||||
return value != rhs;
|
||||
}
|
||||
|
||||
bool operator<(ll rhs) {
|
||||
return value < rhs;
|
||||
}
|
||||
|
||||
bool operator>(ll rhs) {
|
||||
return value > rhs;
|
||||
}
|
||||
|
||||
bool operator<=(ll rhs) {
|
||||
return (*this < rhs) || (*this == rhs);
|
||||
}
|
||||
|
||||
bool operator>=(ll rhs) {
|
||||
return (*this > rhs) || (*this == rhs);
|
||||
}
|
||||
};
|
||||
|
||||
class BinarySearchTree {
|
||||
public:
|
||||
void AddTraversals(std::vector<ll>& inorder_, std::vector<ll>& postorder_) {
|
||||
inorder = &inorder_;
|
||||
postorder = &postorder_;
|
||||
}
|
||||
BinarySearchTree() = default;
|
||||
~BinarySearchTree() {
|
||||
DeleteNodes(root);
|
||||
}
|
||||
void PreorderTraversal() {
|
||||
if (!root) {
|
||||
return;
|
||||
}
|
||||
PreorderTraversal(root);
|
||||
}
|
||||
|
||||
void InorderTraversal() {
|
||||
|
||||
if (!root) {
|
||||
return;
|
||||
}
|
||||
ll i = 0;
|
||||
InorderTraversal(root, i);
|
||||
}
|
||||
|
||||
void PostorderTraversal() {
|
||||
if (!root) {
|
||||
|
||||
return;
|
||||
}
|
||||
ll i = 0;
|
||||
PostorderTraversal(root, i);
|
||||
}
|
||||
|
||||
void AddChild(ll value) {
|
||||
if (!root) {
|
||||
root = new Node(value);
|
||||
return;
|
||||
}
|
||||
AddChild(root, value);
|
||||
}
|
||||
|
||||
void Construct(const std::vector<ll>& array) {
|
||||
root = Construct(array, 0, array.size() - 1);
|
||||
}
|
||||
|
||||
void GetNextValue(ll number) {
|
||||
Node* node = root;
|
||||
Node* next = nullptr;
|
||||
|
||||
while (node) {
|
||||
|
||||
if (*node > number) {
|
||||
next = node;
|
||||
node = node->left_child;
|
||||
} else {
|
||||
node = node->right_child;
|
||||
}
|
||||
}
|
||||
|
||||
if (!next) {
|
||||
|
||||
std::cout << "none" << std::endl;
|
||||
} else {
|
||||
std::cout << next->value << std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void GetPrevValue(ll number) {
|
||||
Node* node = root;
|
||||
Node* next = nullptr;
|
||||
|
||||
while (node) {
|
||||
if (*node < number) {
|
||||
next = node;
|
||||
node = node->right_child;
|
||||
} else {
|
||||
node = node->left_child;
|
||||
}
|
||||
}
|
||||
|
||||
if (!next) {
|
||||
std::cout << "none" << std::endl;
|
||||
} else {
|
||||
std::cout << next->value << std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void Find(ll value) {
|
||||
std::cout << Find(root, value)->value << std::endl;
|
||||
}
|
||||
|
||||
void Exists(ll value) {
|
||||
std::cout << (Find(root, value) ? "true" : "false") << std::endl;
|
||||
}
|
||||
|
||||
void Delete(ll value) {
|
||||
root = Delete(root, value);
|
||||
}
|
||||
|
||||
void PrintRightElement() {
|
||||
ll height = FindHeight(root);
|
||||
for (ll i = 1; i <= height; ++i) {
|
||||
PrintRightElement(root, i);
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
void DeleteNodes(Node* node) {
|
||||
if (!node) {
|
||||
|
||||
return;
|
||||
}
|
||||
DeleteNodes(node->left_child);
|
||||
DeleteNodes(node->right_child);
|
||||
delete node;
|
||||
}
|
||||
|
||||
Node* AddChild(Node* node, ll value) {
|
||||
|
||||
if (!node) return new Node(value);
|
||||
|
||||
if (*node > value) {
|
||||
node->left_child = AddChild(node->left_child, value);
|
||||
} else {
|
||||
node->right_child = AddChild(node->right_child, value);
|
||||
}
|
||||
|
||||
return node;
|
||||
}
|
||||
|
||||
void PreorderTraversal(Node* node) {
|
||||
if (!node) {
|
||||
return;
|
||||
}
|
||||
std::cout << node->value << ' ';
|
||||
PreorderTraversal(node->left_child);
|
||||
PreorderTraversal(node->right_child);
|
||||
}
|
||||
|
||||
void InorderTraversal(Node* node, ll& i) {
|
||||
if (!node) {
|
||||
return;
|
||||
}
|
||||
|
||||
InorderTraversal(node->left_child, i);
|
||||
|
||||
if (*node != (*inorder)[i]) {
|
||||
// for (int j = 0; j < 6; ++j) {
|
||||
// std::cout << (*inorder)[j] << ' ';
|
||||
// }
|
||||
// std::cout << "\n";
|
||||
// std::cout << node->value << ' ' << (*inorder)[i] << '\n';
|
||||
std::cout << "NO";
|
||||
exit(0);
|
||||
}
|
||||
// else {
|
||||
// std::cout << (*inorder)[i] << " Matches\n";
|
||||
// }
|
||||
++i;
|
||||
|
||||
InorderTraversal(node->right_child, i);
|
||||
}
|
||||
|
||||
void PostorderTraversal(Node* node, ll& i) {
|
||||
if (!node) {
|
||||
return;
|
||||
}
|
||||
PostorderTraversal(node->left_child, i);
|
||||
PostorderTraversal(node->right_child, i);
|
||||
if (*node != (*postorder)[i]) {
|
||||
std::cout << "NO";
|
||||
exit(0);
|
||||
}
|
||||
++i;
|
||||
}
|
||||
|
||||
Node* Construct(const std::vector<ll>& array, ll start, ll end) {
|
||||
if (start > end) return nullptr;
|
||||
|
||||
size_t mid = (start + end) / 2;
|
||||
Node* node = new Node(array[mid]);
|
||||
|
||||
node->left_child = Construct(array, start, mid - 1);
|
||||
node->right_child = Construct(array, mid + 1, end);
|
||||
|
||||
return node;
|
||||
}
|
||||
|
||||
Node* Find(Node* node, ll value) {
|
||||
|
||||
if (!node || *node == value) {
|
||||
return node;
|
||||
}
|
||||
|
||||
if (*node > value) {
|
||||
return Find(node->left_child, value);
|
||||
} else {
|
||||
return Find(node->right_child, value);
|
||||
}
|
||||
}
|
||||
|
||||
Node* Delete(Node* node, ll value) {
|
||||
if (!node) {
|
||||
return node;
|
||||
}
|
||||
|
||||
if (*node > value) {
|
||||
node->left_child = Delete(node->left_child, value);
|
||||
return node;
|
||||
} else if (*node < value) {
|
||||
node->right_child = Delete(node->right_child, value);
|
||||
return node;
|
||||
}
|
||||
|
||||
if (!node->left_child && !node->right_child) {
|
||||
delete node;
|
||||
return nullptr;
|
||||
} else if (!node->left_child) {
|
||||
Node* tmp = node->right_child;
|
||||
delete node;
|
||||
return tmp;
|
||||
} else if (!node->right_child) {
|
||||
Node* tmp = node->left_child;
|
||||
delete node;
|
||||
|
||||
return tmp;
|
||||
} else {
|
||||
Node* next_parent = nullptr;
|
||||
Node* next = node->right_child;
|
||||
|
||||
while (next->left_child) {
|
||||
next_parent = next;
|
||||
next = next->left_child;
|
||||
}
|
||||
|
||||
if (next_parent) {
|
||||
next_parent->left_child = next->right_child;
|
||||
} else {
|
||||
node->right_child = next->right_child;
|
||||
}
|
||||
|
||||
node->value = next->value;
|
||||
|
||||
delete next;
|
||||
return node;
|
||||
}
|
||||
}
|
||||
|
||||
ll FindHeight(Node* node) {
|
||||
if (!node)
|
||||
|
||||
return 0;
|
||||
else {
|
||||
ll left = FindHeight(node->left_child);
|
||||
ll right = FindHeight(node->right_child);
|
||||
|
||||
return std::max(left, right) + 1;
|
||||
}
|
||||
}
|
||||
|
||||
bool PrintRightElement(Node* node, ll level) {
|
||||
bool ret_val = false;
|
||||
if (!node) {
|
||||
return false;
|
||||
}
|
||||
if (level == 1) {
|
||||
std::cout << node->value << ' ';
|
||||
return true;
|
||||
} else if (level > 1) {
|
||||
ret_val = PrintRightElement(node->right_child, level - 1);
|
||||
if (!ret_val) {
|
||||
ret_val = PrintRightElement(node->left_child, level - 1);
|
||||
}
|
||||
}
|
||||
return ret_val;
|
||||
}
|
||||
|
||||
public:
|
||||
Node* root = nullptr;
|
||||
std::vector<ll>* inorder;
|
||||
std::vector<ll>* postorder;
|
||||
};
|
||||
|
||||
ll GetValueFromStdin() {
|
||||
ll temp;
|
||||
std::cin >> temp;
|
||||
return temp;
|
||||
}
|
||||
|
||||
int main() {
|
||||
std::ios::sync_with_stdio(0);
|
||||
std::cin.tie(0);
|
||||
ll n;
|
||||
std::cin >> n;
|
||||
|
||||
std::vector<std::vector<ll>> values(2);
|
||||
|
||||
BinarySearchTree bst;
|
||||
|
||||
std::stack<Node*> stack;
|
||||
|
||||
ll value = GetValueFromStdin();
|
||||
|
||||
Node* new_node = new Node(value);
|
||||
bst.root = new_node;
|
||||
stack.push(new_node);
|
||||
|
||||
for (ll i = 1; i < n; ++i) {
|
||||
value = GetValueFromStdin();
|
||||
Node* current_node = nullptr;
|
||||
while (!stack.empty() && (*stack.top()) <= value) {
|
||||
current_node = stack.top();
|
||||
stack.pop();
|
||||
}
|
||||
if (!current_node) {
|
||||
current_node = stack.top();
|
||||
Node* new_node = new Node(value);
|
||||
current_node->left_child = new_node;
|
||||
stack.push(new_node);
|
||||
} else {
|
||||
Node* new_node = new Node(value);
|
||||
current_node->right_child = new_node;
|
||||
stack.push(new_node);
|
||||
}
|
||||
}
|
||||
|
||||
values[0].reserve(n);
|
||||
values[1].reserve(n);
|
||||
for (int i = 0; i < 2; ++i) {
|
||||
for (ll j = 0; j < n; ++j)
|
||||
values[i].push_back(GetValueFromStdin());
|
||||
}
|
||||
|
||||
bst.AddTraversals(values[0], values[1]);
|
||||
bst.InorderTraversal();
|
||||
bst.PostorderTraversal();
|
||||
|
||||
std::cout << "YES";
|
||||
return 0;
|
||||
}
|
||||
387
5/H.cpp
Normal file
387
5/H.cpp
Normal file
|
|
@ -0,0 +1,387 @@
|
|||
#include <cstddef>
|
||||
#include <iostream>
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
typedef long long ll;
|
||||
|
||||
struct Node {
|
||||
Node* left_child = nullptr;
|
||||
Node* right_child = nullptr;
|
||||
ll value;
|
||||
|
||||
Node(ll value) : value(value){};
|
||||
|
||||
bool operator==(ll rhs) {
|
||||
return value == rhs;
|
||||
}
|
||||
|
||||
bool operator<(ll rhs) {
|
||||
return value < rhs;
|
||||
}
|
||||
|
||||
bool operator>(ll rhs) {
|
||||
return value > rhs;
|
||||
}
|
||||
|
||||
bool operator<=(ll rhs) {
|
||||
return (*this < rhs) || (*this == rhs);
|
||||
}
|
||||
|
||||
bool operator>=(ll rhs) {
|
||||
return (*this > rhs) || (*this == rhs);
|
||||
}
|
||||
};
|
||||
|
||||
class BinarySearchTree {
|
||||
public:
|
||||
~BinarySearchTree() {
|
||||
DeleteNodes(root);
|
||||
}
|
||||
void PreorderTraversal() {
|
||||
if (!root) {
|
||||
return;
|
||||
}
|
||||
PreorderTraversal(root);
|
||||
}
|
||||
|
||||
void InorderTraversal() {
|
||||
|
||||
if (!root) {
|
||||
return;
|
||||
}
|
||||
InorderTraversal(root);
|
||||
}
|
||||
|
||||
void InorderTraversalVector(std::vector<ll>& container) {
|
||||
InorderTraversalVector(root, container);
|
||||
}
|
||||
|
||||
void InorderTraversalVector(Node* node, std::vector<ll>& container) {
|
||||
if (!node) {
|
||||
return;
|
||||
}
|
||||
|
||||
InorderTraversalVector(node->left_child, container);
|
||||
container.push_back(node->value);
|
||||
InorderTraversalVector(node->right_child, container);
|
||||
}
|
||||
|
||||
void PostorderTraversal() {
|
||||
if (!root) {
|
||||
|
||||
return;
|
||||
}
|
||||
PostorderTraversal(root);
|
||||
}
|
||||
|
||||
void AddChild(ll value) {
|
||||
if (!root) {
|
||||
root = new Node(value);
|
||||
return;
|
||||
}
|
||||
AddChild(root, value);
|
||||
}
|
||||
|
||||
void AddChild(Node* node) {
|
||||
if (!root) {
|
||||
root = node;
|
||||
return;
|
||||
}
|
||||
AddChild(root, node);
|
||||
}
|
||||
|
||||
void Construct(const std::vector<ll>& array) {
|
||||
root = Construct(array, 0, array.size() - 1);
|
||||
}
|
||||
|
||||
void GetNextValue(ll number) {
|
||||
Node* node = root;
|
||||
Node* next = nullptr;
|
||||
|
||||
while (node) {
|
||||
|
||||
if (*node > number) {
|
||||
next = node;
|
||||
node = node->left_child;
|
||||
} else {
|
||||
node = node->right_child;
|
||||
}
|
||||
}
|
||||
|
||||
if (!next) {
|
||||
|
||||
std::cout << "none" << std::endl;
|
||||
} else {
|
||||
std::cout << next->value << std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void GetPrevValue(ll number) {
|
||||
Node* node = root;
|
||||
Node* next = nullptr;
|
||||
|
||||
while (node) {
|
||||
if (*node < number) {
|
||||
next = node;
|
||||
node = node->right_child;
|
||||
} else {
|
||||
node = node->left_child;
|
||||
}
|
||||
}
|
||||
|
||||
if (!next) {
|
||||
std::cout << "none" << std::endl;
|
||||
} else {
|
||||
std::cout << next->value << std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void Find(ll value) {
|
||||
std::cout << Find(root, value)->value << std::endl;
|
||||
}
|
||||
|
||||
void Exists(ll value) {
|
||||
std::cout << (Find(root, value) ? "true" : "false") << std::endl;
|
||||
}
|
||||
|
||||
void Delete(ll value) {
|
||||
root = Delete(root, value);
|
||||
}
|
||||
|
||||
void PrintRightElement() {
|
||||
ll height = FindHeight(root);
|
||||
for (ll i = 1; i <= height; ++i) {
|
||||
PrintRightElement(root, i);
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
void DeleteNodes(Node* node) {
|
||||
if (!root) {
|
||||
|
||||
return;
|
||||
}
|
||||
// DeleteNodes(node->left_child);
|
||||
// DeleteNodes(node->right_child);
|
||||
delete node;
|
||||
}
|
||||
|
||||
Node* AddChild(Node* node, ll value) {
|
||||
|
||||
if (!node) return new Node(value);
|
||||
|
||||
if (*node > value) {
|
||||
node->left_child = AddChild(node->left_child, value);
|
||||
} else {
|
||||
node->right_child = AddChild(node->right_child, value);
|
||||
}
|
||||
|
||||
return node;
|
||||
}
|
||||
|
||||
Node* AddChild(Node* node, Node* value) {
|
||||
|
||||
if (!node) return value;
|
||||
|
||||
if (*node > value->value) {
|
||||
node->left_child = AddChild(node->left_child, value);
|
||||
} else {
|
||||
node->right_child = AddChild(node->right_child, value);
|
||||
}
|
||||
|
||||
return node;
|
||||
}
|
||||
|
||||
void PreorderTraversal(Node* node) {
|
||||
if (!node) {
|
||||
return;
|
||||
}
|
||||
std::cout << node->value << ' ';
|
||||
PreorderTraversal(node->left_child);
|
||||
PreorderTraversal(node->right_child);
|
||||
}
|
||||
|
||||
void InorderTraversal(Node* node) {
|
||||
if (!node) {
|
||||
return;
|
||||
}
|
||||
|
||||
InorderTraversal(node->left_child);
|
||||
|
||||
std::cout << node->value << ' ';
|
||||
|
||||
InorderTraversal(node->right_child);
|
||||
}
|
||||
|
||||
void PostorderTraversal(Node* node) {
|
||||
if (!node) {
|
||||
return;
|
||||
}
|
||||
PostorderTraversal(node->left_child);
|
||||
PostorderTraversal(node->right_child);
|
||||
std::cout << node->value << ' ';
|
||||
}
|
||||
|
||||
Node* Construct(const std::vector<ll>& array, ll start, ll end) {
|
||||
if (start > end) return nullptr;
|
||||
|
||||
size_t mid = (start + end) / 2;
|
||||
Node* node = new Node(array[mid]);
|
||||
|
||||
node->left_child = Construct(array, start, mid - 1);
|
||||
node->right_child = Construct(array, mid + 1, end);
|
||||
|
||||
return node;
|
||||
}
|
||||
|
||||
Node* Find(Node* node, ll value) {
|
||||
|
||||
if (!node || *node == value) {
|
||||
return node;
|
||||
}
|
||||
|
||||
if (*node > value) {
|
||||
return Find(node->left_child, value);
|
||||
} else {
|
||||
return Find(node->right_child, value);
|
||||
}
|
||||
}
|
||||
|
||||
Node* Delete(Node* node, ll value) {
|
||||
if (!node) {
|
||||
return node;
|
||||
}
|
||||
|
||||
if (*node > value) {
|
||||
node->left_child = Delete(node->left_child, value);
|
||||
return node;
|
||||
} else if (*node < value) {
|
||||
node->right_child = Delete(node->right_child, value);
|
||||
return node;
|
||||
}
|
||||
|
||||
if (!node->left_child && !node->right_child) {
|
||||
delete node;
|
||||
return nullptr;
|
||||
} else if (!node->left_child) {
|
||||
Node* tmp = node->right_child;
|
||||
delete node;
|
||||
return tmp;
|
||||
} else if (!node->right_child) {
|
||||
Node* tmp = node->left_child;
|
||||
delete node;
|
||||
|
||||
return tmp;
|
||||
} else {
|
||||
Node* next_parent = nullptr;
|
||||
Node* next = node->right_child;
|
||||
|
||||
while (next->left_child) {
|
||||
next_parent = next;
|
||||
next = next->left_child;
|
||||
}
|
||||
|
||||
if (next_parent) {
|
||||
next_parent->left_child = next->right_child;
|
||||
} else {
|
||||
node->right_child = next->right_child;
|
||||
}
|
||||
|
||||
node->value = next->value;
|
||||
|
||||
delete next;
|
||||
return node;
|
||||
}
|
||||
}
|
||||
|
||||
ll FindHeight(Node* node) {
|
||||
if (!node)
|
||||
|
||||
return 0;
|
||||
else {
|
||||
ll left = FindHeight(node->left_child);
|
||||
ll right = FindHeight(node->right_child);
|
||||
|
||||
return std::max(left, right) + 1;
|
||||
}
|
||||
}
|
||||
|
||||
bool PrintRightElement(Node* node, ll level) {
|
||||
bool ret_val = false;
|
||||
if (!node) {
|
||||
return false;
|
||||
}
|
||||
if (level == 1) {
|
||||
std::cout << node->value << ' ';
|
||||
return true;
|
||||
} else if (level > 1) {
|
||||
ret_val = PrintRightElement(node->right_child, level - 1);
|
||||
if (!ret_val) {
|
||||
ret_val = PrintRightElement(node->left_child, level - 1);
|
||||
}
|
||||
}
|
||||
return ret_val;
|
||||
}
|
||||
|
||||
public:
|
||||
Node* root = nullptr;
|
||||
};
|
||||
|
||||
ll GetValueFromStdin() {
|
||||
ll temp;
|
||||
std::cin >> temp;
|
||||
return temp;
|
||||
}
|
||||
|
||||
int main() {
|
||||
ll n;
|
||||
std::cin >> n;
|
||||
|
||||
BinarySearchTree acc1;
|
||||
BinarySearchTree acc2;
|
||||
|
||||
std::string cmd;
|
||||
for (ll i = 0; i < n; ++i) {
|
||||
std::cin >> cmd;
|
||||
if (cmd == "buy") {
|
||||
int acc;
|
||||
std::cin >> acc;
|
||||
|
||||
if (acc == 1) {
|
||||
acc1.AddChild(GetValueFromStdin());
|
||||
} else {
|
||||
acc2.AddChild(GetValueFromStdin());
|
||||
}
|
||||
} else if (cmd == "sell") {
|
||||
int acc;
|
||||
std::cin >> acc;
|
||||
|
||||
if (acc == 1) {
|
||||
acc1.Delete(GetValueFromStdin());
|
||||
} else {
|
||||
acc2.Delete(GetValueFromStdin());
|
||||
}
|
||||
} else if (cmd == "merge") {
|
||||
std::vector<ll> nodes_1;
|
||||
std::vector<ll> nodes_2;
|
||||
acc2.InorderTraversalVector(nodes_2);
|
||||
acc2.root = nullptr;
|
||||
|
||||
for (ll node : nodes_2) {
|
||||
acc1.AddChild(node);
|
||||
}
|
||||
|
||||
acc1.InorderTraversalVector(nodes_1);
|
||||
if (nodes_1.empty()) {
|
||||
continue;
|
||||
}
|
||||
|
||||
for (int i = 0; i < nodes_1.size() - 1; ++i) {
|
||||
std::cout << nodes_1[i] << " ";
|
||||
}
|
||||
std::cout << nodes_1[nodes_1.size() - 1] << '\n';
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue