예제 #1
0
        private static void _MatchRecursive(Node node, ISet<string> rtn, string letters, string prefix, int? maxMatches)
        {
            if (maxMatches != null && rtn.Count == maxMatches)
                return;

            if (node == null)
            {
                if (!rtn.Contains(letters)) rtn.Add(letters);
                return;
            }

            letters += node.Letter.ToString();

            if (prefix.Length > 0)
            {
                if (node.ContainsKey(prefix[0]))
                {
                    _MatchRecursive(node[prefix[0]], rtn, letters, prefix.Remove(0, 1), maxMatches);
                }
            }
            else
            {
                foreach (char key in node.Keys)
                {
                    _MatchRecursive(node[key], rtn, letters, prefix, maxMatches);
                }
            }
        }
예제 #2
0
        //Find a node given the key("Jo")
        public static bool Find(Node node, string key)
        {
            //Is key empty
            if (string.IsNullOrEmpty(key))
                return true;//terminal Node

            //get the first character
            string first = key.Substring(0, 1);

            //get the tail: key - first character
            string tail = key.Substring(1);

            Node curNode = node.Children.GetNodeByKey(first);

            //loop until you locate the key i.e. "Jo"
            if (curNode != null)
            {
                return Find(curNode, tail);
            }
            else
            {
                //not found, return false
                return false;
            }
        }
예제 #3
0
        //Locates a node based on the key; eg. Locates "Jo" node on the tree
        public static Node GetChildNode(Node node, string key)
        {
            //Is key empty
            if (string.IsNullOrEmpty(key))
                return node;//terminal Node?

            //get the first character
            string first = key.Substring(0, 1);

            //get the tail: key - first character
            string tail = key.Substring(1);

            //current node
            Node curNode = node.Children.GetNodeByKey(first);

            //loop until you locate the key i.e. "Jo"
            if (curNode != null)
            {
                return GetChildNode(curNode, tail);
            }
            else
            {
                //not found, return null
                return null;
            }
        }
 //Adds a node into the children list
 public void Add(Node node)
 {
     //cannot readd a same node
     if (_owner.IsParentOrChild(node))
         throw new InvalidOperationException("Cannot add an ancestor or descendant.");
     _children.Add(node);
     node.Parent = _owner;
 }
예제 #5
0
        private void InnerAddWord(string wordSubString, Node element)
        {
            if (string.IsNullOrEmpty(wordSubString) || string.IsNullOrWhiteSpace(wordSubString))
            {
                element.Occurances++;
                return;
            }

            var currChar = wordSubString[0].ToString();

            if (!element.Children.ContainsKey(currChar))
            {
                element.Children.Add(currChar, new Node(currChar) { Parent = element });
            }

            this.InnerAddWord(wordSubString.Substring(1), element.Children[currChar]);
        }
예제 #6
0
        public static void Insert(Node root, string word)
        {
            if (String.IsNullOrWhiteSpace(word))
                return;

            int index;
            var crawler = root;

            for (int level = 0; level < word.Length; level++)
            {
                index = char_to_index(word[level]);
                if (crawler.CharList[index] == null)
                    crawler.CharList[index] = new Node();

                crawler = crawler.CharList[index];
            }
            crawler.IsLeaf = true;
        }
예제 #7
0
        public static bool Search(Node root, string word)
        {
            if (string.IsNullOrWhiteSpace(word))
                return false;

            int index;
            var crawler = root;

            for (int i = 0; i < word.Length; i++)
            {
                index = char_to_index(word[i]);
                if (crawler.CharList[index] == null)
                    return false;
                crawler = crawler.CharList[index];
            }

            return (crawler != null && crawler.IsLeaf);
        }
예제 #8
0
        private bool InnerTryFindWord(string wordSubString, out int occurances, Node element)
        {
            if (string.IsNullOrEmpty(wordSubString) || string.IsNullOrWhiteSpace(wordSubString))
            {
                occurances = element.Occurances;
                return true;
            }

            var currChar = wordSubString[0].ToString();

            if (!element.Children.ContainsKey(currChar))
            {
                occurances = 0;
                return false;
            }

            return this.InnerTryFindWord(wordSubString.Substring(1), out occurances, element.Children[currChar]);
        }
예제 #9
0
        /* Gets all the childern starting from a string
           ex: returns all names starting from Jo -> John, Joe, Joseph etc*/
        public static void GetChildrenStartingFromKey(Node node, string key)
        {
            //Get the node which has the value of "Jo"
            Node curNode = GetChildNode(node, key);

            //if "Jo" found:
            if (curNode != null)
            {
                //get the children of "Jo" -> John, Joe, Joseph etc
                IEnumerator iterator = curNode.GetDepthNodes();

                while (iterator.MoveNext())
                {
                    //get child
                    Node childNode = (Node)iterator.Current;

                    //Does child have a valid full name
                    if (childNode.IsTerminal)
                        Console.WriteLine(childNode.Value);
                }
            }
        }
예제 #10
0
 public Trie()
 {
     this.root = new Node("");
 }
 //Removes a node
 public void Remove(Node node)
 {
     _children.Remove(node);
     node.Parent = null;
 }
예제 #12
0
 public TrieFilter()
 {
     RootNode = new Node { Letter = Node.Root };
 }
예제 #13
0
        static void Main(string[] args)
        {
            //Root Node
            Node root = new Node("", "");

            //Loads Names
            TextReader reader;
            string textLine;

            try
            {
                reader = new StreamReader(@"..\..\names.txt");

                while ((textLine = reader.ReadLine()) != null)
                {
                    root = Trie.InsertNode(textLine, root);
                }

                reader.Close();
            }
            catch (Exception ex)
            {
                Console.WriteLine("Error Opening File: " + ex.Message);
            }

            Console.WriteLine("Enter Option");
            Console.WriteLine("-------------------------------------");
            Console.WriteLine("1. DFS on Trie");
            Console.WriteLine("2. BFS on Trie");
            Console.WriteLine("3. Find a Name on the Directory");
            Console.WriteLine("4. Directory Lookup");
            Console.WriteLine("5. Exit");
            Console.WriteLine("--------------------------------------");
            Console.Write("Enter Option:");
            int option = int.Parse(Console.ReadLine());

            switch (option)
            {
                case 1:
                    IEnumerator iterator = root.GetDepthNodes();

                    while (iterator.MoveNext())
                    {
                        Node n = (Node)iterator.Current;
                        Console.WriteLine(n.Value);
                    }
                    break;

                case 2:
                    IEnumerator iterator2 = root.GetBreadthNodes();

                    while (iterator2.MoveNext())
                    {
                        Node n = (Node)iterator2.Current;
                        Console.WriteLine(n.Value);
                    }
                    break;

                case 3:
                    Console.Write("Enter Name to Find(Case Sensitive):");
                    string name = Console.ReadLine();
                    bool fnd = Trie.Find(root, name);

                    if (fnd)
                        Console.WriteLine("Found");
                    else
                        Console.WriteLine("Not Found");
                    break;

                case 4:
                    Console.Write("Enter Name to Lookup(Case Sensitive):");
                    string name2 = Console.ReadLine();
                    Trie.GetChildrenStartingFromKey(root, name2);
                    break;
            }

            Console.WriteLine("--------------------------------------");
            Console.WriteLine("Press any key to exit!");
            Console.ReadLine();
        }
 internal NodeCollection(Node owner)
 {
     if (null == owner) throw new ArgumentNullException("Owner");
     _owner = owner;
 }
예제 #15
0
 //determines if this node shares hierarchy with given node
 public bool IsParentOrChild(Node node)
 {
     if (node == this) return true;
     if (this.IsParentOfNode(node)) return true;
     if (this.IsChildOfNode(node)) return true;
     return false;
 }
예제 #16
0
 //Determins if this node is ancestor of the given node
 public bool IsParentOfNode(Node node)
 {
     if (_children.Contains(node)) return true;
     foreach (Node childNode in _children)
         if (childNode.IsParentOfNode(node)) return true;
     return false;
 }
예제 #17
0
 //Determins if this node is descendant of the given node
 public bool IsChildOfNode(Node node)
 {
     if (null == _parent) return false;
     if (node == _parent) return true;
     return _parent.IsChildOfNode(node);
 }
예제 #18
0
        //Inserts Names into the Trie data structure
        public static Node InsertNode(string name, Node root)
        {
            //Is name null?
            if (string.IsNullOrEmpty(name))
                throw new ArgumentNullException("Null Key");

            //set the index, start inserting characters
            int index = 1;

            //key
            string key;

            //start with the root node
            Node currentNode = root;

            //loop for all charecters in the name
            while (index <= name.Length)
            {
                //get the key character
                key = name[index - 1].ToString();

                //does the node with same key already exist?
                Node resultNode = currentNode.Children.GetNodeByKey(key);

                //No, this is a new key
                if (resultNode == null)
                {
                    //Add a node
                    Node newNode = new Node(key, name.Substring(0, index));

                    //If reached the last charaecter, this is a valid full name
                    if (index == name.Length)
                        newNode.IsTerminal = true;

                    //add the node to currentNode(i.e. Root node for the first time)
                    currentNode.Children.Add(newNode);

                    //set as the current node
                    currentNode = newNode;
                }
                else
                {
                    //node already exist, set as tghe current node
                    //and move to the next character in the name
                    currentNode = resultNode;
                }

                //move to the next character in the name
                index++;
            }

            //all done, return root node
            return root;
        }
 //Determins if the children contains a node, test for equality
 public bool Contains(Node node)
 {
     return _children.Contains(node);
 }