Realization of function with correct codding style

TASK.md

@@ -0,0 +1,5 @@
+## Task
+����������� ������� ���������� ��������� ������ ������ �� ���������������� �������
+* ����������� ������ ������ ���� ����������������
+* ����� ������ ������� - ��������
+����� ���������� ����������� Google-tests � ����������.

app/main.cpp

@@ -1,6 +1,31 @@
-#include "add.h"
 #include <iostream>
+#include "create_tree.h"
 
 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);
 }

include/create_tree.h

@@ -0,0 +1,22 @@
+#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* CreateTree(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_

src/create_tree.cpp

@@ -0,0 +1,112 @@
+#include <iostream>
+#include <queue>
+#include <tuple>
+#include "create_tree.h"
+
+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<int> 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* CreateTree(int* A, int size) {
+  std::queue<std::tuple<CNode**, int, int>> 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) {
+    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 <CNode*> 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);
+  }
+}

test/test_create_tree.cpp

@@ -0,0 +1,192 @@
+#include <gtest/gtest.h>
+#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);
+}
+
+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);
+}