Tree

Tree/.gitignore

@@ -0,0 +1,49 @@
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and Webstorm
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+
+# User-specific stuff:
+.idea/**/workspace.xml
+.idea/**/tasks.xml
+.idea/dictionaries
+
+# Sensitive or high-churn files:
+.idea/**/dataSources/
+.idea/**/dataSources.ids
+.idea/**/dataSources.xml
+.idea/**/dataSources.local.xml
+.idea/**/sqlDataSources.xml
+.idea/**/dynamic.xml
+.idea/**/uiDesigner.xml
+
+# Gradle:
+.idea/**/gradle.xml
+.idea/**/libraries
+
+# CMake
+cmake-build-debug/
+
+# Mongo Explorer plugin:
+.idea/**/mongoSettings.xml
+
+## File-based project format:
+*.iws
+
+## Plugin-specific files:
+
+# IntelliJ
+out/
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Cursive Clojure plugin
+.idea/replstate.xml
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties

Tree/Tree.iml

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module org.jetbrains.idea.maven.project.MavenProjectsManager.isMavenModule="true" type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" LANGUAGE_LEVEL="JDK_1_5">
+    <output url="file://$MODULE_DIR$/target/classes" />
+    <output-test url="file://$MODULE_DIR$/target/test-classes" />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src/main/java" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/src/main/resources" type="java-resource" />
+      <sourceFolder url="file://$MODULE_DIR$/src/test/java" isTestSource="true" />
+      <excludeFolder url="file://$MODULE_DIR$/target" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="library" name="Maven: junit:junit:4.8" level="project" />
+    <orderEntry type="library" name="Maven: org.jetbrains:annotations:13.0" level="project" />
+  </component>
+</module>

Tree/pom.xml

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>ru.spbau.mit.kazakov</groupId>
+    <artifactId>Tree</artifactId>
+    <version>1.0-SNAPSHOT</version>
+
+    <dependencies>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.8</version>
+        </dependency>
+        <dependency>
+            <groupId>org.jetbrains</groupId>
+            <artifactId>annotations</artifactId>
+            <version>13.0</version>
+        </dependency>
+    </dependencies>
+
+</project>

Tree/src/main/java/ru/srbau/mit/kazakov/Tree.java

@@ -0,0 +1,100 @@
+package ru.srbau.mit.kazakov;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Generic binary search tree.
+ *
+ * @param <T> type of stored data
+ */
+public class Tree<T extends Comparable<? super T>> {
+    private int size = 0;
+    @Nullable
+    private Node root = null;
+
+    /**
+     * Node for binary search tree. Stores left, right children and data.
+     */
+    private class Node {
+        private Node left = null;
+        private Node right = null;
+        private T data;
+
+        /**
+         * Initializes data with specified value.
+         *
+         * @param value to initialize with
+         */
+        private Node(@NotNull T value) {
+            data = value;
+        }
+    }
+
+    /**
+     * Returns number of stored elements in the tree.
+     */
+    public int size() {
+        return size;
+    }
+
+    /**
+     * Checks if there is a value equals to specified value.
+     *
+     * @param value to check
+     * @return true if there is such value, and false otherwise
+     */
+    public boolean contains(@NotNull T value) {
+        Node current = root;
+
+        while (current != null) {
+            if (current.data.compareTo(value) > 0) {
+                current = current.left;
+            } else if (current.data.compareTo(value) < 0) {
+                current = current.right;
+            } else if (current.data.compareTo(value) == 0) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Adds new Node storing specified value to the tree.
+     *
+     * @param value to add
+     * @return false if there was specified value, and true otherwise
+     */
+    public boolean add(@NotNull T value) {
+        if (contains(value)) {
+            return false;
+        }
+        if (root == null) {
+            root = new Node(value);
+            size++;
+            return true;
+        }
+
+        Node current = root;
+        Node parent = null;
+        while (current != null) {
+            parent = current;
+            if (current.data.compareTo(value) > 0) {
+                current = current.left;
+            } else if (current.data.compareTo(value) < 0) {
+                current = current.right;
+            }
+
+        }
+
+        if (parent.data.compareTo(value) < 0) {
+            parent.right = new Node(value);
+        } else if (parent.data.compareTo(value) > 0) {
+            parent.left = new Node(value);
+        }
+
+        size++;
+        return true;
+    }
+}

Tree/src/test/java/ru/srbau/mit/kazakov/TreeTest.java

@@ -0,0 +1,80 @@
+package ru.srbau.mit.kazakov;
+
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class TreeTest {
+    @Test
+    public void testConstructor() {
+        new Tree<Integer>();
+    }
+
+    @Test
+    public void testAddNotExisting() {
+        Tree<Boolean> tree = new Tree<Boolean>();
+        assertTrue(tree.add(false));
+        assertTrue(tree.contains(false));
+    }
+
+    @Test
+    public void testAddExisting() {
+        Tree<Integer> tree = new Tree<Integer>();
+        tree.add(1);
+        assertFalse(tree.add(1));
+        assertTrue(tree.contains(1));
+    }
+
+    @Test
+    public void testAddOneHundred() {
+        Tree<Integer> tree = new Tree<Integer>();
+        for (int i = 0; i < 100; i++) {
+            assertTrue(tree.add(i));
+        }
+
+        assertTrue(tree.contains(50));
+    }
+
+    @Test
+    public void sizeEmpty() {
+        Tree<String> tree = new Tree<String>();
+        assertEquals(0, tree.size());
+    }
+
+    @Test
+    public void sizeOne() {
+        Tree<String> tree = new Tree<String>();
+        tree.add("abacaba");
+        assertEquals(1, tree.size());
+    }
+
+    @Test
+    public void testSizeOneHundred() {
+        Tree<Integer> tree = new Tree<Integer>();
+        for (int i = 0; i < 100; i++) {
+            assertTrue(tree.add(i));
+        }
+
+        assertEquals(100, tree.size());
+    }
+
+    @Test
+    public void testContainsEmpty() {
+        Tree<Character> tree = new Tree<Character>();
+        assertFalse(tree.contains('z'));
+    }
+
+    @Test
+    public void testContainsNotExisting() {
+        Tree<Character> tree = new Tree<Character>();
+        tree.add('a');
+        assertFalse(tree.contains('z'));
+    }
+
+    @Test
+    public void testContainsExisting() {
+        Tree<Character> tree = new Tree<Character>();
+        tree.add('a');
+        assertTrue(tree.contains('a'));
+    }
+}