From 51660ab292166f57ba3770532b173a379281d106 Mon Sep 17 00:00:00 2001
From: "github-classroom[bot]"
 <66690702+github-classroom[bot]@users.noreply.github.com>
Date: Fri, 25 Mar 2022 11:05:15 +0000
Subject: [PATCH 1/3] Setting up GitHub Classroom Feedback


From bcdaf97c2e853c98ea17bed3611a572442ba3322 Mon Sep 17 00:00:00 2001
From: KamaL145 <niyaz.kamalov.21@gmail.com>
Date: Thu, 14 Apr 2022 20:16:11 +0300
Subject: [PATCH 2/3] =?UTF-8?q?homework=20=E2=84=963?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 README.md                  |   4 +-
 src/binary_search_tree.cpp | 120 ++++++++++++++++++++++++++++---------
 2 files changed, 95 insertions(+), 29 deletions(-)

diff --git a/README.md b/README.md
index 5f20c87..c3319bd 100644
--- a/README.md
+++ b/README.md
@@ -5,9 +5,9 @@
 
 ## 1. Информация о студенте
 
-**Номер группы**: 00-000
+**Номер группы**: 11-104
 
-**Фамилия и Имя**: Иванов Иван
+**Фамилия и Имя**: Камалов Нияз
 
 ## 2. Описание задания
 
diff --git a/src/binary_search_tree.cpp b/src/binary_search_tree.cpp
index 24042ff..20b0b97 100644
--- a/src/binary_search_tree.cpp
+++ b/src/binary_search_tree.cpp
@@ -7,74 +7,140 @@ 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_->left);
+    clear(root_->right);
+    delete root_;
   }
 
   std::optional<int> BinarySearchTree::Find(int key) const {
-    // Write your code here...
-    return std::nullopt;
+    Node* node = find(key, root_);
+
+    if (node == nullptr) {
+      return std::nullopt;
+    }
+    return node->value;
   }
 
   bool BinarySearchTree::Contains(int key) const {
-    // Write your code here...
-    return false;
+    return Find(key).has_value();
   }
 
   bool BinarySearchTree::IsEmpty() const {
-    return false;
+    return root_ == nullptr;
   }
 
   std::optional<int> BinarySearchTree::FindMin() const {
-    // Write your code here...
-    return std::nullopt;
+    Node* min_node = find_min(root_);
+
+    if (min_node == nullptr) {
+      return std::nullopt;
+    }
+    return min_node->key;
   }
 
   std::optional<int> BinarySearchTree::FindMax() const {
-    // Write your code here...
-    return std::nullopt;
+    Node* max_node = find_min(root_);
+
+    if (max_node == nullptr) {
+      return std::nullopt;
+    }
+    return max_node->key;
   }
 
   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) {
+      node->value = value;
+      return;
+    }
+    if (key < node->key) {
+      insert(key, value, node->left);
+    } else if (key > node->key) {
+      insert(key, value, node->right);
+    }
   }
 
   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 && node->right != nullptr) {
+        Node* min = find_min(node->right);
+        node->key = min->key;
+        return remove(min->key, node->right);
+      }
+      Node* right_node = node->right;
+      delete node;
+      node = right_node;
+      return true;
+    }
+    if (key < node->key) {
+      return remove(key, node->left);
+    }
+    if (key > node->key) {
+      return remove(key, node->right);
+    }
+    return true;
   }
 
   void BinarySearchTree::clear(Node* node) {
-    // Write your code here...
+    if (node != nullptr) {
+      clear(node->left);
+      clear(node->right);
+      delete node;
+    }
   }
 
   Node* BinarySearchTree::find(int key, Node* node) const {
-    // Write your code here...
-    return nullptr;
+    if (node == nullptr) {
+      return nullptr;
+    }
+    if (node->key == key) {
+      return node;
+    }
+    if (key < node->key) {
+      return find(key, node->left);
+    }
+    return find(key, node->right);
   }
 
   Node* BinarySearchTree::find_min(Node* node) const {
-    // Write your code here...
-    return nullptr;
+    if (node == nullptr) {
+      return nullptr;
+    }
+    if (node->left == nullptr) {
+      return node;
+    }
+    return find_min(node->left);
   }
 
   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;
+    }
+    if (node->right == nullptr) {
+      return node;
+    }
+    return find_max(node->right);
+  }
+}
+  // namespace assignment
\ No newline at end of file

From d30c4211714c024d784e178b7b81c7d28dd81f3a Mon Sep 17 00:00:00 2001
From: KamaL145 <niyaz.kamalov.21@gmail.com>
Date: Wed, 7 Sep 2022 15:39:01 +0300
Subject: [PATCH 3/3] add

---
 src/binary_search_tree.cpp | 199 +++++++++++++++++++++++++++----------
 1 file changed, 148 insertions(+), 51 deletions(-)

diff --git a/src/binary_search_tree.cpp b/src/binary_search_tree.cpp
index 20b0b97..472b205 100644
--- a/src/binary_search_tree.cpp
+++ b/src/binary_search_tree.cpp
@@ -7,25 +7,83 @@ namespace assignment {
   }
 
   void BinarySearchTree::Insert(int key, int value) {
-    insert(key, value, root_);
+    if (root_ == nullptr) {
+      root_ = new Node(key, value);
+      return;
+    }
+
+    Node* node = root_;
+    while (true) {
+      if (key == node->key) {
+        node->value = value;
+        return;
+      }
+
+      if (key > node->key) {
+        if (node->right == nullptr) {
+          node->right = new Node(key, value);
+          return;
+        }
+
+        node = node->right;
+      } else {
+        if (node->left == nullptr) {
+          node->left = new Node(key, value);
+          return;
+        }
+
+        node = node->left;
+      }
+    }
   }
 
   bool BinarySearchTree::Remove(int key) {
+    if (root_ == nullptr) {
+      return false;
+    }
+
+    if (root_->key == key) {
+      if (root_->left == nullptr && root_->right == nullptr) {
+        delete root_;
+        root_ = nullptr;
+        return true;
+      }
+
+      if (root_->right == nullptr) {
+        Node* new_root = root_->left;
+        delete root_;
+        root_ = new_root;
+        return true;
+      }
+
+      if (root_->left == nullptr) {
+        Node* new_root = root_->right;
+        delete root_;
+        root_ = new_root;
+        return true;
+      }
+
+      Node to_replace = *find_min(root_->right);
+      Remove(to_replace.key);
+      root_->key = to_replace.key;
+      root_->value = to_replace.value;
+      return true;
+    }
+
     return remove(key, root_);
   }
 
   void BinarySearchTree::Clear() {
-    clear(root_->left);
-    clear(root_->right);
-    delete root_;
+    clear(root_);
+    root_ = nullptr;
   }
 
   std::optional<int> BinarySearchTree::Find(int key) const {
     Node* node = find(key, root_);
-
     if (node == nullptr) {
       return std::nullopt;
     }
+
     return node->value;
   }
 
@@ -38,21 +96,19 @@ namespace assignment {
   }
 
   std::optional<int> BinarySearchTree::FindMin() const {
-    Node* min_node = find_min(root_);
-
-    if (min_node == nullptr) {
+    Node* node = find_min(root_);
+    if (node == nullptr) {
       return std::nullopt;
     }
-    return min_node->key;
+    return node->key;
   }
 
   std::optional<int> BinarySearchTree::FindMax() const {
-    Node* max_node = find_min(root_);
-
-    if (max_node == nullptr) {
+    Node* node = find_max(root_);
+    if (node == nullptr) {
       return std::nullopt;
     }
-    return max_node->key;
+    return node->key;
   }
 
   Node* BinarySearchTree::root() const {
@@ -61,51 +117,85 @@ namespace assignment {
 
   // вспомогательные методы
 
-  void BinarySearchTree::insert(int key, int value, Node*& node) {
-    if (node == nullptr) {
-      node = new Node(key, value);
-      return;
-    }
-
-    if (key == node->key) {
-      node->value = value;
-      return;
-    }
-    if (key < node->key) {
-      insert(key, value, node->left);
-    } else if (key > node->key) {
-      insert(key, value, node->right);
-    }
-  }
+  //  void BinarySearchTree::insert(int key, int value, Node*& node) {
+  //    // Write your code here ...
+  //  }
 
   bool BinarySearchTree::remove(int key, Node*& node) {
     if (node == nullptr) {
       return false;
     }
-    if (key == node->key) {
-      if (node->left != nullptr && node->right != nullptr) {
-        Node* min = find_min(node->right);
-        node->key = min->key;
-        return remove(min->key, node->right);
-      }
-      Node* right_node = node->right;
-      delete node;
-      node = right_node;
-      return true;
-    }
-    if (key < node->key) {
-      return remove(key, node->left);
-    }
+
     if (key > node->key) {
-      return remove(key, node->right);
+      if (key != node->right->key) {
+        return remove(key, node->right);
+      }
+      Node * child = node->right;
+      if (child->left == nullptr && child->right == nullptr) {
+        delete child;
+        node->right = nullptr;
+        return true;
+      }
+
+      if (child->right == nullptr) {
+        Node* new_root = child->left;
+        delete child;
+        node->right = new_root;
+        return true;
+      }
+
+      if (child->left == nullptr) {
+        Node* new_root = child->right;
+        delete child;
+        node->right = new_root;
+        return true;
+      }
+
+      Node to_replace = *find_min(child->right);
+      remove(to_replace.key, node);
+      child->key = to_replace.key;
+      child->value = to_replace.value;
+    } else {
+      if (key != node->left->key) {
+        return remove(key, node->left);
+      }
+      Node * child = node->left;
+      if (child->left == nullptr && child->right == nullptr) {
+        delete child;
+        node->left = nullptr;
+        return true;
+      }
+
+      if (child->right == nullptr) {
+        Node* new_root = child->left;
+        delete child;
+        node->left = new_root;
+        return true;
+      }
+
+      if (child->left == nullptr) {
+        Node* new_root = child->right;
+        delete child;
+        node->left = new_root;
+        return true;
+      }
+
+      Node to_replace = *find_min(child->right);
+      remove(to_replace.key, node);
+      child->key = to_replace.key;
+      child->value = to_replace.value;
     }
     return true;
   }
 
   void BinarySearchTree::clear(Node* node) {
     if (node != nullptr) {
-      clear(node->left);
-      clear(node->right);
+      if (node->left != nullptr) {
+        clear(node->left);
+      }
+      if (node->right != nullptr) {
+        clear(node->right);
+      }
       delete node;
     }
   }
@@ -114,22 +204,27 @@ namespace assignment {
     if (node == nullptr) {
       return nullptr;
     }
+
     if (node->key == key) {
       return node;
     }
-    if (key < node->key) {
-      return find(key, node->left);
+
+    if (key > node->key) {
+      return find(key, node->right);
     }
-    return find(key, node->right);
+
+    return find(key, node->left);
   }
 
   Node* BinarySearchTree::find_min(Node* node) const {
     if (node == nullptr) {
       return nullptr;
     }
+
     if (node->left == nullptr) {
       return node;
     }
+
     return find_min(node->left);
   }
 
@@ -137,10 +232,12 @@ namespace assignment {
     if (node == nullptr) {
       return nullptr;
     }
+
     if (node->right == nullptr) {
       return node;
     }
+
     return find_max(node->right);
   }
-}
-  // namespace assignment
\ No newline at end of file
+
+}  // namespace assignment
\ No newline at end of file