在C ++中搜索树中节点的最快方法

Question

#ifndef __TREE_H
#define __TREE_H
#include <cstdlib>
#include<string>

// structure of a tree node

struct TreeNode{
        string str;
        TreeNode *parent;
        TreeNode *leftChild;
        TreeNode *nextSibling;

        TreeNode(string str1){
                this->str = str1;
                this->parent = NULL;
                this->leftChild = NULL;
                this->nextSibling = NULL;
        }

};

class Tree{

        TreeNode* root;
        int size;

public:

        Tree();         //constructor

        void insert(string str1);       //insert a node

        string locate(string str1);     //locate a node

        TreeNode *ancestor(string str1, string str2);   //get lowest common ancestor
};


#endif

this is a class of a generic tree (not a binary tree). What will be the fastest way to implement the locate function? should i go through all the child first and then the siblings or what?

Answer 1

If the tree is unordered there is no algorithm other than brute force testing of all nodes and break out when the element is found (if found). When dealing with trees, recursion is usually the simplest approach. The pseudo algorithm could be something like:

find(current_node,value):

if current_node.value == value
   return found
else 
   if find(current_node.left,value) == found
      return found
   else if find(current_node.right,value) == found
      return found
   else
      return not_found

Of course, when really implementing this you will need to test for null pointers, and so on. Without any other constraints on the tree, the asymptotic complexity cannot be reduced. You might be able to come with a non-recursive approach or a tail-recursion algorithm (based on the above) that might improve the constant factors, but don't expect a huge improvement there.

Answer 2

If the nodes are ordered, ie children are less than this node and siblings are greater than this node, you compare with str and, depending on the result, have this node as a result or search down the children or compare with the siblings

const TreeNode *TreeNode::locate(const string &str1) const
{
    int c = str.compare(str1);
    if (c == 0)
        return this;

    if (c > 0) {
        if (leftChild)
            return leftChild->locate(str1);

        return 0;
    }

    if (nextSibling)
        return nextSibling->locate(str1);

    return 0;
}

and in Tree

const TreeNode *Tree::locate(const string &str1) const
{
    return root->locate(str1);
}

Answer 3

You can try several tree traversal algorithms depending on how your information is distributed among the tree nodes.

BFS, DFS, are some examples.