added realization of optimization DSU

CMakeLists.txt

@@ -13,8 +13,14 @@ include(cmake/function.cmake)         # подхватываем функции,
                                       # для простоты мы объединили наборы команд для создания статической библиотеки
 								      # и для создания исполняемого проекта в отдельные функции
 
-add_subdirectory(lib_easy_example)    # подключаем дополнительный CMakeLists.txt из подкаталога с именем lib_easy_example
 
+add_subdirectory(lib_easy_example)    # подключаем дополнительный CMakeLists.txt из подкаталога с именем lib_easy_example
+add_subdirectory(lib_queue)
+add_subdirectory(lib_list)
+add_subdirectory(lib_doubly_linked_list)    # подключаем дополнительный CMakeLists.txt из подкаталога с именем lib_easy_example  
+add_subdirectory(lib_stack)   # подключаем дополнительный CMakeLists.txt из подкаталога с именем lib_easy_example
+add_subdirectory(lib_dsu)   # подключаем дополнительный CMakeLists.txt из подкаталога с именем lib_easy_example
+add_subdirectory(lib_algorithms)
 add_subdirectory(main)                # подключаем дополнительный CMakeLists.txt из подкаталога с именем main
 
 option(BTEST "build test?" ON)        # указываем подключаем ли google-тесты (ON или YES) или нет (OFF или NO)

lib_dsu/CMakeLists.txt

@@ -0,0 +1 @@
+create_project_lib(DSU)

lib_dsu/dsu.h

@@ -0,0 +1,44 @@
+#pragma once
+class DSU {
+    int* _parent;
+    int* _rank;
+    int _size;
+public:
+    DSU(int size);
+    void unite(int, int);
+    int find(int);
+    ~DSU();
+};
+DSU::DSU(int size) : _size(size) {
+    _parent = new int[_size];
+    _rank = new int[_size];
+    for (int i = 0; i < _size; i++) {
+        _parent[i] = i;
+        _rank[i] = 0;
+    }
+}
+DSU::~DSU() {
+    delete[] _parent;
+    delete[] _rank;  
+}
+int DSU::find(int x) {
+    if (_parent[x] != x) {
+        _parent[x] = find(_parent[x]);  
+    }
+    return _parent[x];
+}
+void DSU::unite(int x, int y) {
+    int rootX = find(x);  
+    int rootY = find(y);
+    if (rootX == rootY) return;
+    if (_rank[rootX] < _rank[rootY]) {
+        _parent[rootX] = rootY;
+    }
+    else if (_rank[rootX] > _rank[rootY]) {
+        _parent[rootY] = rootX;
+    }
+    else {
+        _parent[rootY] = rootX;
+        _rank[rootX]++;
+    }
+}

tests/test_algorithms.cpp

@@ -0,0 +1,35 @@
+#include <gtest/gtest.h>
+#include "algorithms.h"
+#include "stack.h"
+TEST(AlgorithmsTest, 1) {
+    EXPECT_TRUE(check_algorithms("()"));
+    EXPECT_TRUE(check_algorithms("{}"));
+    EXPECT_TRUE(check_algorithms("[]"));
+}
+
+TEST(AlgorithmsTest, 2) {
+    EXPECT_TRUE(check_algorithms("({[]})"));
+    EXPECT_TRUE(check_algorithms("{[()]}"));
+    EXPECT_TRUE(check_algorithms("({})[]"));
+}
+
+TEST(AlgorithmsTest, 3) {
+    EXPECT_FALSE(check_algorithms("("));
+    EXPECT_FALSE(check_algorithms(")"));
+    EXPECT_FALSE(check_algorithms("{[}"));
+    EXPECT_FALSE(check_algorithms("({[}])"));
+}
+TEST(AlgorithmsTest, 4) {
+    EXPECT_FALSE(check_algorithms("([)]"));
+    EXPECT_FALSE(check_algorithms("{(})"));
+}
+TEST(AlgorithmsTest, 5) {
+    EXPECT_TRUE(check_algorithms("()[]{}"));
+    EXPECT_TRUE(check_algorithms("({[]})[]{}"));
+}
+
+TEST(AlgorithmsTest, 6) {
+    EXPECT_FALSE(check_algorithms("())"));
+    EXPECT_FALSE(check_algorithms("{[}]"));
+    EXPECT_FALSE(check_algorithms("((("));
+}

tests/test_doubly_linked_list.cpp

@@ -0,0 +1,61 @@
+#include <gtest/gtest.h>
+#include "doubly_linked_list.h"
+TEST(DoublyLinkedListTest, IteratorEmpty) {
+    DoublyLinkedList<int> list;
+    EXPECT_TRUE(list.begin() == list.end());
+    EXPECT_EQ(list.size(), 0);
+    int count = 0;
+    for (auto it = list.begin(); it != list.end(); ++it) {
+        count++;
+    }
+    EXPECT_EQ(count, 0);
+    count = 0;
+    for (auto it = list.end(); it != list.begin(); --it) {
+        count++;
+    }
+    EXPECT_EQ(count, 0);
+}
+TEST(DoublyLinkedListTest, IteratorWrite) {
+    DoublyLinkedList<int> list;
+    list.push_back(1);
+    list.push_back(2);
+    list.push_back(3);
+    int value = 10;
+    for (auto it = list.begin(); it != list.end(); ++it) {
+        *it = value;
+        value += 10;
+    }
+    value = 10;
+    for (auto it = list.begin(); it != list.end(); ++it) {
+        EXPECT_EQ(*it, value);
+        value += 10;
+    }
+}
+TEST(DoublyLinkedListTest, IteratorReadAndBidirectional) {
+    DoublyLinkedList<int> list;
+
+    list.push_back(10);
+    list.push_back(20);
+    list.push_back(30);
+
+    // ������ �������� ����������
+    auto it = list.begin();
+    EXPECT_EQ(*it, 10);
+    ++it;
+    EXPECT_EQ(*it, 20);
+    ++it;
+    EXPECT_EQ(*it, 30);
+
+    // �������� ���������� (�� �� �� end()!)
+    auto it2 = list.begin();
+    ++it2;  // �� 20
+    --it2;  // ������� �� 10
+    EXPECT_EQ(*it2, 10);
+
+    // ������� ����� ������
+    int sum = 0;
+    for (auto it = list.begin(); it != list.end(); ++it) {
+        sum += *it;
+    }
+    EXPECT_EQ(sum, 60);
+}

tests/test_dsu.cpp

@@ -0,0 +1,47 @@
+#include <gtest/gtest.h>
+#include "dsu.h"
+TEST(DSUTest, InitialState) {
+    DSU dsu(5);
+    for (int i = 0; i < 5; i++) {
+        EXPECT_EQ(dsu.find(i), i);
+    }
+}
+TEST(DSUTest, SimpleUnion) {
+    DSU dsu(3);
+    dsu.unite(0, 1);
+    EXPECT_EQ(dsu.find(0), dsu.find(1));
+    EXPECT_NE(dsu.find(0), dsu.find(2));
+}
+TEST(DSUTest, TransitiveUnion) {
+    DSU dsu(4);
+    dsu.unite(0, 1);
+    dsu.unite(1, 2);
+    EXPECT_EQ(dsu.find(0), dsu.find(2));
+    EXPECT_NE(dsu.find(0), dsu.find(3));
+}
+TEST(DSUTest, MultipleUnions) {
+    DSU dsu(6);
+    dsu.unite(0, 1);
+    dsu.unite(2, 3);
+    dsu.unite(4, 5);
+    EXPECT_EQ(dsu.find(0), dsu.find(1));
+    EXPECT_EQ(dsu.find(2), dsu.find(3));
+    EXPECT_EQ(dsu.find(4), dsu.find(5));
+    EXPECT_NE(dsu.find(0), dsu.find(2));
+    EXPECT_NE(dsu.find(0), dsu.find(4));
+    EXPECT_NE(dsu.find(2), dsu.find(4));
+}
+TEST(DSUTest, UnionAllElements) {
+    DSU dsu(5);
+    for (int i = 0; i < 4; i++) {
+        dsu.unite(i, i + 1);
+    }
+    for (int i = 1; i < 5; i++) {
+        EXPECT_EQ(dsu.find(0), dsu.find(i));
+    }
+}
+TEST(DSUTest, SelfUnion) {
+    DSU dsu(3);
+    dsu.unite(0, 0);
+    EXPECT_EQ(dsu.find(0), 0);
+}

tests/test_list.cpp

@@ -0,0 +1,176 @@
+#include <gtest/gtest.h>
+#include "../lib_list/list.h"
+TEST(ListTest, CreateEmpty) {
+    List<int> list;
+    EXPECT_TRUE(list.is_empty());
+    EXPECT_EQ(list.size(), 0);
+}
+TEST(ListTest, CopyConstructor) {
+    List<int> list1;
+    list1.push_back(1);
+    list1.push_back(2);
+
+    List<int> list2(list1);
+    EXPECT_EQ(list2.size(), 2);
+}
+TEST(ListTest, Assignment) {
+    List<int> list1;
+    list1.push_back(10);
+    list1.push_back(20);
+
+    List<int> list2;
+    list2 = list1;
+    EXPECT_EQ(list2.size(), 2);
+}
+
+TEST(ListTest, DestructorWorks) {
+    List<int> list;
+    list.push_back(1);
+    list.push_back(2);
+}
+TEST(ListTest, PushElements) {
+    List<int> list;
+    list.push_front(2);
+    list.push_back(3);
+    list.push_front(1);
+    EXPECT_EQ(list.size(), 3);
+}
+TEST(ListTest, PopElements) {
+    List<int> list;
+    list.push_back(1);
+    list.push_back(2);
+    list.push_back(3);
+    list.pop_front();
+    list.pop_back();
+    EXPECT_EQ(list.size(), 1);
+}
+TEST(ListTest, InsertErase) {
+    List<int> list;
+    list.push_back(1);
+    list.push_back(3);
+    list.insert(1, 2); 
+    list.erase(0);     
+    EXPECT_EQ(list.size(), 2);
+}
+TEST(ListTest, Clear) {
+    List<int> list;
+    list.push_back(1);
+    list.push_back(2);
+    list.clear();
+    EXPECT_TRUE(list.is_empty());
+}
+TEST(ListTest, Find) {
+    List<int> list;
+    list.push_back(10);
+    list.push_back(20);
+    Node<int>* found = list.find(20);
+    EXPECT_NE(found, nullptr);
+}
+TEST(ListTest, Exceptions) {
+    List<int> list;
+    EXPECT_THROW(list.pop_front(), std::logic_error);
+    list.push_back(1);
+    EXPECT_THROW(list.erase(5), std::logic_error);
+}
+TEST(ListTest, Iterators) {
+    List<int> list;
+    list.push_back(1);
+    list.push_back(2);
+    list.push_back(3);
+    int sum = 0;
+    for (List<int>::Iterator it = list.begin(); it != list.end(); ++it) {
+        sum += *it;
+    }
+    EXPECT_EQ(sum, 6);
+}
+TEST(ListTest, DifferentTypes) {
+    List<std::string> list;
+    list.push_back("hello");
+    list.push_back("world");
+    EXPECT_EQ(list.size(), 2);
+}
+TEST(ListTest, IteratorRead) {
+    List<int> list;
+    for (int i = 0; i < 5; i++) {
+        list.push_back(i * 2);
+    }
+    std::vector<int> result;
+    for (List<int>::Iterator it = list.begin(); it != list.end(); it++) {
+        result.push_back(*it);  
+    }
+    EXPECT_EQ(result.size(), 5u);
+    EXPECT_EQ(result[0], 0);
+    EXPECT_EQ(result[1], 2);
+    EXPECT_EQ(result[2], 4);
+    EXPECT_EQ(result[3], 6);
+    EXPECT_EQ(result[4], 8);
+}
+
+TEST(ListTest, IteratorWrite) {
+    List<int> list;
+    for (int i = 0; i < 5; i++) {
+        list.push_back(0); 
+    }
+    int value = 1;
+    for (List<int>::Iterator it = list.begin(); it != list.end(); ++it) {
+        *it = value * 10;
+        value++;
+    }
+    value = 1;
+    for (List<int>::Iterator it = list.begin(); it != list.end(); ++it) {
+        EXPECT_EQ(*it, value * 10);
+        value++;
+    }
+}
+
+TEST(ListTest, IteratorEmptyList) {
+    List<int> list;
+    List<int>::Iterator it1 = list.begin();
+    EXPECT_EQ(it1, list.end());
+    EXPECT_TRUE(list.begin() == list.end());
+    int count = 0;
+    for (List<int>::Iterator it = list.begin(); it != list.end(); it++) {
+        count++;
+    }
+    EXPECT_EQ(count, 0);
+    count = 0;
+    for (List<int>::Iterator it = list.begin(); it != list.end(); ++it) {
+        count++;
+    }
+    EXPECT_EQ(count, 0);
+}
+//TEST(ListTest, can_read) {
+//    List<int>list;
+//    for (int i = 0; i < 10; i++) {
+//        list.push_back(i + 1);
+//    }
+//    int expected_val = 1;
+//    for (List<int>::Iterator it = list.begin(); it != list.end(); it++) {
+//        *it = expected_val;
+//        expected_val++;
+//    }
+//    expected_val = 1;
+//    for (List<int>::Iterator it = list.begin(); it != list.end(); it++) {
+//        EXPECT_EQ(*it, expected_val);
+//        expected_val++;
+//    }
+//}
+//TEST(ListTest, can_write) {
+//    List<int>list;
+//    int expected_val = 1;
+//    for (List<int>::Iterator it = list.begin(); it != list.end(); it++) {
+//        EXPECT_EQ(*it, expected_val);
+//        expected_val++;
+//    }
+//}
+//TEST(ListTest, is_empty) {
+//    List<int>list;
+//    for (List<int>::Iterator it = list.begin(); it != list.end(); it++) {
+//        *it = 0;
+//    }
+//}
+
+
+
+
+