2, 5 tasks

task_02/src/stack.cpp

@@ -1,21 +0,0 @@
-#include "stack.hpp"
-
-#include <algorithm>
-
-void Stack::Push(int value) { data_.push(value); }
-
-int Stack::Pop() {
-  auto result = data_.top();
-  data_.pop();
-  return result;
-}
-
-void MinStack::Push(int value) { data_.push_back(value); }
-
-int MinStack::Pop() {
-  auto result = data_.back();
-  data_.pop_back();
-  return result;
-}
-
-int MinStack::GetMin() { return *std::min_element(data_.begin(), data_.end()); }

task_02/src/stack.hpp

@@ -1,23 +1,88 @@
-#pragma once
+#ifndef STACK_H
+#define STACK_H
 
 #include <stack>
 #include <vector>
 
-class Stack {
- public:
-  void Push(int value);
-  int Pop();
+#include<vector>
+#include<stdexcept>
 
- private:
-  std::stack<int> data_;
+template <typename T>
+class Stack
+{
+public:
+    void push_element(T elem);
+    T pop_element();
+    bool is_empty(){return value_list.size() == 0;}
+private:
+    std::vector<T> value_list;
 };
 
-class MinStack {
- public:
-  void Push(int value);
-  int Pop();
-  int GetMin();
+template<typename T>
+void Stack<T>::push_element(T elem)
+{
+  value_list.push_back(elem);
+}
 
- private:
-  std::vector<int> data_;
+template<typename T>
+T Stack<T>::pop_element()
+{
+    if (value_list.empty()){
+        throw std::runtime_error("stack is empty");
+    }
+    T last_element = value_list.back();
+    value_list.pop_back();
+    return last_element;
+}
+
+
+
+
+template <typename T>
+class MinStack
+{
+public:
+    void push_element(T elem);
+    T pop_element();
+    T get_min();
+    bool is_empty(){return value_list.size() == 0;}
+private:
+    std::vector<T> value_list;
+    std::vector<T> min_list;
 };
+
+
+template<typename T>
+void MinStack<T>::push_element(T elem)
+{
+    value_list.push_back(elem);
+    if (min_list.empty() || elem < min_list.back())
+    {
+        min_list.push_back(elem);
+    }
+}
+
+template<typename T>
+T MinStack<T>::pop_element()
+{
+    if (value_list.empty()){
+        throw std::runtime_error("stack is empty");
+    }
+    if (value_list.back() == min_list.back()){
+        min_list.pop_back();
+    }
+    T last_element = value_list.back();
+    value_list.pop_back();
+    return last_element;
+}
+
+template<typename T>
+T MinStack<T>::get_min()
+{
+    if (min_list.empty()){
+        throw std::runtime_error("stack is empty");
+    }
+    return min_list.back();
+}
+
+#endif //STACK_H

task_02/src/test.cpp

@@ -1,42 +1,41 @@
 
 #include <gtest/gtest.h>
 
-#include <stack>
 
 #include "stack.hpp"
 
 TEST(StackTest, Simple) {
-  Stack stack;
-  stack.Push(1);              // Stack [1]
-  ASSERT_EQ(stack.Pop(), 1);  // Stack []
-  stack.Push(1);              // Stack [1]
-  stack.Push(2);              // Stack [1, 2]
-  ASSERT_EQ(stack.Pop(), 2);  // Stack [1]
-  ASSERT_EQ(stack.Pop(), 1);  // Stack []
-  stack.Push(1);              // Stack [1]
-  stack.Push(2);              // Stack [1, 2]
-  ASSERT_EQ(stack.Pop(), 2);  // Stack [1]
-  stack.Push(3);              // Stack [1, 3]
-  ASSERT_EQ(stack.Pop(), 3);  // Stack [1]
-  ASSERT_EQ(stack.Pop(), 1);  // Stack []
+  Stack<int> stack;
+  stack.push_element(1);              // Stack [1]
+  ASSERT_EQ(stack.pop_element(), 1);  // Stack []
+  stack.push_element(1);              // Stack [1]
+  stack.push_element(2);              // Stack [1, 2]
+  ASSERT_EQ(stack.pop_element(), 2);  // Stack [1]
+  ASSERT_EQ(stack.pop_element(), 1);  // Stack []
+  stack.push_element(1);              // Stack [1]
+  stack.push_element(2);              // Stack [1, 2]
+  ASSERT_EQ(stack.pop_element(), 2);  // Stack [1]
+  stack.push_element(3);              // Stack [1, 3]
+  ASSERT_EQ(stack.pop_element(), 3);  // Stack [1]
+  ASSERT_EQ(stack.pop_element(), 1);  // Stack []
 }
 
 TEST(MinStackTest, Simple) {
-  MinStack stack;
-  stack.Push(1);  // Stack [1]
-  ASSERT_EQ(stack.GetMin(), 1);
-  ASSERT_EQ(stack.Pop(), 1);  // Stack []
-  stack.Push(1);              // Stack [1]
-  stack.Push(2);              // Stack [1, 2]
-  ASSERT_EQ(stack.GetMin(), 1);
-  ASSERT_EQ(stack.Pop(), 2);  // Stack [1]
-  ASSERT_EQ(stack.Pop(), 1);  // Stack []
-  stack.Push(1);              // Stack [1]
-  stack.Push(2);              // Stack [1, 2]
-  ASSERT_EQ(stack.GetMin(), 1);
-  ASSERT_EQ(stack.Pop(), 2);  // Stack [1]
-  stack.Push(3);              // Stack [1, 3]
-  ASSERT_EQ(stack.GetMin(), 1);
-  ASSERT_EQ(stack.Pop(), 3);  // Stack [1]
-  ASSERT_EQ(stack.Pop(), 1);  // Stack []
+  MinStack<int> stack;
+  stack.push_element(1);  // Stack [1]
+  ASSERT_EQ(stack.get_min(), 1);
+  ASSERT_EQ(stack.pop_element(), 1);  // Stack []
+  stack.push_element(1);              // Stack [1]
+  stack.push_element(2);              // Stack [1, 2]
+  ASSERT_EQ(stack.get_min(), 1);
+  ASSERT_EQ(stack.pop_element(), 2);  // Stack [1]
+  ASSERT_EQ(stack.pop_element(), 1);  // Stack []
+  stack.push_element(1);              // Stack [1]
+  stack.push_element(2);              // Stack [1, 2]
+  ASSERT_EQ(stack.get_min(), 1);
+  ASSERT_EQ(stack.pop_element(), 2);  // Stack [1]
+  stack.push_element(3);              // Stack [1, 3]
+  ASSERT_EQ(stack.get_min(), 1);
+  ASSERT_EQ(stack.pop_element(), 3);  // Stack [1]
+  ASSERT_EQ(stack.pop_element(), 1);  // Stack []
 }

task_05/src/heap.hpp

@@ -0,0 +1,107 @@
+#ifndef HEAP_HPP
+#define HEAP_HPP
+
+#include<vector>
+#include<stdexcept>
+#include <algorithm>
+
+template <typename T>
+class Heap
+{
+public:
+    Heap(std::vector<T> list){for (auto c: list){append_element(c);}}
+    T pop_min();
+    void append_element(T element);
+private:
+    std::vector<T> tree;
+
+    void siftup();
+    void siftdown();
+
+    int parent_index(int index_of_element){return (index_of_element - 1)/2;}
+    int left_child_index(int index_of_element){return 2*index_of_element+1;}
+    int right_child_index(int index_of_element){return 2*index_of_element+2;}
+};
+
+
+template<typename T>
+T Heap<T>::pop_min()
+{
+    if (tree.empty()) {throw std::runtime_error("heap is empty");}
+    T min_elem = tree[0];
+    siftdown();
+    return min_elem;
+}
+
+
+template<typename T>
+void Heap<T>::append_element(T element)
+{
+    tree.push_back(element);
+    siftup();
+}
+
+
+template<typename T>
+void Heap<T>::siftup()
+{
+    int index = tree.size() - 1;
+    while (index != 0)
+    {
+        int p_ind = parent_index(index);
+        if (tree[p_ind] > tree[index])
+        {
+            T bufer = tree[index];
+            tree[index] = tree[p_ind];
+            tree[p_ind] = bufer;
+        }
+        index = p_ind;
+    }
+}
+
+
+template<typename T>
+void Heap<T>::siftdown()
+{
+    if (tree.empty()) return;
+    tree[0] = tree.back();
+    tree.pop_back();
+    int index{0};
+    while(left_child_index(index) < tree.size()) //существует хотя бы 1 потомок. Если левого потомка нет, то и правого тоже быть не может
+    {
+        int l_c_ind = left_child_index(index);
+        int r_c_ind = right_child_index(index);
+        if (r_c_ind >= tree.size()) //проверка на существование правого потомка
+        {
+            if (tree[l_c_ind]<tree[index])
+            {
+                std::swap(tree[index], tree[l_c_ind]);
+                index = l_c_ind;
+                continue;
+            }
+            break;
+        }
+        int ind_of_min_elem = tree[l_c_ind]<tree[r_c_ind]?l_c_ind:r_c_ind;
+        if(tree[index] > tree[ind_of_min_elem])
+        {
+            std::swap(tree[index], tree[ind_of_min_elem]);
+        }
+        index = ind_of_min_elem;
+    }
+}
+
+
+
+template <typename T>
+std::vector<T> Heap_sort(std::vector<T> list)
+{
+    std::vector<T> return_vector;
+    Heap<T> heap = Heap(list);
+    while(return_vector.size() != list.size())
+    {
+        return_vector.push_back(heap.pop_min());
+    }
+    return return_vector;
+}
+
+#endif //HEAP_HPP

task_05/src/test.cpp

@@ -1,6 +1,32 @@
+#include"heap.hpp"
+
+#include<vector>
+#include <algorithm>
+#include<string>
 
 #include <gtest/gtest.h>
 
-TEST(TopologySort, Simple) {
-  ASSERT_EQ(1, 1);  // Stack []
+TEST(Heap_sort , ints){
+  std::vector<int> list = {2,3,1,4,1};
+  std::vector<int> sorted_list = Heap_sort(list);
+  std::sort(begin(list), end(list));
+  ASSERT_EQ(sorted_list, list);
+}
+TEST(Heap_sort, empty_list){
+  std::vector<int> list = {};
+  std::vector<int> sorted_list = Heap_sort(list);
+  std::vector<int> expected_list = {};
+  ASSERT_EQ(sorted_list, expected_list);
+}
+TEST(Heap_sort, doubles){
+  std::vector<double> list = {1.1, 2.4, 0.7, 5.6, -23.4};
+  std::vector<double> sorted_list = Heap_sort(list);
+  std::sort(begin(list), end(list));
+  ASSERT_EQ(sorted_list, list);
 }
+TEST(Heap_sort, string){
+  std::vector<std::string> list = {"a", "s", "a", "c", "b"};
+  std::vector<std::string> sorted_list = Heap_sort(list);
+  std::sort(begin(list), end(list));
+  ASSERT_EQ(sorted_list, list);
+}