diff --git a/README.md b/README.md
index 33d3dfd..b21623d 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-[![Build Status](https://travis-ci.org/justcppdev/vector_example.svg?branch=master)](https://travis-ci.org/justcppdev/vector_example)
+[![Build Status](https://travis-ci.org/ilya41299/vector_example.svg?branch=master)](https://travis-ci.org/ilya41299/vector_example)
 
 ```
 cmake -H. -B_builds -DBUILD_TESTS=ON
diff --git a/include/vector.hpp b/include/vector.hpp
index 98dccd3..c3ef865 100644
--- a/include/vector.hpp
+++ b/include/vector.hpp
@@ -1,27 +1,155 @@
 #include <iostream>
 
-class vector_t
+class tree_t
 {
 private:
-	int * elements_;
-	std::size_t size_;
-	std::size_t capacity_;
+    struct node_t
+    {
+        node_t* left = nullptr;
+        node_t* right = nullptr;
+        int value = 0;
+    };
+
+private:
+    node_t* root_;
+
 public:
-	vector_t();
-	vector_t(vector_t const & other);
-	vector_t & operator =(vector_t const & other);
-	~vector_t();
+    tree_t()
+    {
+        root_ = nullptr;
+    }
+    node_t* root()
+    {
+        return root_;
+    }
 
-	std::size_t size() const;
-	std::size_t capacity() const;
+    void check_operator(std::ostream& stream, char op, int value)
+    {
+        switch (op)
+        {
+            case '+':
+            {
+                insert(value);
+                break;
+            }
+            case '?':
+            {
+                if(find(value))
+		{
+			stream << "true";
+		}
+		else stream << "false";
+                break;
+            }
+            case '=':
+            {
+                print(stream, 0, root_);
+                break;
+            }
+            case 'q':
+            {
+                exit(0);
+                break;
+            }
+            default:
+            {
+              stream <<"Error of use operator";
+            }
+        }
+    }
 
-	void push_back(int value);
-	void pop_back();
+    void insert(int value)
+    {
+        node_t* node = new node_t;
+        node->value = value;
+        node->right = nullptr;
+        node->left = nullptr;
+        if (root_ == nullptr)
+        {
+            root_ = node;
+            return;
+        }
 
-	int & operator [](std::size_t index);
-	int operator [](std::size_t index) const;
+        node_t* vetka = root_;
+        while (vetka != nullptr)
+        {
+            if (vetka->value < value)
+            {
+                if (vetka->right != nullptr)
+                {
+                    vetka = vetka->right;
+                }
+                else
+                {
+                    vetka->right = node;
+                    return;
+                }
+            }
+            else if (vetka->value > value)
+            {
+                if (vetka->left != nullptr)
+                {
+                    vetka = vetka->left;
+                }
+                else
+                {
+                    vetka->left = node;
+                    return;
+                }
+            }
+            else
+                return;
+        }
+    }
+    bool find(int value) const
+    {
+        node_t* node = root_;
+        while (node != nullptr)
+        {
+            if (node->value == value)
+            {
+                return true;
+            }
+            else
+            {
+                if (value <= node->value)
+                {
+                    node = node->left;
+                }
+                else
+                    node = node->right;
+            }
+        }
+        return false;
+    }
 
-	bool operator ==(vector_t const & other) const;
-};
+    void print(std::ostream& stream, int level, node_t* node)
+    {
+        if (node == nullptr)
+            return;
 
-bool operator !=(vector_t const & lhs, vector_t const & rhs);
+        print(stream, level + 1, node->right);
+
+        for (unsigned int i = 0; i < level; i++)
+        {
+            stream << "---";
+        }
+          stream << node->value <<   std::endl;
+
+        print(stream, level + 1, node->left);
+    }
+
+   void destroy(node_t* node)
+   {
+	if (node != nullptr)
+	{
+		destroy(node->left);
+		destroy(node->right);
+		delete node;
+	}
+   }
+	~tree_t()
+	{
+		destroy(root_);	
+	}
+};
diff --git a/sources/vector.cpp b/sources/vector.cpp
index e1a2561..8b13789 100644
--- a/sources/vector.cpp
+++ b/sources/vector.cpp
@@ -1,59 +1 @@
-#include <algorithm>
-#include <cassert>
 
-#include "vector.hpp"
-
-vector_t::vector_t()
-{
-}
-
-vector_t::vector_t(vector_t const & other)
-{
-}
-
-vector_t & vector_t::operator =(vector_t const & other)
-{
-	return *this;
-}
-
-bool vector_t::operator ==(vector_t const & other) const
-{
-	return false;
-}
-
-vector_t::~vector_t()
-{
-}
-
-std::size_t vector_t::size() const
-{
-    return 0;
-}
-
-std::size_t vector_t::capacity() const
-{
-    return 0;
-}
-
-void vector_t::push_back(int value)
-{
-}
-
-void vector_t::pop_back()
-{
-}
-
-int & vector_t::operator [](std::size_t index)
-{
-	return elements_[0];
-}
-
-int vector_t::operator [](std::size_t index) const
-{
-	return 0;
-}
-
-bool operator !=(vector_t const & lhs, vector_t const & rhs)
-{
-	return true;
-}
diff --git a/tests/vector.cpp b/tests/vector.cpp
index 7d2b926..70f5608 100644
--- a/tests/vector.cpp
+++ b/tests/vector.cpp
@@ -3,117 +3,65 @@
 
 #include "vector.hpp"
 
-TEST_CASE("creating vector")
+TEST_CASE("Сreating tree")
 {
-	vector_t vector;
-	REQUIRE( vector.size() == 0 );
-	REQUIRE( vector.capacity() == 0 );
+	tree_t My_tree;
+	REQUIRE( My_tree.root() == nullptr );
 }
 
-TEST_CASE("copying vector")
+TEST_CASE("Add elements in tree")
 {
-	vector_t vector;
-	vector.push_back(1);
-
-	vector_t copy(vector);
-	REQUIRE( copy == vector );
+	tree_t My_tree;
+	My_tree.insert(7);
+	My_tree.insert(3);
+	My_tree.insert(9);
+	My_tree.insert(6);
+	std::ostringstream ostream;
+	My_tree.print(ostream, 0, My_tree.root());
+	std::string output{
+		"---9\n"
+		"7\n"
+		"------6\n"
+		"---3\n"};
+	REQUIRE(output == ostream.str());
 }
 
-TEST_CASE("assigning vector")
+TEST_CASE("Check root tree")
 {
-	vector_t vector1;
-	vector_t vector2;
-
-	vector1.push_back(1);
-	vector2.push_back(2);
-
-	vector1 = vector2;
-	REQUIRE( vector1 == vector2 );
-}
-
-TEST_CASE("equaling vector")
-{
-	vector_t vector1;
-	vector_t vector2;
-
-	vector1.push_back(1);
-	vector2.push_back(1);
+	tree_t My_tree;
+  My_tree.insert(7);
+  My_tree.insert(3);
+  My_tree.insert(9); 
 
-	REQUIRE( vector1 == vector2 );
-
-	vector1.push_back(2);
-	REQUIRE( vector1 != vector2 );
+  REQUIRE(My_tree.find(9) == true);
+  REQUIRE(My_tree.find(2) == false);
 }
 
-TEST_CASE("indexing vector")
+TEST_CASE("Check operator tree '+' and '=' ")
 {
-	vector_t vector;
-
-	vector.push_back(1);
-
-	REQUIRE( vector[0] == 1 );
-
-	vector_t const copy(vector);
-	REQUIRE( copy[0] == 1 );
+	tree_t My_tree;
+	std::ostringstream ostream;
+	My_tree.check_operator(ostream, '+', 7);
+	My_tree.check_operator(ostream, '+', 3);
+	My_tree.check_operator(ostream, '+', 9);
+	My_tree.check_operator(ostream, '+', 6);
+	std::string output {
+		"---9\n"
+		"7\n"
+		"------6\n"
+		"---3\n"};
+	My_tree.check_operator (ostream, '=', 0);
+	
+	REQUIRE(output == ostream.str());
 }
-
-TEST_CASE("pushing elements")
+TEST_CASE("Check operator tree '?' ")
 {
-	vector_t vector;
-
-	vector.push_back(1);
-	REQUIRE( vector.size() == 1 );
-	REQUIRE( vector.capacity() == 1 );
-
-	vector.push_back(2);
-	REQUIRE( vector.size() == 2 );
-	REQUIRE( vector.capacity() == 2 );
-
-	vector.push_back(3);
-	REQUIRE( vector.size() == 3 );
-	REQUIRE( vector.capacity() == 4 );
-
-	vector.push_back(4);
-	REQUIRE( vector.size() == 4 );
-	REQUIRE( vector.capacity() == 4 );
-
-	vector.push_back(5);
-	REQUIRE( vector.size() == 5 );
-	REQUIRE( vector.capacity() == 8 );
-}
-
-TEST_CASE("poping elements")
-{
-	vector_t vector;
-
-	vector.push_back(1);
-	vector.push_back(2);
-	vector.push_back(3);
-	vector.push_back(4);
-	vector.push_back(5);
-	vector.push_back(6);
-
-	vector.pop_back();
-	REQUIRE( vector.size() == 5 );
-	REQUIRE( vector.capacity() == 8 );
-
-	vector.pop_back();
-	REQUIRE( vector.size() == 4 );
-	REQUIRE( vector.capacity() == 8 );
-
-	vector.pop_back();
-	REQUIRE( vector.size() == 3 );
-	REQUIRE( vector.capacity() == 8 );
-
-	vector.pop_back();
-	REQUIRE( vector.size() == 2 );
-	REQUIRE( vector.capacity() == 4 );
-
-	vector.pop_back();
-	REQUIRE( vector.size() == 1 );
-	REQUIRE( vector.capacity() == 2 );
-
-	vector.pop_back();
-	REQUIRE( vector.size() == 0 );
-	REQUIRE( vector.capacity() == 1 );
+	tree_t My_tree;
+	My_tree.insert(7);
+	My_tree.insert(3);
+	My_tree.insert(9); 
+	std::ostringstream ostream;
+	My_tree.check_operator (ostream, '?', 3);
+	REQUIRE(ostream.str() == "true");
 }
+