@Test
public void testSinglePath() {
Trie trie = new Trie();
assertTrue(trie.getRoot().hasSinglePath());
trie.add("abcdef");
assertTrue(trie.getRoot().hasSinglePath());
trie.add("abdfg");
Node rootNode = trie.getRoot();
assertEquals(2, rootNode.getChildren()[0].getChildren()[0].getChildren().length);
assertTrue(rootNode.getChildren()[0].getChildren()[0].getChildren()[0].hasSinglePath());
assertTrue(rootNode.getChildren()[0].getChildren()[0].getChildren()[1].hasSinglePath());
}
@Test
public void testGetChildren() {
Trie trie = new Trie();
trie.add("aa");
trie.add("ab");
trie.add("bb");
Node rootNode = trie.getRoot();
assertEquals(2, rootNode.getChildren().length);
assertEquals(2, rootNode.getChildren()[0].getChildren().length);
assertEquals(1, rootNode.getChildren()[1].getChildren().length);
}
@Override
public void runAlgorithm() throws InterruptedException {
setHeader("trieinsert", s.substring(0, s.length() - 1));
if (s.compareTo("$") == 0) {
addNote("badword");
}
TrieNode v = T.getRoot();
v.mark();
addNote("trieinsertnote");
addStep("trierootstart");
pause();
v.unmark();
hw = new TrieWordNode(T, s);
hw.setColor(NodeColor.INSERT);
addToScene(hw);
hw.goNextTo(v);
while (s.compareTo("$") != 0) {
final char ch = s.charAt(0);
hw.setAndGoNextTo(s, v);
TrieNode w = v.getChildWithCH(ch);
if (w != null) {
addStep("trieinsertwch", "" + ch);
} else {
addStep("trieinsertwoch", "" + ch);
w = v.addChild(ch, hw.x, hw.y);
}
w.setColor(NodeColor.CACHED);
T.reposition();
pause();
v = w;
v.setColor(NodeColor.INSERT);
T.reposition();
s = s.substring(1);
}
hw.setAndGoNextTo(s, v);
final TrieNode w = v.getChildWithCH('$');
if (w == null) {
addStep("trieinserteow");
} else {
addStep("trieinsertneow");
}
pause();
v.setColor(NodeColor.NORMAL);
v = v.addChild('$', hw.x, hw.y);
T.reposition();
hw.setAndGoNextTo(s, v);
beforeReturn();
}
@Override
public void run() {
if (s.compareTo("$") == 0) {
addNote("badword");
}
TrieNode v = T.getRoot();
v.mark();
addNote("trieinsertnote");
addStep("trierootstart");
mysuspend();
v.unmark();
T.hw = new TrieWordNode(T, s);
T.hw.setColor(NodeColor.INSERT);
T.hw.goNextTo(v);
while (s.compareTo("$") != 0) {
char ch = s.charAt(0);
T.hw.setAndGoNextTo(s, v);
TrieNode w = v.getChildWithCH(ch);
if (w != null) {
addStep("trieinsertwch", "" + ch);
} else {
addStep("trieinsertwoch", "" + ch);
w = v.addChild(ch, T.hw.x, T.hw.y);
}
w.setColor(NodeColor.CACHED);
T.reposition();
mysuspend();
v = w;
v.setColor(NodeColor.INSERT);
T.reposition();
s = s.substring(1);
}
T.hw.setAndGoNextTo(s, v);
TrieNode w = v.getChildWithCH('$');
if (w == null) {
addStep("trieinserteow");
} else {
addStep("trieinsertneow");
}
mysuspend();
v.setColor(NodeColor.NORMAL);
v = v.addChild('$', T.hw.x, T.hw.y);
T.reposition();
T.hw.setAndGoNextTo(s, v);
beforeReturn();
}
@Test
public void testGetRoot() {
Trie trie = new Trie();
Node rootNode = trie.getRoot();
assertNotNull(rootNode);
}
public ArrayList<AlternativeString> parseString(String line, Trie trie) {
char[] charsInLine = line.toCharArray();
ArrayList<AlternativeString> possibleStrings = new ArrayList<AlternativeString>();
possibleStrings.add(new AlternativeString(line, 0));
for (int i = 0; i < charsInLine.length - 1; i++) {
char[] twoLetters = {charsInLine[i], charsInLine[i + 1]};
int[] results = getEntries(twoLetters);
double probOfSpace = results[Const.BETWEEN];
double sum =
results[Const.AFTER]
+ results[Const.BEFORE]
+ results[Const.BETWEEN]
+ results[Const.NOSPACE];
probOfSpace /= sum;
if (probOfSpace > 0) { // "normalize" with divide with NOSPACE
char[] before = new char[2];
int[] resultsBefore = null;
if (i != 0) {
before[0] = charsInLine[i - 1];
before[1] = charsInLine[i];
resultsBefore = getEntries(before);
}
char[] after = new char[2];
int[] resultsAfter = null;
if (i != charsInLine.length - 2) {
after[0] = charsInLine[i + 1];
after[1] = charsInLine[i + 2];
resultsAfter = getEntries(after);
}
if (resultsBefore != null) {
double sumBefore =
resultsBefore[Const.AFTER]
+ resultsBefore[Const.BEFORE]
+ resultsBefore[Const.BETWEEN]
+ resultsBefore[Const.NOSPACE];
probOfSpace *= (resultsBefore[Const.AFTER] / sumBefore);
}
if (resultsAfter != null) {
double sumAfter =
resultsAfter[Const.AFTER]
+ resultsAfter[Const.BEFORE]
+ resultsAfter[Const.BETWEEN]
+ resultsAfter[Const.NOSPACE];
probOfSpace *= (resultsAfter[Const.BEFORE] / sumAfter);
}
if (probOfSpace > THRESHOLD) {
ArrayList<AlternativeString> toAdd = new ArrayList<AlternativeString>();
for (int j = 0; j < possibleStrings.size(); j++) {
AlternativeString as = possibleStrings.get(j);
StringBuilder sb = new StringBuilder();
sb.append(as.string);
sb.insert((i + 1) + as.nrOfSpacesInString, ' ');
String[] words = sb.toString().split(" ");
String toCheck = words[words.length - 2];
if (trie.containWord(trie.getRoot(), toCheck))
toAdd.add(new AlternativeString(sb.toString(), (as.nrOfSpacesInString + 1)));
// do nuttin
// toAdd.add(new AlternativeString(sb.toString(), (as.nrOfSpacesInString+1)));
}
for (int j = 0; j < toAdd.size(); j++) {
possibleStrings.add(toAdd.get(j));
}
}
}
}
return possibleStrings;
// for(int i = 0; i < possibleStrings.size(); i++) {
// System.out.println(""+(i+1)+" "+possibleStrings.get(i).string);
// }
}
