Евгений Кузин, Trie

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,6 @@
+#Mon Mar 26 16:07:28 MSK 2018
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-4.4.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-4.4.1-all.zip

src/main/java/ru/spbstu/kspt/task1/Trie.java

@@ -0,0 +1,144 @@
+package ru.spbstu.kspt.task1;
+
+import java.util.*;
+
+public class Trie {
+
+    static class TrieNode {
+        Map<Character, TrieNode> children = new TreeMap<>();
+        boolean branch;
+    }
+
+    TrieNode root = new TrieNode();
+
+    public void insert(String str) {
+        TrieNode node = root;
+        for (char ch : str.toLowerCase().toCharArray()) {
+            if (!node.children.containsKey(ch)) {
+                node.children.put(ch, new TrieNode());
+                if (node != root) {
+                    node.children.get(ch).branch = true;
+                }
+            } else if (node.branch) {
+                node.branch = false;
+            }
+            node = node.children.get(ch);
+        }
+    }
+
+    public boolean find(String str) {
+        TrieNode node = root;
+        for (char ch : str.toLowerCase().toCharArray()) {
+            if (!node.children.containsKey(ch)) {
+                return false;
+            } else {
+                node = node.children.get(ch);
+            }
+        }
+        return true;
+    }
+
+    public void delete(String str) {
+        TrieNode node = root;
+        for (char ch : str.toLowerCase().toCharArray()) {
+            if (node.children.get(ch) != null) {
+                if (node.branch) {
+                    node = node.children.remove(ch);
+                } else {
+                    node = node.children.get(ch);
+                }
+            }
+        }
+    }
+
+    private ArrayList<String> list = new ArrayList<>();
+
+    public ArrayList<String> search(String prefix) {
+        TrieNode node = root;
+        list.clear();
+        char c = ' ';
+        for (char ch : prefix.toCharArray()) {
+            if (node.children.containsKey(ch)) {
+                node = node.children.get(ch);
+            } else {
+                throw new IllegalArgumentException("No results for: " + prefix);
+            }
+            c = ch;
+        }
+        if (!node.branch && c != ' ') {
+            for (char ch : node.children.keySet()) {
+                StringBuilder prefixBuilder = new StringBuilder(prefix);
+                if (node.children.get(ch) == null) break;
+                prefixBuilder.append(ch);
+                searchHelp(prefixBuilder, prefixBuilder.toString(), node.children.get(ch));
+            }
+        } else {
+            StringBuilder word = new StringBuilder(prefix);
+            searchHelp(word, prefix, node);
+        }
+        if (list == null) {
+           throw new IllegalArgumentException("no results for: " + prefix);
+        }
+        return list;
+    }
+
+    private void searchHelp(StringBuilder word, String prefix, TrieNode node) {
+        Character c = ' ';
+        for (Character ch : node.children.keySet()) {
+            word.append(ch);
+            searchHelp(word, prefix, node.children.get(ch));
+            word.replace(0, word.length(), prefix);
+            c = ch;
+        }
+        if (node.children.get(c) == null) {
+            list.add(word.toString());
+        }
+    }
+
+    @Override
+    public String toString() {
+        return toStringHelp(root, new StringBuilder(), 0);
+    }
+
+    private String toStringHelp(TrieNode node, StringBuilder word, int i) {
+
+        for (Character ch : node.children.keySet()) {
+            StringBuilder strB = new StringBuilder();
+            strB.append(addSpace(i)).append(ch);
+            if (node.children != null) {
+                toStringHelp(node.children.get(ch), word, i + 1);
+                word.insert(0, strB.append("\r").toString());
+            }
+
+        }
+
+
+
+        return word.toString();
+    }
+
+    private static Map<Integer, String> spacesMap = new HashMap<>();
+
+    private String addSpace(int i) {
+        String result = spacesMap.get(i);
+        if (result == null) {
+            StringBuilder indent = new StringBuilder();
+            for (int k = 0; k < i; k++) {
+                indent.append(" ");
+            }
+            result = indent.toString();
+            spacesMap.put(i, result);
+        }
+        return result;
+    }
+
+    public boolean equals(Trie anTrie) {
+        return this.toString().equals(anTrie.toString());
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(root);
+    }
+
+}

src/test/java/ru/spbstu/kspt/task1/TrieTest.java

@@ -0,0 +1,116 @@
+package ru.spbstu.kspt.task1;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class TrieTest {
+
+
+
+    @Test
+    void insertAndDeleteTest() {
+        Trie testTrie = new Trie();
+        testTrie.insert("wolk");
+        testTrie.insert("kotAssFirst");
+        testTrie.insert("russian");
+        testTrie.insert("walt");
+        testTrie.insert("roll");
+        testTrie.insert("rrrrock");
+        testTrie.insert("word");
+        testTrie.insert("world");
+        testTrie.insert("wored");
+        testTrie.insert("worry");
+        testTrie.insert("kotlin");
+        testTrie.insert("rrrrrrrrrr");
+        assertEquals(true, testTrie.find("word"));
+        assertEquals(true, testTrie.find("worry"));
+        assertEquals(false, testTrie.find("hello"));
+        assertEquals(true, testTrie.find("kotlin"));
+        assertEquals(true, testTrie.find("wolk"));
+        assertEquals(true, testTrie.find("kotAssFirst"));
+        assertEquals(true, testTrie.find("russian"));
+        assertEquals(true, testTrie.find("rrrrock"));
+        assertEquals(true, testTrie.find("walt"));
+        assertEquals(true, testTrie.find("roll"));
+        assertEquals(true, testTrie.find("rrrrrrrrrr"));
+        assertEquals(true, testTrie.find("kotlin"));
+        testTrie.delete("world");
+        assertEquals(false, testTrie.find("world"));
+        testTrie.delete("rrrrock");
+        assertEquals(false, testTrie.find("rrrrock"));
+        testTrie.delete("russian");
+        assertEquals(false, testTrie.find("russian"));
+        testTrie.delete("kotAssFirst");
+        assertEquals(false, testTrie.find("kotAssFirst"));
+        testTrie.delete("roll");
+        assertEquals(false, testTrie.find("roll"));
+        testTrie.delete("walt");
+        assertEquals(false, testTrie.find("walt"));
+        testTrie.delete("worry");
+        assertEquals(false, testTrie.find("worry"));
+        assertEquals(true, testTrie.find("word"));
+        testTrie.delete("kotlin");
+        assertEquals(false, testTrie.find("kotlin"));
+    }
+
+    @Test
+    void searchTest() {
+        ArrayList<String> list = new ArrayList<>();
+        Trie trie = new Trie();
+        trie.insert("worry");
+        trie.insert("world");
+        trie.insert("word");
+        trie.insert("wored");
+        trie.insert("kotlin");
+        trie.insert("kotassfirst");
+        trie.insert("wolt");
+        trie.insert("wolk");
+        list.add("word");
+        list.add("wored");
+        list.add("world");
+        list.add("worry");
+        assertEquals(list ,trie.search("wor"));
+        list.clear();
+        list.add("kotassfirst");
+        list.add("kotlin");
+        assertEquals(list, trie.search("kot"));
+        list.clear();
+        list.add("wolk");
+        list.add("wolt");
+        list.add("word");
+        list.add("wored");
+        list.add("world");
+        list.add("worry");
+        assertEquals(list, trie.search("wo"));
+        list.clear();
+        try {
+            trie.search("hello");
+        }
+        catch (IllegalArgumentException e){
+            assertEquals("No results for: hello", e.getMessage());
+        }
+    }
+
+    @Test
+    void toStringTest() {
+        Trie trie = new Trie();
+        trie.insert("hello");
+        trie.insert("hey");
+        trie.insert("hola");
+        Assertions.assertEquals("h\r o\r  l\r   a\r e\r" + "  y\r" + "  l\r   l\r    o\r", trie.toString());
+    }
+
+    @Test
+    void equalsTest() {
+        Trie firstTrie = new Trie();
+        Trie secondTrie = new Trie();
+        firstTrie.insert("hello");
+        secondTrie.insert("hello");
+        assertFalse(new Trie().equals(secondTrie));
+        assertTrue(firstTrie.equals(secondTrie));
+    }
+}