From a3438dd90bcb4725ba8a925a6c4fa849256755a1 Mon Sep 17 00:00:00 2001
From: "github-classroom[bot]"
 <66690702+github-classroom[bot]@users.noreply.github.com>
Date: Mon, 5 Sep 2022 08:16:10 +0000
Subject: [PATCH 1/2] Setting up GitHub Classroom Feedback


From bb32b8d00599028cfd8cc6c2af31c5e0cb34f855 Mon Sep 17 00:00:00 2001
From: lookisrr <lookisrrs@gmail.com>
Date: Mon, 5 Sep 2022 11:18:05 +0300
Subject: [PATCH 2/2] f

---
 README.md                  |   4 +-
 src/binary_search_tree.cpp | 119 ++++++++++++++++++++++++++++++-------
 2 files changed, 98 insertions(+), 25 deletions(-)

diff --git a/README.md b/README.md
index a86bec0..1a61357 100644
--- a/README.md
+++ b/README.md
@@ -5,9 +5,9 @@
 
 ## 1. Информация о студенте
 
-**Номер группы**: 00-000
+**Номер группы**: 11-109
 
-**Фамилия и Имя**: Иванов Иван
+**Фамилия и Имя**: Шамсутдинов Рафаэль
 
 ## 2. Описание задания
 
diff --git a/src/binary_search_tree.cpp b/src/binary_search_tree.cpp
index 24042ff..205932e 100644
--- a/src/binary_search_tree.cpp
+++ b/src/binary_search_tree.cpp
@@ -7,74 +7,147 @@ namespace assignment {
   }
 
   void BinarySearchTree::Insert(int key, int value) {
-    // Write your code here...
+    insert(key, value, root_);
   }
 
   bool BinarySearchTree::Remove(int key) {
-    // Write your code here...
-    return false;
+    return remove(key, root_);
   }
 
   void BinarySearchTree::Clear() {
-    // Write your code here...
+    clear(root_);
+    root_ = nullptr;
   }
 
   std::optional<int> BinarySearchTree::Find(int key) const {
-    // Write your code here...
+    Node* found_node = find(key, root_);
+    if (found_node != nullptr) {
+      return found_node->value;
+    }
     return std::nullopt;
   }
 
   bool BinarySearchTree::Contains(int key) const {
-    // Write your code here...
-    return false;
+    if (find(key, root_) == nullptr) {
+      return false;
+    }
+    return true;
   }
 
   bool BinarySearchTree::IsEmpty() const {
-    return false;
+    return root_ == nullptr;
   }
 
   std::optional<int> BinarySearchTree::FindMin() const {
-    // Write your code here...
+    Node* node = find_min(root_);
+    if (node != nullptr) {
+      return node->key;
+    }
     return std::nullopt;
   }
 
   std::optional<int> BinarySearchTree::FindMax() const {
-    // Write your code here...
+    Node* node = find_max(root_);
+    if (node != nullptr) {
+      return node->key;
+    }
     return std::nullopt;
   }
 
   Node* BinarySearchTree::root() const {
-    return nullptr;
+    return root_;
   }
 
   // вспомогательные методы
 
   void BinarySearchTree::insert(int key, int value, Node*& node) {
-    // Write your code here ...
+    if (node == nullptr) {
+      node = new Node(key, value);
+      return;
+    }
+    if (key > node->key) {
+      return insert(key, value, node->right);
+    }
+    if (key < node->key) {
+      return insert(key, value, node->left);
+    }
+    node->value = value;
   }
 
   bool BinarySearchTree::remove(int key, Node*& node) {
-    // Write your code here...
-    return false;
+    if (node == nullptr) {
+      return false;
+    }
+
+    if (key == node->key) {
+
+      if (node->left != nullptr and node->right != nullptr) {
+        Node* min = find_min(node->right);
+        node->key = min->key;
+        node->value = min->value;
+        return remove(min->key, node->right);
+      }
+
+      if (node->left != nullptr or node->right == nullptr) {
+        Node* left_child = node->left;
+        delete node;
+        node = left_child;
+        return true;
+      }
+
+      Node* right_child = node->right;
+      delete node;
+      node = right_child;
+      return true;
+    }
+
+    if (key > node->key) {
+      return remove(key, node->right);
+    }
+
+    return remove(key, node->left);
   }
 
   void BinarySearchTree::clear(Node* node) {
-    // Write your code here...
+    delete node;
+    //node = nullptr;
   }
 
   Node* BinarySearchTree::find(int key, Node* node) const {
-    // Write your code here...
+    if (node == nullptr) {
+      return nullptr;
+    }
+    if (key == node->key) {
+      return node;
+    }
+    if (key < node->key) {
+      return find(key, node->left);
+    }
+    if (key > node->key) {
+      return find(key, node->right);
+    }
     return nullptr;
   }
 
   Node* BinarySearchTree::find_min(Node* node) const {
-    // Write your code here...
-    return nullptr;
+    if (node == nullptr) {
+      return nullptr;
+    }
+    Node* curr_node = node;
+    while (curr_node->left != nullptr) {
+      curr_node = curr_node->left;
+    }
+    return curr_node;
   }
 
   Node* BinarySearchTree::find_max(Node* node) const {
-    // Write your code here...
-    return nullptr;
-  }
-
-}  // namespace assignment
\ No newline at end of file
+    if (node == nullptr) {
+      return nullptr;
+    }
+    Node* curr_node = node;
+    while (curr_node->right != nullptr) {
+      curr_node = curr_node->right;
+    }
+    return curr_node;
+  }
+}
\ No newline at end of file