Tree@0.0.2

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

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_);	
+	}
+};

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;
-}