diff --git a/README.md b/README.md
index 55766c0..cd57e82 100644
--- a/README.md
+++ b/README.md
@@ -5,9 +5,9 @@
 
 ## 1. Информация о студенте
 
-**Номер группы**: 00-000
+**Номер группы**: 11-109
 
-**Фамилия и Имя**: Иванов Иван
+**Фамилия и Имя**: Краденова Дарья
 
 ## 2. Описание задания
 
diff --git a/src/heap_sort.cpp b/src/heap_sort.cpp
index d57f66c..ffcb9a4 100644
--- a/src/heap_sort.cpp
+++ b/src/heap_sort.cpp
@@ -8,11 +8,13 @@ namespace assignment {
   void HeapSort::Sort(std::vector<int>& arr) const {
 
     // строим двоичную кучу ... BuildMaxHeap ...
-
+    BuildMaxHeap(arr);
     // обходим элементы кучи с конца до корня (не включительно)
     for (int index = static_cast<int>(arr.size()) - 1; index > 0; index--) {
       // обмениваем местами корень (максимальный элемент) и последний элемент кучи ... std::swap ...
+      std::swap(arr[0], arr[index]);
       // спускаем новый корневой узел вниз ... Heapify ...
+      Heapify(arr, index, 0);
     }
   }
 
@@ -24,6 +26,9 @@ namespace assignment {
     // - индекс идет до корня (включительно)
 
     const int size = static_cast<int>(arr.size());
+    for (int i = size / 2 - 1; i >= 0; i--) {
+      Heapify(arr, size, i);
+    }
 
     // Напишите здесь свой код ...
   }
@@ -32,23 +37,28 @@ namespace assignment {
     assert(heap_size >= 0 && heap_size <= arr.size() && index >= 0 && index < heap_size);
 
     // максимальный элемент устанавливаем в значение текущего индекса
-    for (int largest = index; largest < heap_size; /* ... */) {
+    for (int large = index; large < heap_size;) {
 
       // вычисляем индексы потомков для текущего элемента
       const int left_child = LeftChild(index);
       const int right_child = RightChild(index);
 
       // поиск наибольшего элемента среди текущего элемента и его потомков ...
-
+      if (left_child < heap_size and arr[left_child] > arr[large]) {
+        large = left_child;
+      }
+      if (right_child < heap_size and arr[right_child] > arr[large]) {
+        large = right_child;
+      }
       // если текущий элемент больше своих потомков, то он находится на правильном месте (свойство макс. кучи)
-      if (largest == index) {
+      if (large == index) {
         return;  // завершаем спуск
       }
 
       // обмениваем местами текущий элемент с его потомком ... std::swap ...
-
+      std::swap(arr[large], arr[index]);
       // продолжаем спуск c нового места (после операции обмена местами)
-      index = -1 /* здесь какая-то ошибка ... */;
+      index = large;
     }
   }
 
@@ -67,4 +77,4 @@ namespace assignment {
     return 2 * index + 2;
   }
 
-}  // namespace assignment
+}  // namespace assignment
\ No newline at end of file
diff --git a/src/insertion_sort.cpp b/src/insertion_sort.cpp
index f0c182f..5cde228 100644
--- a/src/insertion_sort.cpp
+++ b/src/insertion_sort.cpp
@@ -9,37 +9,45 @@ namespace assignment {
   int linear_search(const std::vector<int>& arr, int index) {
 
     // итерация всех предыдущих элементов [0, index - 1] (они находятся в отсортированном порядке)
-    for (int curr_pos = -1 /* ... */; false /* условие ... */; /* обновление curr_pos ... */) {
+    for (int cur = 0; index > cur;
+         cur++) {
 
-      // если текущий элемент меньше или равен вставляемому, позиция для вставки найдена ...
+      if (arr[cur] >= arr[index]) {
+        return cur;
+      }
     }
 
-    return -1;  // здесь что-то не так ...
+    return index;
   }
 
   int binary_search(const std::vector<int>& arr, int index) {
 
     // начало, конец и середина области поиска места для вставки [0, index - 1]
-    int start = -1 /* здесь что-то не так ... */;
-    int stop = -1 /* здесь что-то не так ... */;
-    int middle = -1 /* здесь что-то не так ... */;
+    int start = 0;
+    int stop = index;
+    int middle = middle_of(start, stop) ;
 
     // ищем до тех пор, пока границы не схлопнулись
     while (start <= stop) {
 
       // возвращаем позицию для вставки
       if (arr[index] == arr[middle]) {
-        return -1 /* здесь что-то не так ... */;
+        return middle;
       }
 
       // обновляем границы области поиска ...
+      if (arr[index] < arr[middle]) {
+        stop = middle - 1;
+      } else {
+        start = middle + 1;
+      }
 
       // обновляем середину области поиска
-      middle = middle_of(-1, -1);  // здесь что-то не так ...
+      middle = middle_of(start, stop);
     }
 
     // в конечном счете возвращаем начало последней области поиска
-    return -1;  // здесь что-то не так ...
+    return start;  // здесь что-то не так ...
   }
 
   void InsertionSort::Sort(std::vector<int>& arr) const {
@@ -50,11 +58,15 @@ namespace assignment {
     for (int index = 1; index < static_cast<int>(arr.size()); index++) {
 
       // поиск индекса для вставки элемента с индексом index в область [0, index - 1]
-      const int ins_index = searcher_(arr, index);
-
-      // если индекс вставки не совпадает с текущей позицией элемента,
-      // производим вставку элемента на вычисленную позицию (std::copy или цикл for) ...
+      const int pos = searcher_(arr, index);
+      if (pos != index) {
+        for (int i = index; pos < i; i--) {
+          std::swap(arr[i], arr[i - 1]);
+        }
+      }
     }
+    // если индекс вставки не совпадает с текущей позицией элемента,
+    // производим вставку элемента на вычисленную позицию (std::copy или цикл for) ...
   }
 
   InsertionSort::InsertionSort(Searcher searcher) : searcher_{std::move(searcher)} {}
diff --git a/src/merge_sort.cpp b/src/merge_sort.cpp
index c6ad3ab..73c097b 100644
--- a/src/merge_sort.cpp
+++ b/src/merge_sort.cpp
@@ -10,7 +10,7 @@ namespace assignment {
     // буфер памяти для операции слияния (merge)
     std::vector<int> buf(arr.size());
 
-    // забыл что-то здесь вызвать ...
+    merge_sort(arr, 0, static_cast<int>(arr.size()) - 1, buf);
   }
 
   void MergeSort::merge_sort(std::vector<int>& arr, int start, int stop, std::vector<int>& buf) const {
@@ -21,10 +21,13 @@ namespace assignment {
     }
 
     // вычисляем индекс середины области
-    const int middle = middle_of(start, stop);
+    const int mid = middle_of(start, stop);
 
-    // рекурсивный вызов сортировки левой [start, middle] и правой [middle + 1, stop] подмассивов ...
-    // слияния двух подмассивов [start, middle] и [middle + 1, stop] ...
+    //. рекурсивный вызов сортировки левой [start, middle] и правой [middle + 1, stop] подмассивов ...
+    //    // слияния двух подмассивов [start, middle] и [middle + 1, stop] ..
+    merge_sort(arr, start, mid, buf);
+    merge_sort(arr, mid + 1, stop, buf);
+    merge(arr, start, mid, stop, buf);
   }
 
-}  // namespace assignment
+}  // namespace assignment
\ No newline at end of file
diff --git a/src/merging.cpp b/src/merging.cpp
index b5e49d7..d0d6c83 100644
--- a/src/merging.cpp
+++ b/src/merging.cpp
@@ -13,26 +13,37 @@ namespace assignment {
     int right_offset = middle + 1;
 
     // индекс текущей позиции буфера (туда будут сливаться подмассивы)
-    int buf_offset = -1 /* здесь что-то не так */;
+    int buf_offset = start;
 
     // слияния подмассивов (пока не достигли конца одного из подмассивов)
     while (left_offset <= middle && right_offset <= stop) {
-
       // копируем элемент с наименьшим значением в буфер ...
-
+      if (arr[left_offset] >= arr[right_offset]) {
+        buf[buf_offset] = arr[right_offset];
+        right_offset += 1;
+      } else {
+        buf[buf_offset] = arr[left_offset];
+        left_offset += 1;
+      }
       // перемещаем текущую позицию вставки в буфер
       buf_offset += 1;
     }
 
     // сливаем остатки подмассивов (останутся элементы только одного из двух подмассивов)
-    for (/* ... */; left_offset <= middle; left_offset++) {
-      buf[buf_offset] = arr[left_offset];
+    for (int i = left_offset; i <= middle; i++) {
+      buf[buf_offset] = arr[i];
       buf_offset += 1;
     }
 
     // реализуйте сливание остатков правого подмассива ...
-
+    for (int i = right_offset; i <= stop; i++) {
+      buf[buf_offset] = arr[i];
+      buf_offset += 1;
+    }
     // копируем результат слияния подмассивов из буфера в оригинальный массив ... std::copy или цикл for ...
+    for (int i = 0; i <= stop; i ++ ){
+      arr[i] = buf[i];
+    }
   }
 
 }  // namespace assignment
\ No newline at end of file
diff --git a/src/partitioning.cpp b/src/partitioning.cpp
index e706327..f1aeeb3 100644
--- a/src/partitioning.cpp
+++ b/src/partitioning.cpp
@@ -18,13 +18,22 @@ namespace assignment {
     }
 
     // вычисляем индекс середины заданной области
-    const int middle = middle_of(start, stop);
+    const int mid = middle_of(start, stop);
 
     // поиск медианы среди трех элементов по индексам start, middle и stop
 
     // Здесь должна быть ваша реализация ...
+    int mas[3] = {start, mid, stop};
+    for (int i = 1; i < 3; i++) {
+      int j = i;
+      while (j > 0 and mas[j - 1] > mas[i]) {
+        std::swap(mas[j], mas[i]);
+        j -= 1;
+      }
+
+    }
 
-    return -1 /* здесь что-то не так ... */;
+    return mas[1];
   }
 
   int partition(std::vector<int>& arr, int start, int stop, int pivot) {
@@ -40,27 +49,28 @@ namespace assignment {
     //    переместите опорный элемент на корректную позицию.
 
     // значение опорного элемента
-    const int pivot_value = arr[pivot];
+    const int pivo_value = arr[pivot];
 
     // переместить опорный элемент в конец (чтобы не мешался)
     std::swap(arr[pivot], arr[stop]);
 
     // индекс опорного элемента (будет вычисляться далее, изначально находится в начале области)
-    int curr_pivot_index = start;
+    int curr_pivo_index = start;
 
     // вычисление индекса опорного элемента и перемещение элементов по правилу разбиения
     for (int index = start; index < stop; index++) {
 
-      if (arr[index] < pivot_value) {
-        // Напишите здесь ваш код ...
+      if (arr[index] < pivo_value) {
+        std::swap(arr[curr_pivo_index], arr[index]);
+        curr_pivo_index++;
       }
     }
 
     // разбиение завершилось, перемещаем выбранный опорный элемент на вычисленное ранее место
-    std::swap(arr[curr_pivot_index], arr[stop]);
+    std::swap(arr[curr_pivo_index], arr[stop]);
 
     // возвращаем индекс опорного элемента
-    return -1 /* здесь что-то не так ... */;
+    return curr_pivo_index;
   }
 
 }  // namespace assignment
\ No newline at end of file
diff --git a/src/quick_sort.cpp b/src/quick_sort.cpp
index 202e6d4..790f58f 100644
--- a/src/quick_sort.cpp
+++ b/src/quick_sort.cpp
@@ -18,10 +18,12 @@ namespace assignment {
     }
 
     // вычисляем индекс опорного элемента ... median_of_three ...
-    int pivot_index = -1 /* напишите здесь свой код ... */;
-
+    int mid = median_of_three(arr, start, stop);
     // производим разбиение относительно опорного элемента ...  partition ...
+    int pivo_index = partition(arr, start, stop, mid);
     // рекурсивно повторяем процедуру над левой и правой частью ...
+    quick_sort(arr, start, pivo_index - 1);
+    quick_sort(arr, pivo_index + 1, stop);
   }
 
-}  // namespace assignment
+}  // namespace assignment
\ No newline at end of file