typename BinaryTree<T>::Node* BinaryTree<T>::_Find(Node *root,const T &value){
if(root==NULL){
return NULL;
}
if(root->_value == value){
return root;
}
Node *ret = _Find(root->_left,value);
if(ret==NULL){
ret = _Find(root->_right,value);
}
return ret;
}
bool _Find(vector<vector<char> >& board, int curM, int curN,
string& word, int p, vector<vector<bool> >& used) {
if (p >= word.size()) return true;
int m = board.size();
int n = board[0].size();
static int M_DIFF[] = {-1, 0, 1, 0};
static int N_DIFF[] = {0, 1, 0, -1};
for (int i = 0; i < 4; ++i) {
int newM = curM + M_DIFF[i];
int newN = curN + N_DIFF[i];
if (newM < 0 || newM >= m || newN < 0 || newN >= n)
continue;
if (used[newM][newN])
continue;
if (board[newM][newN] == word[p]) {
used[newM][newN] = true;
if (_Find(board, newM, newN, word, p+1, used))
return true;
else
used[newM][newN] = false;
}
}
return false;
}
bool FileFinder::_Find(DirectorySpecifier &dir, Typecode type, bool recursive, int depth)
{
// Get list of entries in directory
vector<dir_entry> entries;
if (!dir.ReadDirectory(entries))
return false;
sort(entries.begin(), entries.end());
// Iterate through entries
vector<dir_entry>::const_iterator i, end = entries.end();
for (i = entries.begin(); i != end; i++) {
// Construct full specifier of file/dir
FileSpecifier file = dir + i->name;
if (i->is_directory) {
if (depth == 0 && i->name == "Plugins")
continue;
// Recurse into directory
if (recursive)
if (_Find(file, type, recursive, depth + 1))
return true;
} else {
// Check file type and call found() function
if (type == WILDCARD_TYPE || type == file.GetType())
if (found(file))
return true;
}
}
return false;
}
Node<T> * _Find(Node<T> *pRoot, const T &data)
{
if (NULL != pRoot)
{
if (pRoot->_val == data)
return pRoot;
else
{ Node<T> *ret;
ret = _Find(pRoot->pLeft, data);
if (ret)
return ret;
ret = _Find(pRoot->pRight, data);
if (ret)
return ret;
}
}
return NULL;
}
BSTNode<K,V>* _Find(BSTNode<K,V>* root, const K& key)
{
if (root)
{
if (root->_key > key)
{
return _Find(root->_left, key);
}
else if (root->_key < key)
{
return _Find(root->_right, key);
}
else
{
return root;
}
}
return NULL;
}
/*!
Returns false if argv dispatcher with the same name already
registered
*/
bool
Settings::Add(SettingsArgvDispatcher* setting)
{
// check for uniqueness
if (_Find(setting->Name()))
return false;
if (fCount >= fListSize) {
fListSize += 30;
fList = (SettingsArgvDispatcher **)realloc(fList,
fListSize * sizeof(SettingsArgvDispatcher *));
}
fList[fCount++] = setting;
return true;
}
//---------------------------------------------------------
void CCandidates::Add(int x, int y, int Segment, double Similarity)
{
if( m_Candidates && m_nCandidates < m_nMax )
{
int iInsert = _Find(Similarity);
memmove(m_Candidates + iInsert + 1, m_Candidates + iInsert, sizeof(TCandidate) * (m_nCandidates - iInsert));
m_Candidates[iInsert].x = x;
m_Candidates[iInsert].y = y;
m_Candidates[iInsert].Segment = Segment;
m_Candidates[iInsert].Similarity = Similarity;
}
else
{
if( !m_pLow )
{
int iDivide = m_nMax / 2;
m_pLow = new CCandidates(m_nMax);
m_pHigh = new CCandidates(m_nMax);
m_pLow ->m_nCandidates = iDivide;
m_pHigh->m_nCandidates = m_nMax - iDivide;
memcpy(m_pLow ->m_Candidates, m_Candidates , m_pLow ->m_nCandidates * sizeof(TCandidate));
memcpy(m_pHigh->m_Candidates, m_Candidates + m_pLow->m_nCandidates, m_pHigh->m_nCandidates * sizeof(TCandidate));
SG_Free(m_Candidates);
m_Candidates = NULL;
}
if( Similarity > m_pHigh->Get_Minimum() )
{
m_pHigh->Add(x, y, Segment, Similarity);
}
else
{
m_pLow ->Add(x, y, Segment, Similarity);
}
}
m_nCandidates++;
}
bool exist(vector<vector<char> > &board, string word) {
if (board.empty() || board[0].empty() || word.empty())
return false;
int m = board.size();
int n = board[0].size();
for (int i = 0; i < m; ++i) {
for (int j = 0; j < n; ++j) {
if (board[i][j] == word[0]) {
vector<vector<bool> > used(m, vector<bool>(n, false));
used[i][j] = true;
if (_Find(board, i, j, word, 1, used)) return true;
used[i][j] = false;
}
}
}
return false;
}
typename BinaryTree<T>::Node* BinaryTree<T>::Find(const T &value){
return _Find(_root,value);
}
status_t
Attribute::Find(int32 index)
{
return _Find(NULL, index);
}
status_t
Attribute::Find(const char* name)
{
return _Find(name, -1);
}
status_t
BPlusTree::FindExact(struct btrfs_key &key, void** _value, size_t* _size)
{
return _Find(key, _value, _size, BPLUSTREE_EXACT);
}
status_t
BPlusTree::FindPrevious(struct btrfs_key &key, void** _value, size_t* _size)
{
return _Find(key, _value, _size, BPLUSTREE_BACKWARD);
}
status_t
BPlusTree::FindNext(struct btrfs_key &key, void** _value, size_t* _size)
{
return _Find(key, _value, _size, BPLUSTREE_FORWARD);
}
BSTNode<K,D>* Find(const K& key)
{
return _Find(_root, key);
}
BSTNode<K,V>* Find_R(const K& key)
{
return _Find(_root, key);
}
Node<T> * Find(const T &data)
{
return _Find(pRoot, data);
}
