From a677e68313651d14b443b353f75be227998aa225 Mon Sep 17 00:00:00 2001 From: Usova Marina A Date: Sun, 19 Mar 2017 13:48:58 +0300 Subject: [PATCH 1/2] Realization of function with correct codding style --- README.md | 7 ++- app/main.cpp | 30 ++++++++- include/add.h | 6 -- include/create_tree.h | 21 +++++++ src/add.cpp | 3 - src/create_tree.cpp | 88 ++++++++++++++++++++++++++ test/test_add.cpp | 7 --- test/test_create_tree.cpp | 129 ++++++++++++++++++++++++++++++++++++++ 8 files changed, 272 insertions(+), 19 deletions(-) delete mode 100644 include/add.h create mode 100644 include/create_tree.h delete mode 100644 src/add.cpp create mode 100644 src/create_tree.cpp delete mode 100644 test/test_add.cpp create mode 100644 test/test_create_tree.cpp diff --git a/README.md b/README.md index 114797a..dda4f23 100644 --- a/README.md +++ b/README.md @@ -13,4 +13,9 @@ ``` git checkout git rebase master -``` \ No newline at end of file +``` +## Task +Реализовать функцию построения бинарного дерева поиска по отсортированному массиву +* Построенное дерево должно быть сбалансированным +* Время работы функции - линейное +Также необходимо реализовать Google-tests и приложение. \ No newline at end of file diff --git a/app/main.cpp b/app/main.cpp index 4485790..2351f04 100644 --- a/app/main.cpp +++ b/app/main.cpp @@ -1,6 +1,32 @@ -#include "add.h" +#include "create_tree.h" #include int main() { - std::cout << "2 + 2 = " << add(2, 2) << std::endl; + const int size = 6; + int A[size] = { 1, 3, 4, 5, 6, 7 }; + + + CNode* tree_1 = create_tree(A, size); + std::cout << std::endl << "Created tree" << std::endl << std::endl; + print_tree(tree_1, 4); + + CNode* tree_2 = create_tree_with_recursion(A, 0, size - 1); + std::cout << std::endl << + "Created tree with recursion" << std::endl << std::endl; + print_tree(tree_2, 4); + std::cout << "" << std::endl; + + std::cout << std::endl << "Another view" << std::endl << std::endl; + PrintTree(tree_1); + std::cout << "" << std::endl; + + std::cout << std::endl << "Use search" << std::endl << std::endl; + CNode** res = find(&tree_1, 8); + *res = new CNode(8); + std::cout << std::endl << + "Tree after adding an element 8 on found position" + << std::endl << std::endl; + print_tree(tree_1, 4); + PrintTree(tree_1); + return 0; } diff --git a/include/add.h b/include/add.h deleted file mode 100644 index ebb1c94..0000000 --- a/include/add.h +++ /dev/null @@ -1,6 +0,0 @@ -#ifndef INCLUDE_ADD_H_ -#define INCLUDE_ADD_H_ - -int add(int x, int y); - -#endif // INCLUDE_ADD_H_ diff --git a/include/create_tree.h b/include/create_tree.h new file mode 100644 index 0000000..26675ef --- /dev/null +++ b/include/create_tree.h @@ -0,0 +1,21 @@ +#ifndef INCLUDE_CREATE_TREE_H_ +#define INCLUDE_CREATE_TREE_H_ + +struct CNode { + int val; + CNode *left, *right; + CNode() {} + explicit CNode(int v) { + val = v; + left = nullptr; + right = nullptr; + } +}; + +CNode* create_tree_with_recursion(int *A, int left_end, int right_end); +CNode* create_tree(int *A, int size); +CNode** find(CNode**root, int v); +void PrintTree(CNode* root); +void print_tree(CNode* root, int level); + +#endif // INCLUDE_CREATE_TREE_H_ diff --git a/src/add.cpp b/src/add.cpp deleted file mode 100644 index 35bf82f..0000000 --- a/src/add.cpp +++ /dev/null @@ -1,3 +0,0 @@ -int add(int x, int y) { - return x + y; -} diff --git a/src/create_tree.cpp b/src/create_tree.cpp new file mode 100644 index 0000000..8de29e4 --- /dev/null +++ b/src/create_tree.cpp @@ -0,0 +1,88 @@ +#include +#include "create_tree.h" +#include + +CNode* create_tree_with_recursion(int *A, int left_end, int right_end) { + CNode* tree; + CNode* tmp; + int middle; + if (left_end > right_end) { + tree = nullptr; + } else { + middle = (left_end + right_end) / 2; + tmp = new CNode; + tmp->val = A[middle]; + tmp->left = create_tree_with_recursion(A, left_end, middle - 1); + tmp->right = create_tree_with_recursion(A, middle + 1, right_end); + tree = tmp; + } + return tree; +} + +CNode* create_tree(int *A, int size) { + CNode* tree = nullptr; + int left_end = 0, right_end = size - 1, middle; + std::queue q; + q.push(left_end); + q.push(right_end); + while (!q.empty()) { + left_end = q.front(); + q.pop(); + right_end = q.front(); + q.pop(); + if (left_end > right_end) { + continue; + } + middle = (left_end + right_end) / 2; + CNode** tmp = find(&tree, A[middle]); + *tmp = new CNode(A[middle]); + q.push(left_end); + q.push(middle - 1); + q.push(middle + 1); + q.push(right_end); + } + return tree; +} + +CNode** find(CNode** root, int v) { + CNode **tree = root; + while (*tree) { + if ((*tree)->val == v) { + return tree; + } else { + if ((*tree)->val < v) { + tree = &(*tree)->right; + } else { + tree = &(*tree)->left; + } + } + } + return tree; +} + +void PrintTree(CNode* root) { + std::queue q; + q.push(root); + while (!q.empty()) { + int size = q.size(); + for (int i = 0; i < size; ++i) { + CNode* e = q.front(); + q.pop(); + if (e == nullptr) + continue; + std::cout << e->val << " "; + q.push(e->left); + q.push(e->right); + } + std::cout << std::endl; + } +} + +void print_tree(CNode* root, int level) { + if (root) { + print_tree(root->right, level + 1); + for (int i = 0; i< level; i++) std::cout << " "; + std::cout << root->val << std::endl; + print_tree(root->left, level + 1); + } +} diff --git a/test/test_add.cpp b/test/test_add.cpp deleted file mode 100644 index 66c2df3..0000000 --- a/test/test_add.cpp +++ /dev/null @@ -1,7 +0,0 @@ -#include -#include "add.h" - -TEST(Addition, CanAddTwoNumbers) { - EXPECT_EQ(add(2, 2), 4); - EXPECT_EQ(add(-2, 2), 0); -} diff --git a/test/test_create_tree.cpp b/test/test_create_tree.cpp new file mode 100644 index 0000000..5ee731e --- /dev/null +++ b/test/test_create_tree.cpp @@ -0,0 +1,129 @@ +#include +#include "create_tree.h" + +TEST(Create_Tree, can_create_empty_tree) { + EXPECT_NO_THROW(create_tree(NULL, 0)); +} + +TEST(Create_Tree, can_create_tree_ex_1_1) { + const int size = 3; + int A[size] = { 1, 2, 3 }; + + EXPECT_NO_THROW(create_tree(A, size)); +} + +TEST(Create_Tree, can_create_tree_ex_1_2) { + const int size = 3; + int A[size] = { 1, 2, 3 }; + + CNode* tree = create_tree(A, size); + + CNode* true_tree = new CNode(2); + true_tree->left = new CNode(1); + true_tree->right = new CNode(3); + + ASSERT_EQ(tree->val, true_tree->val); + ASSERT_EQ(tree->left->val, true_tree->left->val); + ASSERT_EQ(tree->right->val, true_tree->right->val); +} + +TEST(Create_Tree, can_create_tree_ex_2_1) { + const int size = 5; + int A[size] = { 1, 2, 3, 4, 5 }; + + EXPECT_NO_THROW(create_tree(A, size)); +} + +TEST(Create_Tree, can_create_tree_ex_2_2) { + const int size = 5; + int A[size] = { 1, 2, 3, 4, 5 }; + + CNode* tree = create_tree(A, size); + + CNode* true_tree = new CNode(3); + true_tree->left = new CNode(1); + true_tree->right = new CNode(4); + true_tree->left->right = new CNode(2); + true_tree->right->right = new CNode(5); + + ASSERT_EQ(tree->val, true_tree->val); + ASSERT_EQ(tree->left->val, true_tree->left->val); + ASSERT_EQ(tree->right->val, true_tree->right->val); + ASSERT_EQ(tree->left->right->val, true_tree->left->right->val); + ASSERT_EQ(tree->right->right->val, true_tree->right->right->val); +} + +TEST(Create_Tree, create_tree_can_work_with_function) { + const int size = 3; + int A[size] = { 1, 2, 3 }; + + CNode* tree = create_tree(A, size); + + EXPECT_EQ(*(find(&tree, 2)), tree); + EXPECT_EQ(*(find(&tree, 1)), tree->left); + EXPECT_EQ(*(find(&tree, 3)), tree->right); +} + +TEST(Create_Tree_With_Recursion, can_create_empty_tree) { + EXPECT_NO_THROW(create_tree_with_recursion(NULL, 0, -1)); +} + +TEST(Create_Tree_With_Recursion, can_create_tree_ex_1_1) { + const int size = 3; + int A[size] = { 1, 2, 3 }; + + EXPECT_NO_THROW(create_tree_with_recursion(A, 0, size - 1)); +} + +TEST(Create_Tree_With_Recursion, can_create_tree_ex_1_2) { + const int size = 3; + int A[size] = { 1, 2, 3 }; + + CNode* tree = create_tree_with_recursion(A, 0, size - 1); + + CNode* true_tree = new CNode(2); + true_tree->left = new CNode(1); + true_tree->right = new CNode(3); + + ASSERT_EQ(tree->val, true_tree->val); + ASSERT_EQ(tree->left->val, true_tree->left->val); + ASSERT_EQ(tree->right->val, true_tree->right->val); +} + +TEST(Create_Tree_With_Recursion, can_create_tree_ex_2_1) { + const int size = 5; + int A[size] = { 1, 2, 3, 4, 5 }; + + EXPECT_NO_THROW(create_tree_with_recursion(A, 0, size - 1)); +} + +TEST(Create_Tree_With_Recursion, can_create_tree_ex_2_2) { + const int size = 5; + int A[size] = { 1, 2, 3, 4, 5 }; + + CNode* tree = create_tree_with_recursion(A, 0, size - 1); + + CNode* true_tree = new CNode(3); + true_tree->left = new CNode(1); + true_tree->right = new CNode(4); + true_tree->left->right = new CNode(2); + true_tree->right->right = new CNode(5); + + ASSERT_EQ(tree->val, true_tree->val); + ASSERT_EQ(tree->left->val, true_tree->left->val); + ASSERT_EQ(tree->right->val, true_tree->right->val); + ASSERT_EQ(tree->left->right->val, true_tree->left->right->val); + ASSERT_EQ(tree->right->right->val, true_tree->right->right->val); +} + +TEST(Create_Tree_With_Recursion, create_tree_can_work_with_function) { + const int size = 3; + int A[size] = { 1, 2, 3 }; + + CNode* tree = nullptr; + tree = create_tree_with_recursion(A, 0, size - 1); + + EXPECT_EQ(*(find(&tree, 2)), tree); + EXPECT_EQ(*(find(&tree, 1)), tree->left); + EXPECT_EQ(*(find(&tree, 3)), tree->right); +} From 02653f8ad39ef7f9c2384b7e4694b2c0002d53e5 Mon Sep 17 00:00:00 2001 From: Usova Marina A Date: Sun, 26 Mar 2017 18:34:40 +0300 Subject: [PATCH 2/2] Add third embodiment --- README.md | 7 +---- TASK.md | 5 ++++ app/main.cpp | 3 +- include/create_tree.h | 1 + src/create_tree.cpp | 26 +++++++++++++++- test/test_create_tree.cpp | 63 +++++++++++++++++++++++++++++++++++++++ 6 files changed, 96 insertions(+), 9 deletions(-) create mode 100644 TASK.md diff --git a/README.md b/README.md index dda4f23..114797a 100644 --- a/README.md +++ b/README.md @@ -13,9 +13,4 @@ ``` git checkout git rebase master -``` -## Task -Реализовать функцию построения бинарного дерева поиска по отсортированному массиву -* Построенное дерево должно быть сбалансированным -* Время работы функции - линейное -Также необходимо реализовать Google-tests и приложение. \ No newline at end of file +``` \ No newline at end of file diff --git a/TASK.md b/TASK.md new file mode 100644 index 0000000..e1e815b --- /dev/null +++ b/TASK.md @@ -0,0 +1,5 @@ +## Task +Реализовать функцию построения бинарного дерева поиска по отсортированному массиву +* Построенное дерево должно быть сбалансированным +* Время работы функции - линейное +Также необходимо реализовать Google-tests и приложение. \ No newline at end of file diff --git a/app/main.cpp b/app/main.cpp index 2351f04..be0397c 100644 --- a/app/main.cpp +++ b/app/main.cpp @@ -1,5 +1,5 @@ -#include "create_tree.h" #include +#include "create_tree.h" int main() { const int size = 6; @@ -28,5 +28,4 @@ int main() { << std::endl << std::endl; print_tree(tree_1, 4); PrintTree(tree_1); - return 0; } diff --git a/include/create_tree.h b/include/create_tree.h index 26675ef..1945924 100644 --- a/include/create_tree.h +++ b/include/create_tree.h @@ -14,6 +14,7 @@ struct CNode { CNode* create_tree_with_recursion(int *A, int left_end, int right_end); CNode* create_tree(int *A, int size); +CNode* CreateTree(int* A, int size); CNode** find(CNode**root, int v); void PrintTree(CNode* root); void print_tree(CNode* root, int level); diff --git a/src/create_tree.cpp b/src/create_tree.cpp index 8de29e4..2ff458e 100644 --- a/src/create_tree.cpp +++ b/src/create_tree.cpp @@ -1,6 +1,7 @@ #include -#include "create_tree.h" #include +#include +#include "create_tree.h" CNode* create_tree_with_recursion(int *A, int left_end, int right_end) { CNode* tree; @@ -44,6 +45,29 @@ CNode* create_tree(int *A, int size) { return tree; } +CNode* CreateTree(int* A, int size) { + std::queue> q; + CNode* tree; + int middle; + if (A == nullptr) + return nullptr; + q.push(std::make_tuple(&tree, 0, size)); + + while (!q.empty()) { + auto node = q.front(); + q.pop(); + middle = (std::get<1>(node) + std::get<2>(node)) / 2; + if (std::get<1>(node) < std::get<2>(node)) { + *(std::get<0>(node)) = new CNode(A[middle]); + q.push(std::make_tuple + (&(*(std::get<0>(node)))->left, (std::get<1>(node)), middle)); + q.push(std::make_tuple + (&(*(std::get<0>(node)))->right, middle+1, std::get<2>(node))); + } + } + return tree; +} + CNode** find(CNode** root, int v) { CNode **tree = root; while (*tree) { diff --git a/test/test_create_tree.cpp b/test/test_create_tree.cpp index 5ee731e..a500cbf 100644 --- a/test/test_create_tree.cpp +++ b/test/test_create_tree.cpp @@ -127,3 +127,66 @@ TEST(Create_Tree_With_Recursion, create_tree_can_work_with_function) { EXPECT_EQ(*(find(&tree, 1)), tree->left); EXPECT_EQ(*(find(&tree, 3)), tree->right); } + +TEST(Create_Tree_2, can_create_empty_tree) { + EXPECT_NO_THROW(CreateTree(NULL, 0)); +} + +TEST(Create_Tree_2, can_create_tree_ex_1_1) { + const int size = 3; + int A[size] = { 1, 2, 3 }; + + EXPECT_NO_THROW(CreateTree(A, size)); +} + +TEST(Create_Tree_2, can_create_tree_ex_1_2) { + const int size = 3; + int A[size] = { 1, 2, 3 }; + + CNode* tree = CreateTree(A, size); + + CNode* true_tree = new CNode(2); + true_tree->left = new CNode(1); + true_tree->right = new CNode(3); + + ASSERT_EQ(tree->val, true_tree->val); + ASSERT_EQ(tree->left->val, true_tree->left->val); + ASSERT_EQ(tree->right->val, true_tree->right->val); +} + +TEST(Create_Tree_2, can_create_tree_ex_2_1) { + const int size = 5; + int A[size] = { 1, 2, 3, 4, 5 }; + + EXPECT_NO_THROW(CreateTree(A, size)); +} + +TEST(Create_Tree_2, can_create_tree_ex_2_2) { + const int size = 5; + int A[size] = { 1, 2, 3, 4, 6 }; + + CNode* tree = CreateTree(A, size); + + CNode* true_tree = new CNode(3); + true_tree->left = new CNode(2); + true_tree->right = new CNode(6); + true_tree->left->left = new CNode(1); + true_tree->right->left = new CNode(4); + + ASSERT_EQ(tree->val, true_tree->val); + ASSERT_EQ(tree->left->val, true_tree->left->val); + ASSERT_EQ(tree->right->val, true_tree->right->val); + ASSERT_EQ(tree->left->left->val, true_tree->left->left->val); + ASSERT_EQ(tree->right->left->val, true_tree->right->left->val); +} + +TEST(Create_Tree_2, create_tree_can_work_with_function) { + const int size = 3; + int A[size] = { 1, 2, 3 }; + + CNode* tree = CreateTree(A, size); + + EXPECT_EQ(*(find(&tree, 2)), tree); + EXPECT_EQ(*(find(&tree, 1)), tree->left); + EXPECT_EQ(*(find(&tree, 3)), tree->right); +}