All problem fixed

Author: Matvey-cmd

task_02/src/stack.cpp

@@ -15,37 +15,37 @@ void Stack::Push(int value) {
 
 int Stack::Pop() {
   if (top == nullptr) {
-    throw std::logic_error("Out_of_range");
+    throw std::logic_error("Stack_is_empty");
   }
   int val = top->value;
   top = top->next;
   return val;
 }
 
 void MinStack::Push(int value) {
-  if (st1_.top == nullptr) {
-    st1_.Push(value);
-    st2_.Push(value);
+  if (stack_.top == nullptr) {
+    stack_.Push(value);
+    min_stack_.Push(value);
     return;
   }
 
-  if (st1_.top->value > value) {
-    st2_.Push(value);
+  if (stack_.top->value > value) {
+    min_stack_.Push(value);
   } else {
-    st1_.Push(value);
-    st2_.Push(st2_.top->value);
+    stack_.Push(value);
+    min_stack_.Push(min_stack_.top->value);
   }
 }
 
 int MinStack::Pop() {
-  if (st1_.top == nullptr) {
-    throw std::logic_error("Out_of_range");
+  if (stack_.top == nullptr) {
+    throw std::logic_error("Stack_is_empty");
   }
 
-  int val = st1_.top->value;
-  st1_.top = st1_.top->next;
-  st2_.top = st2_.top->next;
+  int val = stack_.top->value;
+  stack_.top = stack_.top->next;
+  min_stack_.top = min_stack_.top->next;
   return val;
 }
 
-int MinStack::GetMin() { return st2_.top->value; }
+int MinStack::GetMin() { return min_stack_.top->value; }

task_02/src/stack.hpp

@@ -23,6 +23,6 @@ class MinStack {
   int GetMin();
 
  private:
-  Stack st1_;
-  Stack st2_;
+  Stack stack_;
+  Stack min_stack_;
 };

task_05/src/sort.cpp

@@ -16,11 +16,11 @@ int Partition(std::vector<int> &arr, int low, int high) {
   return (i + 1);
 }
 
-std::vector<int> Quick_Sort(std::vector<int> &arr, int low, int high) {
+std::vector<int> QuickSort(std::vector<int> &arr, int low, int high) {
   if (low < high) {
     int m = Partition(arr, low, high);
-    Quick_Sort(arr, low, m - 1);
-    Quick_Sort(arr, m + 1, high);
+    QuickSort(arr, low, m - 1);
+    QuickSort(arr, m + 1, high);
   }
   return arr;
 }

task_05/src/sort.hpp

@@ -4,4 +4,4 @@
 
 int Partition(std::vector<int> &arr, int low, int high);
 
-std::vector<int> Quick_Sort(std::vector<int> &arr, int low, int high);
+std::vector<int> QuickSort(std::vector<int> &arr, int low, int high);

task_05/src/test.cpp

@@ -4,78 +4,78 @@
 
 #include "sort.hpp"
 
-TEST(Quick_Sort, Simple) {
+TEST(QuickSort, Simple) {
   std::vector<int> vec1{9, 8, 7, 6, 5, 4, 2, 3, 1, 0};
-  ASSERT_EQ(Quick_Sort(vec1, 0, 9),
+  ASSERT_EQ(QuickSort(vec1, 0, 9),
             (std::vector<int>{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}));
   std::vector<int> vec2{10, 90, 30, 80, 60, 50};
-  ASSERT_EQ(Quick_Sort(vec2, 0, 5), (std::vector<int>{10, 30, 50, 60, 80, 90}));
+  ASSERT_EQ(QuickSort(vec2, 0, 5), (std::vector<int>{10, 30, 50, 60, 80, 90}));
   std::vector<int> vec3{12,  43,  15, 26, -1233, 346, 1325,
                         -56, -12, 78, 0,  3345,  -34};
-  ASSERT_EQ(Quick_Sort(vec3, 0, 12),
+  ASSERT_EQ(QuickSort(vec3, 0, 12),
             (std::vector<int>{-1233, -56, -34, -12, 0, 12, 15, 26, 43, 78, 346,
                               1325, 3345}));
   vec3.push_back(-10);
   vec3.push_back(1000);
   vec3.push_back(5);
-  ASSERT_EQ(Quick_Sort(vec3, 0, 15),
+  ASSERT_EQ(QuickSort(vec3, 0, 15),
             (std::vector<int>{-1233, -56, -34, -12, -10, 0, 5, 12, 15, 26, 43,
                               78, 346, 1000, 1325, 3345}));
 }
 
 // Тестирование сортировки пустого вектора
-TEST(Quick_Sort, EmptyVector) {
+TEST(QuickSort, EmptyVector) {
   std::vector<int> vec;
-  ASSERT_EQ(Quick_Sort(vec, 0, vec.size() - 1), (std::vector<int>{}));
+  ASSERT_EQ(QuickSort(vec, 0, vec.size() - 1), (std::vector<int>{}));
 }
 
 // Тестирование сортировки вектора с одним элементом
-TEST(Quick_Sort, SingleElement) {
+TEST(QuickSort, SingleElement) {
   std::vector<int> vec{1};
-  ASSERT_EQ(Quick_Sort(vec, 0, vec.size() - 1), (std::vector<int>{1}));
+  ASSERT_EQ(QuickSort(vec, 0, vec.size() - 1), (std::vector<int>{1}));
 }
 
 // Тестирование сортировки вектора с повторяющимися элементами
-TEST(Quick_Sort, RepeatedElements) {
+TEST(QuickSort, RepeatedElements) {
   std::vector<int> vec{5, 5, 5, 5};
-  ASSERT_EQ(Quick_Sort(vec, 0, vec.size() - 1), (std::vector<int>{5, 5, 5, 5}));
+  ASSERT_EQ(QuickSort(vec, 0, vec.size() - 1), (std::vector<int>{5, 5, 5, 5}));
 }
 
 // Тестирование сортировки вектора с отрицательными и положительными числами
-TEST(Quick_Sort, MixedNumbers) {
+TEST(QuickSort, MixedNumbers) {
   std::vector<int> vec{-1, 3, -2, 5, 4, -3};
-  ASSERT_EQ(Quick_Sort(vec, 0, vec.size() - 1),
+  ASSERT_EQ(QuickSort(vec, 0, vec.size() - 1),
             (std::vector<int>{-3, -2, -1, 3, 4, 5}));
 }
 
 // Тестирование сортировки вектора с уже отсортированными элементами
-TEST(Quick_Sort, AlreadySorted) {
+TEST(QuickSort, AlreadySorted) {
   std::vector<int> vec{1, 2, 3, 4, 5};
-  ASSERT_EQ(Quick_Sort(vec, 0, vec.size() - 1),
+  ASSERT_EQ(QuickSort(vec, 0, vec.size() - 1),
             (std::vector<int>{1, 2, 3, 4, 5}));
 }
 
 // Тестирование сортировки вектора с элементами в обратном порядке
-TEST(Quick_Sort, ReverseOrder) {
+TEST(QuickSort, ReverseOrder) {
   std::vector<int> vec{5, 4, 3, 2, 1};
-  ASSERT_EQ(Quick_Sort(vec, 0, vec.size() - 1),
+  ASSERT_EQ(QuickSort(vec, 0, vec.size() - 1),
             (std::vector<int>{1, 2, 3, 4, 5}));
 }
 
 // Тестирование сортировки вектора с нулями и отрицательными числами
-TEST(Quick_Sort, ZerosAndNegatives) {
+TEST(QuickSort, ZerosAndNegatives) {
   std::vector<int> vec{0, -1, 0, -2, 0, -3};
-  ASSERT_EQ(Quick_Sort(vec, 0, vec.size() - 1),
+  ASSERT_EQ(QuickSort(vec, 0, vec.size() - 1),
             (std::vector<int>{-3, -2, -1, 0, 0, 0}));
 }
 
 // Тестирование сортировки вектора с большим количеством элементов
-TEST(Quick_Sort, LargeArray) {
+TEST(QuickSort, LargeArray) {
   std::vector<int> vec(1000);
   std::iota(vec.begin(), vec.end(),
             -500);  // Заполнение вектора числами от -500 до 499
   std::random_shuffle(vec.begin(), vec.end());  // Перемешивание элементов
   std::vector<int> sorted_vec(vec);
   std::sort(sorted_vec.begin(), sorted_vec.end());
-  ASSERT_EQ(Quick_Sort(vec, 0, vec.size() - 1), sorted_vec);
+  ASSERT_EQ(QuickSort(vec, 0, vec.size() - 1), sorted_vec);
 }

task_07/src/AVL_Tree.cpp

@@ -62,9 +62,9 @@ Node *AVL_Tree::Findmin(Node *right_subtree) {
   return right_subtree->left ? Findmin(right_subtree->left) : right_subtree;
 }
 
-Node *AVL_Tree::Removemin(Node *p) {
+Node *AVL_Tree::RemoveMin(Node *p) {
   if (p->left == nullptr) return p->right;
-  p->left = Removemin(p->left);
+  p->left = RemoveMin(p->left);
   return p;
 }
 
@@ -80,7 +80,7 @@ Node *AVL_Tree::Remove(Node *p, int k) {
     delete p;
     if (!p_right) return p_left;
     Node *min = Findmin(p_right);
-    min->right = Removemin(p_right);
+    min->right = RemoveMin(p_right);
     min->left = p_left;
     return Balance(min);
   }

task_07/src/AVL_Tree.hpp

@@ -27,7 +27,7 @@ class AVL_Tree {
   Node *Rotateleft(Node *q);
   Node *Balance(Node *p);
   Node *Findmin(Node *right_subtree);
-  Node *Removemin(Node *p);
+  Node *RemoveMin(Node *p);
   unsigned char Height(Node *p);
   int DifferenceH(Node *p);
   void Fixheight(Node *p);

task_08/src/hash_table.cpp

@@ -8,20 +8,12 @@
 size_t HashTable::Size() { return size_; }
 
 size_t HashTable::FirstHashFunc(int key) {
-  if constexpr (std::is_arithmetic<int>::value) {
-    return floor(buffers_size_ *
-                 ((key * hashCoefficient) - floor(key * hashCoefficient)));
-  }
-  throw std::invalid_argument(
-      "Hash table cannot cannot work with it with an arithmetic data type");
+  return floor(buffers_size_ *
+               ((key * hashCoefficient) - floor(key * hashCoefficient)));
 }
 
 size_t HashTable::SecondHashFunc(int key) {
-  if constexpr (std::is_arithmetic<int>::value) {
-    return (key * buffers_size_ - 1) % buffers_size_;
-  }
-  throw std::invalid_argument(
-      "Hash table cannot cannot work with it with an arithmetic data type");
+  return (key * buffers_size_ - 1) % buffers_size_;
 }
 
 void HashTable::Clear() {