leecode 解题总结：211. Add and Search Word - Data structure design

#include <iostream>
#include <stdio.h>
#include <vector>
#include <string>
using namespace std;
/*
问题:
Design a data structure that supports the following two operations:

void addWord(word)
bool search(word)
search(word) can search a literal word or a regular expression string containing only letters a-z 
or .. A . means it can represent any one letter.

For example:

addWord("bad")
addWord("dad")
addWord("mad")
search("pad") -> false
search("bad") -> true
search(".ad") -> true
search("b..") -> true
Note:
You may assume that all words are consist of lowercase letters a-z.

分析:分析"."或".."，代表任意字符，需要先实现前缀树，则对于"."的处理需要发给所有孩子节点去查询
则存在递归调用多个，只要有一个符合就返回true

前缀树可以不用递归，后缀树需要

输入:
7(指令个数)
addWord bad
addWord dad
addWord mad
search pad
search bad
search .ad
search b..

输出:
false
true
true
true

关键:
1 通配符：添加+搜索 是前缀树的结构，"."代表任意字符，需要先实现前缀树，则对于"."的处理需要发给所有孩子节点去查询
则存在递归调用多个，只要有一个符合就返回true
2
		//遇到"."需要递归查找后续所有非空节点
		if('.' == word.at(pos))
		{
			for(int i = 0 ; i < CHILD_SIZE ; i++)
			{
				childNode = _childs[i];
				//如何判断查找结束，当前待查找字符对应节点存在，且完成标记为真
				if(pos == len - 1 && (childNode) && childNode->_isFinish)
				{
					return true;
				}
				if(childNode)
				{
					bool result = childNode->search(word,  pos+1);
					if(result)
					{
						return true;
					}
				}
			}
			return false;
		}
*/

const int CHILD_SIZE = 26;
class TrieNode
{
public:
	TrieNode()
	{
		_isFinish = false;
		memset(_childs , NULL , sizeof(_childs));
	}

	bool search(string& word  ,int pos) {
		if(word.empty() || pos < 0 || pos >= word.length())
		{
			return false;
		}
		int len = word.length();
		TrieNode* childNode = NULL;
		//遇到"."需要递归查找后续所有非空节点
		if('.' == word.at(pos))
		{
			for(int i = 0 ; i < CHILD_SIZE ; i++)
			{
				childNode = _childs[i];
				//如何判断查找结束，当前待查找字符对应节点存在，且完成标记为真
				if(pos == len - 1 && (childNode) && childNode->_isFinish)
				{
					return true;
				}
				if(childNode)
				{
					bool result = childNode->search(word,  pos+1);
					if(result)
					{
						return true;
					}
				}
			}
			return false;
		}
		else
		{
			int index = word.at(pos) - 'a';
			if(index < 0 || index > 25)
			{
				return false;
			}
			childNode = _childs[index];
			//如何判断查找结束，当前待查找字符对应节点存在，且完成标记为真
			if(pos == len - 1 && childNode && childNode->_isFinish)
			{
				return true;
			}
			if(childNode)
			{
				return childNode->search(word , pos+1);
			}
			else
			{
				return false;
			}
		}
	}
public:
	bool _isFinish;
	TrieNode* _childs[CHILD_SIZE];
};

class WordDictionary {
public:
    /** Initialize your data structure here. */
    WordDictionary() {
        _root = new TrieNode();
    }
    
    /** Adds a word into the data structure. */
    void addWord(string word) {
		if(word.empty())
		{
			return ;
		}
		int len = word.length();
		TrieNode* curNode = _root;
		for(int i = 0 ; i < len ; i++)
		{
			int index = word.at(i) - 'a';
			if(index < 0 || index > 25)
			{
				return;
			}
			TrieNode* childNode = curNode->_childs[index];
			if(!childNode)
			{
				childNode = new TrieNode();
				curNode->_childs[index] = childNode;//注意赋值
			}
			curNode = childNode; 
		}     
		curNode->_isFinish = true;
    }
    
    /** Returns if the word is in the data structure. A word could contain the dot character '.' to represent any one letter. */
    //由于这里查找中可能包含通配符，因此，这必须是一个递归查找
	bool search(string word) {
		if(word.empty())
		{
			return false;
		}
		bool result = _root->search(word , 0);
		return result;
    }

	~WordDictionary()
	{
		deleteNode(_root);
	}

	void deleteNode(TrieNode* root)
	{
		if(!root)
		{
			return;
		}
		for(int i = 0 ; i < CHILD_SIZE ; i++)
		{
			TrieNode* childNode = root->_childs[i];		
			if(childNode)
			{
				deleteNode(childNode);
			}
		}
		if(root)
		{
			delete root;
			root = NULL;
		}
	}

private:
	TrieNode* _root;
};

void print(vector<int>& result)
{
	if(result.empty())
	{
		cout << "no result" << endl;
		return;
	}
	int size = result.size();
	for(int i = 0 ; i < size ; i++)
	{
		cout << result.at(i) << " " ;
	}
	cout << endl;
}

void process()
{
	 vector<int> nums;
	 string value;
	 int commandNum;
	 vector<int> result;
	 string command;
	 while(cin >> commandNum)
	 {
		 WordDictionary obj;
		for(int i = 0 ; i < commandNum ; i++)
		{
			cin >> command >> value;
			if("addWord" == command)
			{
				obj.addWord(value);
			}
			else if("search" == command)
			{
				bool result = obj.search(value);
				if(result)
				{
					cout << "true" << endl;
				}
				else
				{
					cout << "false" << endl;
				}
			}
		}
		cout << endl;
	 }
}

int main(int argc , char* argv[])
{
	process();
	getchar();
	return 0;
}