Feedback

README.md

@@ -5,9 +5,9 @@
 
 ## 1. Информация о студенте
 
-**Номер группы**: 00-000
+**Номер группы**: 11-109
 
-**Фамилия и Имя**: Иванов Иван
+**Фамилия и Имя**: Салимов Радмир
 
 ## 2. Описание задания
 

src/heap_sort.cpp

@@ -8,9 +8,11 @@ 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(arr[0], arr[index]);
+      Heapify(arr, index, 0);
       // обмениваем местами корень (максимальный элемент) и последний элемент кучи ... std::swap ...
       // спускаем новый корневой узел вниз ... Heapify ...
     }
@@ -25,7 +27,9 @@ namespace assignment {
 
     const int size = static_cast<int>(arr.size());
 
-    // Напишите здесь свой код ...
+    for (int i = size / 2 - 1; i >= 0; i--) {
+      Heapify(arr, size, i);
+    }
   }
 
   void HeapSort::Heapify(std::vector<int>& arr, int heap_size, int index) {
@@ -39,16 +43,22 @@ namespace assignment {
       const int right_child = RightChild(index);
 
       // поиск наибольшего элемента среди текущего элемента и его потомков ...
+      if (left_child < heap_size and arr[left_child] > arr[largest]) {
+        largest = left_child;
+      }
 
+      if (right_child < heap_size and arr[right_child] > arr[largest]) {
+        largest = right_child;
+      }
       // если текущий элемент больше своих потомков, то он находится на правильном месте (свойство макс. кучи)
       if (largest == index) {
         return;  // завершаем спуск
       }
 
       // обмениваем местами текущий элемент с его потомком ... std::swap ...
-
+      std::swap(arr[index], arr[largest]);
       // продолжаем спуск c нового места (после операции обмена местами)
-      index = -1 /* здесь какая-то ошибка ... */;
+      index = largest;
     }
   }
 

src/insertion_sort.cpp

@@ -9,37 +9,47 @@ 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 curr_pos = index - 1; curr_pos >= 0; curr_pos--) {
 
       // если текущий элемент меньше или равен вставляемому, позиция для вставки найдена ...
+      if (arr[curr_pos] <= arr[index]){
+        return curr_pos + 1;
+      }
     }
 
-    return -1;  // здесь что-то не так ...
+    return 0;  // здесь что-то не так ...
   }
 
   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-1 /* здесь что-то не так ... */;
+    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 {
@@ -54,6 +64,13 @@ namespace assignment {
 
       // если индекс вставки не совпадает с текущей позицией элемента,
       // производим вставку элемента на вычисленную позицию (std::copy или цикл for) ...
+      if (ins_index != index) {
+        int index_elem = arr[index];
+        for (int i = index; i > ins_index; i--) {
+          arr[i] = arr[i - 1];
+        }
+        arr[ins_index] = index_elem;
+      }
     }
   }
 

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 {
@@ -23,6 +23,9 @@ namespace assignment {
     // вычисляем индекс середины области
     const int middle = middle_of(start, stop);
 
+    merge_sort(arr, start, middle, buf);
+    merge_sort(arr, middle + 1, stop, buf);
+    merge(arr, start, middle, stop, buf);
     // рекурсивный вызов сортировки левой [start, middle] и правой [middle + 1, stop] подмассивов ...
     // слияния двух подмассивов [start, middle] и [middle + 1, stop] ...
   }

src/merging.cpp

@@ -13,13 +13,20 @@ 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[left_offset];
+        left_offset++;
+      }
+      else {
+        buf[buf_offset] = arr[right_offset];
+        right_offset++;
+      }
       // перемещаем текущую позицию вставки в буфер
       buf_offset += 1;
     }
@@ -31,7 +38,13 @@ namespace assignment {
     }
 
     // реализуйте сливание остатков правого подмассива ...
-
+    for (; right_offset <= stop; right_offset++) {
+      buf[buf_offset] = arr[right_offset];
+      buf_offset++;
+    }
+    for (int i = start; i <= stop; i++) {
+      arr[i] = buf[i];
+    }
     // копируем результат слияния подмассивов из буфера в оригинальный массив ... std::copy или цикл for ...
   }
 

src/partitioning.cpp

@@ -23,8 +23,11 @@ namespace assignment {
     // поиск медианы среди трех элементов по индексам start, middle и stop
 
     // Здесь должна быть ваша реализация ...
+    int maximum = start > middle? start > stop? start:stop: middle > stop? middle:stop;
+    int first_not_max = start == maximum? middle:start;
+    int second_not_max = stop == maximum? middle:stop;
 
-    return -1 /* здесь что-то не так ... */;
+    return first_not_max < second_not_max? second_not_max:first_not_max /* здесь что-то не так ... */;
   }
 
   int partition(std::vector<int>& arr, int start, int stop, int pivot) {
@@ -52,15 +55,16 @@ namespace assignment {
     for (int index = start; index < stop; index++) {
 
       if (arr[index] < pivot_value) {
-        // Напишите здесь ваш код ...
+        std::swap(arr[curr_pivot_index], arr[index]);
+        curr_pivot_index += 1;
       }
     }
 
     // разбиение завершилось, перемещаем выбранный опорный элемент на вычисленное ранее место
     std::swap(arr[curr_pivot_index], arr[stop]);
 
     // возвращаем индекс опорного элемента
-    return -1 /* здесь что-то не так ... */;
+    return curr_pivot_index /* здесь что-то не так ... */;
   }
 
 }  // namespace assignment

src/quick_sort.cpp

@@ -18,10 +18,13 @@ namespace assignment {
     }
 
     // вычисляем индекс опорного элемента ... median_of_three ...
-    int pivot_index = -1 /* напишите здесь свой код ... */;
+    int pivot_index = median_of_three(arr, start, stop) /* напишите здесь свой код ... */;
 
     // производим разбиение относительно опорного элемента ...  partition ...
     // рекурсивно повторяем процедуру над левой и правой частью ...
+    pivot_index = partition(arr, start, stop, pivot_index);
+    quick_sort(arr, start, pivot_index - 1);
+    quick_sort(arr, pivot_index + 1, stop);
   }
 
 }  // namespace assignment