๋ฌธ์์ด์ ํจ์จ์ ์ผ๋ก ์ ์ฅํ๊ณ ๊ฒ์ํ๋ ๋ฐ ์ฌ์ฉ๋๋ ํธ๋ฆฌ ๊ธฐ๋ฐ์ ์๋ฃ๊ตฌ์กฐ
์ฌ์ ๊ณผ ๊ฐ์ ๋จ์ด ๊ฒ์, ์๋ ์์ฑ, ์ ๋์ฌ ๋งค์นญ ๋ฑ์ ์ ์ฉํ๋ค.
Pros
- ๋ถ์์ ํ ํด์ ํจ์๋ฅผ ์ฌ์ฉํ๋ ํด์ํ ์ด๋ธ๊ณผ ๋น๊ตํ ๋, ์๋ฃ์ ์ ๊ทผํ ๋ ์ต์ ์ ๊ฒฝ์ฐ ๋ ๋ ์ ๋ฆฌํ ์๊ฐ๋ณต์ก๋๋ฅผ ๊ฐ๋๋ค. m์ด ํ์ํ ๋ฌธ์์ด์ ๊ธธ์ด์ผ ๋ ์๊ฐ๋ณต์ก๋๋ O(m)์ด๋ค. ๋ณดํต ํด์ํ ์ด๋ธ์ ํ์ ์๊ฐ์ด O(1)์ด๊ณ ํด์ ํจ์ ํ๊ฐ ์๊ฐ์ด O(m)์ด์ง๋ง, ๋ถ์์ ํ ํด์ ํ ์ด๋ธ์ ํค ์ถฉ๋์ด ์ผ์ด๋ ์ ์์ผ๋ฏ๋ก,ย O(N)์ด ๋ ์ ์๋ค.
- ํธ๋ผ์ด์์๋ ํค ์ถฉ๋์ด ์ผ์ด๋์ง ์๋๋ค.
- ์ฌ๋ฌ ๊ฐ์ด ํ๋์ ํค์ ์ฐ๊ด๋์ด ์์ง ์๋ ํ ๋ฒํท์ด ํ์ ์๋ค.
- ํด์ ํจ์๊ฐ ์์ด๋ ๋๋ค. ํค๊ฐ ๋์ด๋ ๋ ํด์ ํจ์๋ฅผ ๋ณ๊ฒฝํ ํ์๋ ์๋ค.
- ๋ชจ๋ ํญ๋ชฉ์ด ํค์ ๋ฐ๋ผ ์ฌ์ ์์ผ๋ก ์ ๋ ฌ๋์ด ์๋ค.
Cons
- ์กฐํ๋ ํด์ ํ ์ด๋ธ๋ณด๋ค ๋๋ฆด ์ ์๋ค. ํนํ ์ฃผ ๋ฉ๋ชจ๋ฆฌ์ ๋นํด ์์ ์ ๊ทผ ๋น์ฉ์ด ํฐ ํ๋ ๋์คํฌ ๋๋ผ์ด๋ธ์ ๊ฐ์ ๋ณด์กฐ ๊ธฐ์ต์ฅ์น์์ ์ง์ ์ฝ๋๋ค๋ฉด ๋์ฑ ๊ทธ๋ ๋ค
- ๋ถ๋์์์ ๊ณผ ๊ฐ์ด ๋ฌธ์์ด๋ก ์ฅํฉํ๊ฒ ํ์๋๋ ์๋ฃ์ ๊ฒฝ์ฐ ๋ฌด์๋ฏธํ๊ฒ ๊ธธ๊ฒ ๋์ด์ง ์ ๋์ฌ์ ๋
ธ๋๋ฅผ ๊ฐ์ง ์ ์๋ค.
- ํ์ค IEEE ๋ถ๋์์์ ์๋ ๋นํธ ํธ๋ผ์ด๋ก ์ฒ๋ฆฌํ ์๋ ์๋ค.
- ํธ๋ผ์ด๊ฐ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๋ ์๋นํ ์ ์๋ค. ๋๋ถ๋ถ์ ํด์ ํ ์ด๋ธ์์๋ ์ ์ฒด ํญ๋ชฉ์ ํ๋์ ๋ฉ๋ชจ๋ฆฌ ์ฒญํฌ์ ์ฌ๋ฆฌ๊ณค ํ์ง๋ง, ํธ๋ผ์ด์์๋ ๊ฒ์ ๋ฌธ์์ด์ ๊ฐ ๋ฌธ์๋ง๋ค ๋ฉ๋ชจ๋ฆฌ๊ฐ ํ ๋น๋ ์ ์๋ค.
Insert
- ๋ฃจํธ ๋ ธ๋์์ ์์ํด ๋ฌธ์์ด์ ๊ฐ ๋ฌธ์๋ฅผ ํธ๋ฆฌ์ ๊น์ด๋ฅผ ๋ฐ๋ผ๊ฐ๋ฉฐ ๋ ธํธ๋ฅผ ์ถ๊ฐํ๋ค.
- ๋ฌธ์์ด์ ๊ฐ ๋ฌธ์์ ๋ํด ์์ ๋ ธ๋๊ฐ ์์ผ๋ฉด ์๋ก์ด ๋ ธ๋๋ฅผ ์ถ๊ฐํ๊ณ , ์์ผ๋ฉด ๊ธฐ์กด ๋ ธ๋๋ฅผ ๋ฐ๋ผ๊ฐ๋ค.
- ๋ฌธ์์ด์ ๋์ ๋๋ฌํ๋ฉด ํด๋น ๋ ธ๋์ endOfWord๋ฅผ true๋ก ํ์ํ๋ค
Search
- ๋ฃจํธ ๋
ธ๋์์ ์์ํด ๋ฌธ์๋ฅผ ๋ฐ๋ผ๊ฐ๋ค ๋ชจ๋ ๋ฌธ์๊ฐ ํธ๋ฆฌ์์ ์ผ์นํ๋ฉด ๋ง์ง๋ง ๋
ธ๋๊ฐ endOfWord ๋ฅผ ๊ฐ์ง๊ณ ์๋์ง ํ์ธํ๋ค.
- endOfWord๋ฅผ ๊ฐ์ง๊ณ ์์ง ์๋ค๋ฉด ์กด์ฌํ์ง ์๋ ๋ฌธ์์ด์ด๋ค
Delete
- ๋จผ์ ๋ฌธ์์ด์ด ์กด์ฌํ๋์ง ํ์ธํ๋ค.
- ์กด์ฌํ๋ค๋ฉด ๋ง์ง๋ง ๋ ธ๋์ธ endOfWord๋ฅผ false๋ก ๋ณ๊ฒฝํ๋ค. ๋ง์ง๋ง ๋ ธ๋์ ์์์ด ์๋ค๋ฉด ๋๋จธ์ง ๋ ธ๋๋ค์ ์ญ์ ํ์ง ์๊ณ ์๋ค๋ฉด ๋ค๋ฅธ ์์ ๋ ธ๋๊ฐ ์์ ๋ ๊น์ง ์์ ๋ ธ๋๋ก ์ด๋ํ๋ฉฐ ๋ ธ๋๋ฅผ ์ญ์ ํ๋ค.
Code
public class Trie {
private class TrieNode {
Map<Character, TrieNode> children = new HashMap<>();
boolean isEndOfWord;
public TrieNode() {
this.isEndOfWord = false;
}
}
private final TrieNode root;
public Trie() {
root = new TrieNode();
}
// insert
public void insert(String word) {
TrieNode current = root;
for (char ch : word.toCharArray()) {
current = current.children.computeIfAbsent(ch, c -> new TrieNode());
}
current.isEndOfWord = true;
}
// search
public boolean search(String word) {
TrieNode current = root;
for (char ch : word.toCharArray()) {
current = current.children.get(ch);
if (current == null) {
return false;
}
}
return current.isEndOfWord;
}
// delete
public void delete(String word) {
delete(root, word, 0);
}
private boolean delete(TrieNode current, String word, int index) {
if (index == word.length()) {
if (!current.isEndOfWord) {
return false;
}
current.isEndOfWord = false;
return current.children.isEmpty();
}
char ch = word.charAt(index);
TrieNode node = current.children.get(ch);
if (node == null) {
return false;
}
boolean shouldDeleteCurrentNode = delete(node, word, index + 1);
if (shouldDeleteCurrentNode) {
current.children.remove(ch);
return current.children.isEmpty() && !current.isEndOfWord;
}
return false;
}
public static void main(String[] args) {
Trie trie = new Trie();
trie.insert("hello");
trie.insert("helium");
System.out.println(trie.search("hello")); // true
System.out.println(trie.search("helix")); // false
trie.delete("hello");
System.out.println(trie.search("hello")); // false
System.out.println(trie.search("helium")); // true
}
}