๊ฐ๋
n-ary tree์ ๋ณ์ข ์ผ๋ก ๊ฐ ๋ ธ๋์ ๋ฌธ์๋ฅผ ์ ์ฅํ๋ ์๋ฃ๊ตฌ์กฐ์ด๋ค.
ํธ๋ฆฌ๋ฅผ ์๋์ชฝ์ผ๋ก ์ํํ๋ฉด ๋จ์ด ํ๋๊ฐ ๋์จ๋ค.
* ๋ ธ๋
* ๋ ธ๋๋ ๋ ๋ ธ๋๋ผ๊ณ ๋ ๋ถ๋ฆฌ๋ฉฐ ๋จ์ด์ ๋์ ๋ํ๋ธ๋ค.
TrieNode๋ฅผ ์์ํ TerminatingTrieNode๋ก ํํํ ์๋ ์๊ณ
* ๋ ธ๋์ ๋ถ๋ชจ ๋ ธ๋ ์์ boolean flag๋ฅผ ์๋ก ์ ์ํด ๋จ์ด์ ๋์ ํํํ ์๋ ์๋ค.
์์ ๋ ธ๋ ๊ฐ์
* ๋ ธ๋๋ก ๋จ์ด์ ๋์ ํํํ๋ฉด ๊ฐ ๋ ธ๋๋ 1๊ฐ ~ (ALPHABET_SIZE + 1)๊ฐ๊น์ง ์์์ ๊ฐ๊ณ ์์ ์ ์๋ค.
๋จ * ๋ ธ๋ ๋์ boolean flag๋ก ํํํ๋ค๋ฉด 0๊ฐ ~ ALPHABET_SIZE๊ฐ๊น์ง.
ํ์ฉ
์ ๋์ฌ๋ฅผ ๋น ๋ฅด๊ฒ ์ฐพ์๋ณด๊ธฐ ์ํด ๋ชจ๋ ๋ฌธ์์ด์ ํธ๋ผ์ด์ ์ ์ฅํด๋์ ์ ์๋ค.
ํด์ํ ์ด๋ธ์ ์ด์ฉํ๋ฉด ์ฃผ์ด์ง ๋ฌธ์์ด์ ์ ํจ์ฑ์ ๋น ๋ฅด๊ฒ ํ์ธํ ์ ์์ง๋ง,
๊ทธ ๋ฌธ์์ด์ด ์ด๋ค ์ ํจํ ๋จ์ด์ ์ ๋์ฌ์ธ์ง๋ ํ์ธํ ์ ์๋ค.
Trie๋ ๊ธธ์ด๊ฐ K์ธ ๋ฌธ์์ด์ด ์ฃผ์ด์ก์ ๋ O(K) ์๊ฐ์ ํด๋น ๋ฌธ์์ด์ด ์ ํจํ ์ ๋์ฌ์ธ์ง ํ์ธํ ์ ์๋ค.
์ด ์๊ฐ์ ํด์ํ ์ด๋ธ์ ์ฌ์ฉํ์ ๋์ ์ ํํ ๊ฐ์ ์ํ ์๊ฐ์ด๋ค.
(ํํ ํด์ํ ์ด๋ธ ๊ฒ์์ด O(1) ์๊ฐ์ ์ํ๋๋ค๊ณ ํ์ง๋ง ์ ๋ ฅ ๋ฌธ์์ด์ ์ ๋ถ ์ฝ์ด์ผ ํ๋ฏ๋ก O(K)์ด๋ค.)
Reference: ์ฝ๋ฉ ์ธํฐ๋ทฐ ์์ ๋ถ์ ์ฑ
์ Trie ์ธ๊ฐ?
1) ๊ธธ์ด๊ฐ K์ธ ๋ฌธ์์ด์ ๋ํ์ฌ insert์ search๋ฅผ O(K)์ ์ํํ๋ค.
↔ BST๋ K๊ฐ ๋ฌธ์์ด์ ๊ธธ์ด, N์ด ์ ์ฒด ๋จ์ด์ ๊ฐ์๋ผ๊ณ ํ ๋ insert์ search๋ฅผ O(KlogN)์ ์ํํ๋ค.
↔ Hashing๊ณผ ๋ฌ๋ฆฌ ํด์ ํจ์๋ฅผ ๊ณ์ฐํ ํ์๊ฐ ์๊ณ Chaning์ด๋ Open addressing ๊ฐ์ Collsion handling๋ ํ์ ์๋ค.
2) (Hashing๊ณผ ๋ฌ๋ฆฌ) ๋ชจ๋ ๋จ์ด๋ฅผ ์ํ๋ฒณ ์์๋ก ์ถ๋ ฅํ๊ธฐ ์ฝ๋ค.
3) ํจ์จ์ ์ผ๋ก prefix search๋ฅผ ํ ์ ์๋ค.
Trie์ ์ด์
Trie์ ๊ฐ์ฅ ํฐ ๋จ์ ์ ๋ฉ๋ชจ๋ฆฌ๊ฐ ์์ฃผ ๋ง์ด ํ์ํ๋ค๋ ๊ฒ์ด๋ค.
๊ฐ ๋ ธ๋์ ๋ํ์ฌ (์ํ๋ฒณ ๊ฐ์๋งํผ) ์์ฃผ ๋ง์ ๋ ธ๋ ํฌ์ธํฐ๋ฅผ ๊ฐ๊ฒ๋๋ค.
์ฆ K๊ฐ ๋ฌธ์์ด์ ๊ธธ์ด, N์ด ์ ์ฒด ๋จ์ด์ ๊ฐ์์ผ ๋ ๊ณต๊ฐ ๋ณต์ก๋๊ฐ O(ALPHABET_SIZE * K * N) ์ด๋ค.
๊ณต๊ฐ ๋ฌธ์ ๊ฐ ์ค์ํ๋ค๋ฉด Compressed Trie, Ternary Search Tree ๋ฑ์ ์ฌ์ฉํ ์ ์๋ค.
--> ์ ๋ฆฌํ์๋ฉด Trie๋ ๋งค์ฐ ๋น ๋ฅด์ง๋ง ์์ฒญ ํฐ ๋ฉ๋ชจ๋ฆฌ๊ฐ ํ์ํ๋ค.
Reference: https://www.geeksforgeeks.org/advantages-trie-data-structure/,
https://www.geeksforgeeks.org/trie-insert-and-search/
๊ตฌํ
struct TrieNode{
TrieNode* children[ALPHABET_SIZE];
bool isEndOfWord;
};
๋งจ ์ ๊ทธ๋ฆผ์ฒ๋ผ, ์กด์ฌํ๋ child node๋ง ๊ทธ๋ ค๋ฃ๋ ๊ฒ ์๋๋ผ
๊ฐ ๋ ธ๋๋ง๋ค ALPHABET_SIZE๊ฐ ๋งํผ์ TrieNode*๋ฅผ ๋ฏธ๋ฆฌ ์ค๋นํ๋ค๊ณ ์๊ฐํ๋ค.
children์ ์ธ๋ฑ์ค๋ ๋ช ๋ฒ์งธ ์ํ๋ฒณ์ธ์ง๋ฅผ ์๋ฏธํ๋ค.
๊ฐ๋ น 'a'๋ผ๋ฉด children[0], 'b'๋ผ๋ฉด children[1], 'z'๋ผ๋ฉด children[25].
์ฒ์ TrieNode๊ฐ ์์ฑ๋์์ ๋๋ children[i]๊ฐ ๋ชจ๋ NULL์ด๋ผ๊ณ ์๊ฐํ๋ค.
ํด๋น TrieNode ์๋ 'a'๊ฐ ์จ๋ค๋ฉด children[0]์ด NULL์ด ์๋ ์๋ก์ด TrieNode๋ฅผ ๊ฐ๋ฆฌํค๋๋ก ํ๋ ์.
(์๋ก์ด TrieNode๋ฅผ ๊ฐ๋ฆฌํค๋๋ก ํ๋ ๊ฒ์ getNode() ๋ผ๋ ํจ์๋ฅผ ์ด์ฉํ๋ค. - ์๋ ์ฝ๋๋ฅผ ์ฐธ๊ณ )
insert์ search๋ ๋งค์ฐ ๋น์ทํ๋ฉฐ,
insert๋ getNode()๋ฅผ ์ด์ฉํด ์๋ก์ด ๋ ธ๋๋ฅผ ์ฐ๊ฒฐํด๊ฐ๋ ํํธ search๋ ๊ทธ๋ฅ ์๋๋ก ์ญ ๋ด๋ ค๊ฐ๋ค.
search๊ฐ ์ข ๋ฃ๋๋ ์กฐ๊ฑด์ ๋ ๊ฐ์ง์ด๋ค.
1) input string์ ๋์ ๋ค๋ค๋๋ค.
--> ์ด ๊ฒฝ์ฐ ๋ง์ง๋ง ๋ ธ๋์ isEndOfWord๊ฐ true์ด๋ฉด search ๊ฒฐ๊ณผ๋ true์ด๋ค.
2) trie์ ํด๋นํ๋ key๊ฐ ์๋ค.
--> search ๊ฒฐ๊ณผ๋ false์ด๋ค.
์๋๋ Reference์ ์ฝ๋์์ ๋ณ์๋ช , ์ฃผ์ ๋ฑ์ ์์ ํ ์ ์ฒด ์ฝ๋ ๋ฒ์ .
๊ฐ๋ ์ฑ์ ์ํด input string์ ๋งจ ์ ์ฌ์ง์ ์๋ ๋จ์ด๋ค๋ก ํ์๋ค.
// Ref: https://www.geeksforgeeks.org/trie-insert-and-search/
#include<iostream>
#define ALPHABET_SIZE 26
using namespace std;
struct TrieNode{
TrieNode* children[ALPHABET_SIZE];
bool isEndOfWord;
};
TrieNode* getNode()
{
TrieNode* new_node = new TrieNode;
new_node->isEndOfWord = false;
for(int i=0; i<ALPHABET_SIZE; i++){
new_node->children[i] = NULL;
}
return new_node;
}
void insert(TrieNode* root, string key)
{
TrieNode* temp_node = root;
for(int i=0; i<key.length(); i++){
int index = key[i] - 'a';
if(!temp_node->children[index])
temp_node->children[index] = getNode();
temp_node = temp_node->children[index];
}
temp_node->isEndOfWord = true;
}
bool search(TrieNode* root, string key)
{
TrieNode* temp_node = root;
for(int i=0; i<key.length(); i++){
int index = key[i] - 'a';
if(!temp_node->children[index])
return false;
temp_node = temp_node->children[index];
}
return temp_node && temp_node->isEndOfWord;
}
int main()
{
string keys[] = {"many", "man", "my", "lie", "a"};
int n = sizeof(keys) / sizeof(keys[0]);
TrieNode* root = getNode();
for(int i=0; i<n; i++)
insert(root, keys[i]);
if(search(root, "man")) cout << "Yes" << endl;
else cout << "No" << endl;
if(search(root, "lay")) cout << "Yes" << endl;
else cout << "No" << endl;
return 0;
}
Reference: https://www.geeksforgeeks.org/trie-insert-and-search/
'Problem Solving > Algorithm, Tips' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Leetcode] Min Stack (0) | 2020.06.28 |
---|---|
๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ (0) | 2020.06.24 |
์ต๋ ์ฐ์ ๋ถ๋ถ ์์ด์ ํฉ (0) | 2020.06.23 |
Kruskal / Prim Algorithm (ํฌ๋ฃจ์ค์นผ / ํ๋ฆผ ์๊ณ ๋ฆฌ์ฆ) (0) | 2020.06.02 |
Dijkstra Algorithm (๋ค์ต์คํธ๋ผ ์๊ณ ๋ฆฌ์ฆ) (0) | 2020.06.02 |
๋๊ธ