Prefix tree

The trie, or prefix tree, is a data structure for storing strings or other sequences in a way that allows for a fast look-up. In its simplest form it can be used as a list of keywords or a dictionary.
By associating each string with an object it can be used as an alternative to a hashmap. The name 'trie' comes from the word 'retrieval'.

The basic idea behind a trie is that each successive letter is stored as a separate node. To find out if the word 'cat' is in the list you start at the root and look up the 'c' node. Having found
the 'c' node you search the list of c's children for an 'a' node, and so on. To differentiate between 'cat' and 'catalog' each word is ended by a special delimiter.

The figure below shows a schematic representation of a partial trie:

Implementation

The fastest way to implement this is with fixed size arrays. Unfortunately this only works if you know which characters can show up in the sequences. For keywords with 26 letters its a fast but space
consuming option, for unicode strings its pretty much impossible.

Instead of fixed sizes arrays you can use a linked list at each node. This has obvious space advantages, since no more empty spaces are stored. Unfortunately searching a long linked list is rather
slow. For example to find the word 'zzz' you might need 3 times 26 steps.

Faster trie algorithms have been devised that lie somewhere between these two extremes in terms of speed and space consumption. These can be found by searching google.

Fun & games with prefix trees

Prefix trees are a bit of an overlooked data structure with lots of interesting possibilities.

Storage

By storing values at each leaf node you can use them as a kind of alternative hashmap, although when working with unicode strings a hashmap will greatly outperform a trie.

As a dictionary

Looking up if a word is in a trie takes O(n) operations, where n is the length of the word. Thus - for array implementations - the lookup speed doesn't change with increasing trie size.

Word completion

Word completion is straightforward to implement using a trie: simply find the node corresponding to the first few letters, and then collape the subtree into a list of possible endings.

This can be used in autocompleting user input in text editors or the T9 dictionary on your phone

Censoring strings

Given a large list of swear words and a string to censor a trie offers a speed advantage over a simple array of strings. If the swear word can appear anywhere in the string you'll need to attempt
to match it from any possible starting offset. With a string of m characters and a list of n words this would mean m*n string comparisons.

Using a trie you can attempt to find a match from each given offset in the string, this means m trie lookups. Since the speed of a trie lookup scales well with an increasing number of words this is
considerably faster than the array lookup.

Java linked list implementation

Just for fun, here's a java linked list implementation. Keep in mind that this is a fairly slow implementation. For serious speed boosts you'll need to investigate double or triple-array tries.

Please note: the version below is a simplified version intended only to give some insight into the workings of the Trie. For the full version please see theDownloads
section
.

publicclass Trie

{

    /**

     * The delimiter used in this word to tell where words end. Without a proper delimiter either A.

     * a lookup for 'win' would return false if the list also contained 'windows', or B. a lookup

     * for 'mag' would return true if the only word in the list was 'magnolia'

     *

     * The delimiter should never occur in a word added to the trie.

     */

    public
final static
char DELIMITER = '\u0001';



    /**

     * Creates a new Trie.

     */

    public Trie()

    {

        root =
new Node('r');

        size = 0;

    }



    /**

     * Adds a word to the list.

     * @param word The word to add.

     * @return True if the word wasn't in the list yet

     */

    public
boolean add(String word)

    {

        if (add(root, word+ DELIMITER,
0))

        {

            size++;

            int n
= word.length();

            if
(n > maxDepth) maxDepth
= n;

            return
true;

        }

        return
false;

    }



    /*

     * Does the real work of adding a word to the trie

     */

    private
boolean add(Node root, String word,int offset)

    {

        if (offset== word.length())return
false;

        int c
= word.charAt(offset);



        // Search for node to add to

        Node last =
null, next = root.firstChild;

        while
(next !=
null)

        {

            if
(next.value < c)

            {

                // Not found yet, continue searching

                last = next;

                next = next.nextSibling;

            }

            else
if (next.value
== c)

            {

                // Match found, add remaining word to this node

                return add(next, word, offset+
1);

            }

            // Because of the ordering of the list getting here means we won't

            // find a match

            else
break;

        }



        // No match found, create a new node and insert

        Node node =
new Node(c);

        if (last==
null)

        {

            // Insert node at the beginning of the list (Works for next == null

            // too)

            root.firstChild = node;

            node.nextSibling = next;

        }

        else

        {

            // Insert between last and next

            last.nextSibling = node;

            node.nextSibling = next;

        }



        // Add remaining letters

        for (int i= offset
+ 1; i< word.length(); i++)

        {

            node.firstChild =new Node(word.charAt(i));

            node = node.firstChild;

        }

        return
true;

    }



    /**

     * Searches for a word in the list.

     *

     * @param word The word to search for.

     * @return True if the word was found.

     */

    public
boolean isEntry(String word)

    {

        if (word.length()==
0)

            throw
new IllegalArgumentException("Word can't be empty");

        return isEntry(root, w+ DELIMITER,
0);

    }



    /*

     * Does the real work of determining if a word is in the list

     */

    private
boolean isEntry(Node root,
String word, int offset)

    {

        if (offset== word.length())return
true;

        int c
= word.charAt(offset);



        // Search for node to add to

        Node next = root.firstChild;

        while
(next !=
null)

        {

            if
(next.value < c) next= next.nextSibling;

            else
if (next.value
== c)
return isEntry(next, word, offset +1);

            else
return false;

        }

        return
false;

    }



    /**

     * Returns the size of this list;

     */

    public
int size()

    {

        return size;

    }



    /**

     * Returns all words in this list starting with the given prefix

     *

     * @param prefix The prefix to search for.

     * @return All words in this list starting with the given prefix, or if no such words are found,

     *         an array containing only the suggested prefix.

     */

    public
String[] suggest(String prefix)

    {

        return suggest(root, prefix,0);

    }



    /*

     * Recursive function for finding all words starting with the given prefix

     */

    private
String[] suggest(Node root,String word,
int offset)

    {

        if (offset== word.length())

        {

            ArrayList<String> words
= new ArrayList<String>(size);

            char[] chars=
new
char[maxDepth];

            for
(int i
= 0; i < offset; i++)

                chars[i]
= word.charAt(i);

            getAll(root, words, chars, offset);

            return words.toArray(newString[words.size()]);

        }

        int c
= word.charAt(offset);



        // Search for node to add to

        Node next = root.firstChild;

        while
(next !=
null)

        {

            if
(next.value < c) next= next.nextSibling;

            else
if (next.value
== c)
return suggest(next, word, offset +1);

            else
break;

        }

        return
new String[]{ word
};

    }



    /**

     * Searches a string for words present in the trie and replaces them with stars (asterixes).

     * @param z The string to censor

     */

    public
String censor(String s)

    {

        if (size==
0)
return s;

        String z = s.toLowerCase();

        int n
= z.length();

        StringBuilder buffer =
new StringBuilder(n);

        int match;

        char star
= '*';

        for (int i=
0; i < n;)

        {

            match = longestMatch(root, z, i,0,
0);

            if
(match > 0)

            {

                for
(int j
= 0; j < match; j++)

                {

                    buffer.append(star);

                    i++;

                }

            }

            else

            {

                buffer.append(s.charAt(i++));

            }

        }

        return buffer.toString();

    }



    /*

     * Finds the longest matching word in the trie that starts at the given offset...

     */

    private
int longestMatch(Node root,
String word, int offset,int depth,
int maxFound)

    {

        // Uses delimiter = first in the list!

        Node next = root.firstChild;

        if (next.value== DELIMITER) maxFound
= depth;

        if (offset== word.length())return
maxFound;

        int c
= word.charAt(offset);



        while
(next !=
null)

        {

            if
(next.value < c) next= next.nextSibling;

            else
if (next.value
== c)
return longestMatch(next, word,

                offset + 1, depth
+ 1, maxFound);

            else
return maxFound;

        }

        return maxFound;

    }



    /*

     * Represents a node in the trie. Because a node's children are stored in a linked list this

     * data structure takes the odd structure of node with a firstChild and a nextSibling.

     */

    private
class Node

    {

        public
int value;

        public Node firstChild;

        public Node nextSibling;



        public Node(int value)

        {

            this.value= value;

            firstChild =
null;

            nextSibling =
null;

        }

    }





    private Node root;

    private
int size;

    private
int maxDepth; // Not exact, but bounding for the maximum

}

Please note: the code given above is intended only to give some insight into the workings of the Trie. For the full version of the class please see theDownloads
section
.

Prefix tree的更多相关文章

  1. Leetcode: Implement Trie (Prefix Tree) && Summary: Trie

    Implement a trie with insert, search, and startsWith methods. Note: You may assume that all inputs a ...

  2. leetcode面试准备:Implement Trie (Prefix Tree)

    leetcode面试准备:Implement Trie (Prefix Tree) 1 题目 Implement a trie withinsert, search, and startsWith m ...

  3. 【LeetCode】208. Implement Trie (Prefix Tree)

    Implement Trie (Prefix Tree) Implement a trie with insert, search, and startsWith methods. Note:You ...

  4. [LeetCode] 208. Implement Trie (Prefix Tree) ☆☆☆

    Implement a trie with insert, search, and startsWith methods. Note:You may assume that all inputs ar ...

  5. 笔试算法题(39):Trie树(Trie Tree or Prefix Tree)

    议题:TRIE树 (Trie Tree or Prefix Tree): 分析: 又称字典树或者前缀树,一种用于快速检索的多叉树结构:英文字母的Trie树为26叉树,数字的Trie树为10叉树:All ...

  6. Trie树(Prefix Tree)介绍

    本文用尽量简洁的语言介绍一种树形数据结构 -- Trie树. 一.什么是Trie树 Trie树,又叫字典树.前缀树(Prefix Tree).单词查找树 或 键树,是一种多叉树结构.如下图: 上图是一 ...

  7. 字典树(查找树) leetcode 208. Implement Trie (Prefix Tree) 、211. Add and Search Word - Data structure design

    字典树(查找树) 26个分支作用:检测字符串是否在这个字典里面插入.查找 字典树与哈希表的对比:时间复杂度:以字符来看:O(N).O(N) 以字符串来看:O(1).O(1)空间复杂度:字典树远远小于哈 ...

  8. LeetCode208 Implement Trie (Prefix Tree). LeetCode211 Add and Search Word - Data structure design

    字典树(Trie树相关) 208. Implement Trie (Prefix Tree) Implement a trie with insert, search, and startsWith  ...

  9. 【leetcode】208. Implement Trie (Prefix Tree 字典树)

    A trie (pronounced as "try") or prefix tree is a tree data structure used to efficiently s ...

随机推荐

  1. ROS_Kinetic_x ROS栅格地图庫 Grid Map Library

    源自:https://github.com/ethz-asl/grid_map Grid Map Overview This is a C++ library with ROS interface t ...

  2. win8如何共享文件夹

    最近小编接手了市委组织部考核项目,各种文档.ER图.原型图,组员之间需要拷来拷去,很不方便,通过飞信,QQ传输吧,文件太大,网络太慢,所以还是不行,于是小编就想起来要共享,以前也映射过别人的共享,觉得 ...

  3. Tomcat内核之Tomcat的类加载器

    跟其他主流的Java Web服务器一样,Tomcat也拥有不同的自定义类加载器,达到对各种资源库的控制.一般来说,Java Web服务器需要解决以下四个问题: ①   同一个Web服务器里,各个Web ...

  4. hbase 程序优化 参数调整方法

    hbase读数据用scan,读数据加速的配置参数为: Scan scan = new Scan(); scan.setCaching(500); // 1 is the default in Scan ...

  5. Android初级教程:对文件和字符串进行MD5加密工具类

    转载请注明出处:http://blog.csdn.net/qq_32059827/article/details/52200008   点击打开链接 之前写过一篇博文,是针对字符串进行md5加密的.今 ...

  6. Android初级教程使用服务注册广播接收者监听手机解锁屏变化

    之前第七章广播与服务理论篇写到: 特殊的广播接收者(一般发广播次数频率很高) 安卓中有一些广播接收者,必须使用代码注册,清单文件注册是无效的 屏幕锁屏和解锁 电量改变 今天在这里就回顾一下,且用代码方 ...

  7. 使用C#+socket实现用移动设备控制的虚拟手柄

    近期在和同学玩死神vs火影,以怀念小时候,突然觉得用键盘玩的不够畅快,因此萌生了写一个虚拟手柄的念头. 我的思路是在移动设备(iOS.Android)上实现手柄,在电脑上监听,利用socket建立持久 ...

  8. 使用js动态添加组件

    在文章开始之前,我想说两点 1 自己初学js,文章的内容在大神看来可能就是不值一提,但是谁都是从hello world来的,望高   手不吝指教# 2 我知道这个标题起的比较蛋疼,大家看图就能说明问题 ...

  9. React Native控件之Listview

    ListView组件用于显示一个垂直的滚动列表,其中的元素之间结构近似而仅数据不同. ListView更适于长列表数据,且元素个数可以增删.和ScrollView不同的是,ListView并不立即渲染 ...

  10. 【UI 设计】PhotoShop基础工具 -- 移动工具

    还是学点美工的东西吧, 业余爱好   比学编程还难 PS版本 : PhotoShop CS6 1. 移动工具 (1) 工具栏和属性栏 工具栏 和 属性栏 : 左侧的是工具栏, 每选中一个工具, 在菜单 ...