示例#1
0
文件: Trie.c 项目: soras/genEditDist
// Adds transformation (string1 => string2 : value) to the trie t
int addToTrie(Trie *t, wchar_t *string1, int strLen1, wchar_t *string2, double value){
    TrieNode *tmp;
    /* if the trie is empty ... */
    if(t->firstNode == NULL){
        t->firstNode = newTrieNode(*string1);
        tmp = t->firstNode;
        if((strLen1-1) == 0)
            tmp->replacement = newEndNode(string2, value);
        else
            addToTrieDepth(tmp, string1+1, strLen1-1, string2, value);
        return 0;
    }

    tmp = t->firstNode;
    TrieNode *prev;
    prev = NULL;
    /* find common prefix from the trie */
    while(strLen1 > 0){
        /* if the left side already exists, add replacement to its ending node */
        if(strLen1 == 1 && tmp->label == *string1){
           addEndNode(tmp,string2, value);
           return 0;
        }
        /* if the label matches, proceed to the next level in depth */
        else if(tmp->label == *string1 && tmp->nextNode != NULL){
           prev = tmp;
           tmp = tmp->nextNode;
           string1 = string1 + 1;
           strLen1--;
        }
        /* if we are at the end of known prefix, expand */
        else if(tmp->label == *string1 && tmp->nextNode == NULL){
           addToTrieDepth(tmp, string1+1,strLen1-1, string2, value);
           return 0;
        }
        /* if labels did not match, check the next node in the same depth level ...*/
        else if(tmp->rightNode != NULL)
            tmp = tmp->rightNode;
        else break;
    }
    /* if common prefix was not found or was incomplete, a new branch must be started */
    tmp->rightNode = newTrieNode(*string1);
    tmp->rightNode->prevNode = prev;
    tmp = tmp->rightNode;
    if(strLen1 == 1)
       addEndNode(tmp,string2, value);
    else
       addToTrieDepth(tmp, (string1+1),strLen1-1, string2, value);
    return 0;
}
int main() {
	struct TrieNode *root = newTrieNode();
	insert(root, "hello");
	printf("%d\n", search(root, "hel"));
	free(root);
	return 0;
}
//Driver function.
int main()
{
    /* Change third ipAddress for validation */
    char ipAdd[][MAX] = {"107.108.11.123", "107.109.123.255",
                         "74.125.200.106"};
    char URL[][50] = {"www.samsung.com", "www.samsung.net",
                      "www.google.in"};
    int n = sizeof(ipAdd)/sizeof(ipAdd[0]);
    struct trieNode *root = newTrieNode();
 
    // Inserts all the ip address and their corresponding
    // domain name after ip address validation.
    for (int i=0; i<n; i++)
        insert(root,ipAdd[i],URL[i]);
 
    // If reverse DNS look up succeeds print the domain
    // name along with DNS resolved.
    char ip[] = "107.108.11.123";
    char *res_url = searchDNSCache(root, ip);
    if (res_url != NULL)
        printf("Reverse DNS look up resolved in cache:\n%s --> %s",
                ip, res_url);
    else
        printf("Reverse DNS look up not resolved in cache ");
    return 0;
}
// This method inserts an ip address and the corresponding
// domain name in the trie. The last node in Trie contains the URL.
void insert(struct trieNode *root, char *ipAdd, char *URL)
{
    // Length of the ip address
    int len = strlen(ipAdd);
    struct trieNode *pCrawl = root;
 
    // Traversing over the length of the ip address.
    for (int level=0; level<len; level++)
    {
        // Get index of child node from current character
        // in ipAdd[].  Index must be from 0 to 10 where
        // 0 to 9 is used for digits and 10 for dot
        int index = getIndex(ipAdd[level]);
 
        // Create a new child if not exist already
        if (!pCrawl->child[index])
            pCrawl->child[index] = newTrieNode();
 
        // Move to the child
        pCrawl = pCrawl->child[index];
    }
 
    //Below needs to be carried out for the last node.
    //Save the corresponding URL of the ip address in the
    //last node of trie.
    pCrawl->isLeaf = true;
    pCrawl->URL = new char[strlen(URL) + 1];
    strcpy(pCrawl->URL, URL);
}
示例#5
0
文件: Trie.c 项目: soras/genEditDist
// Adds string1 to trie, while expanding only downwards (in depth) via nextNode links
int addToTrieDepth(TrieNode *node, wchar_t *string1, int strLen1, wchar_t *string2, double value){
    TrieNode *tmp;
    /* more than 1 letters to add */
    if(strLen1 > 1){
        node->nextNode = newTrieNode(*string1);
        node->nextNode->prevNode = node;
        return addToTrieDepth(node->nextNode, string1+1, strLen1-1, string2, value);
    }
    /* only 1 letter to add */
    else{
        tmp = newTrieNode(*string1);
        tmp->prevNode  = node;
        node->nextNode = tmp;
        tmp->replacement = newEndNode(string2, value);
    }
    return 0;
}
示例#6
0
文件: check.c 项目: aidanlaw/Unix_C
/**
 * Constructs and returns a trie given a list of words.
 */
static TrieNode* buildTrie(char* dict[], int dictLength)
{
	TrieNode* root = newTrieNode();
	
	int d;
	for(d = 0; d < dictLength; d++)
	{
		addTrieWord(root, dict[d]);
	}
	
	return root;
}
void insert(struct TrieNode *root, char *word) {
	int i, length, index;
	length = strlen(word);
	if (length <= 0) return;
	struct TrieNode *current = root;
	for (i = 0; i < length; i++) {
		index = word[i] - 'a';
		if (current->children[index] == NULL) {
			current->children[index] = newTrieNode();
		}
		current = current->children[index];
	}
	current->isWord = true;
}
示例#8
0
文件: check.c 项目: aidanlaw/Unix_C
/**
 * Used by addTrieWord() to actually add a word to the trie, allocating any new
 * nodes required.
 */
static void addTrieWordRecurse(TrieNode* node, char* word)
{
	int index = *word - FIRST_ASCII_CH;
	
	if(node->children[index] == NULL) {
		node->children[index] = newTrieNode();
	}
	
	if(word[1] == '\0') {
		node->children[index]->isWord = TRUE;
	}
	else {
		addTrieWordRecurse(node->children[index], word + 1);
	}
}
示例#9
0
//--------------------------------------------------------------------------------------------------
// A utility function to insert a word to Trie
void insert(struct TrieNode** root, char* word, int index)
{

  if (*root == NULL)                                                                    // Base case
      *root = newTrieNode();
  if (*word != '\0')                 //Down - here we are calling insert as well as we are inserting
      insert( &( (*root)->child[tolower(*word) - 'a'] ), word+1, index );     //ch into child array.
  else    // while recursion stack unwinding, it will go inside to else only once for last char '\0'
  {
    if ((*root)->isEnd)                     // Insert index of this word to end of index linked list
    {                             // going inside this means this word is already present in Trie DS
      IndexNode* pCrawl = (*root)->head;
      while( pCrawl->next )
          pCrawl = pCrawl->next;                                 // going till the last of the link.
      pCrawl->next = newIndexNode(index);
    }
    else                                                                   // If Index list is empty
    {                                            // We are first time adding this word into Trie DS.
      (*root)->isEnd = 1;
      (*root)->head = newIndexNode(index);
    }
  }
}