3

私はこの問題について考えてきましたが、良い効率的な解決策を見つけられませんでした。

バイナリツリーで特定のノード（またはアイテム）のミラーノードを見つける方法は？

// Node definition
struct _Node {
    char data;
    struct _Node* left;
    struct _Node* right;
} Node;

// Assumption:
//     "given" is guaranteed in the binary tree ("root" which is not NULL)
Node* FindMirrorNode(Node* root, Node* given)
{
     // Implementation here
}

// OR: 

// Assumption:
//    in the binary tree ("root"), there is no repeated items, which mean in each node the char data is unique;
//   The char "given" is guaranteed in the binary tree.
char FindMirrorNodeData(Node* root, char given)
{
    // Implementation here
}

注：特定のツリーのミラーツリーを見つける方法については質問していません:-)

For example, considering the tree below
              A
          /      \
       B             C
      /            /   \
    D             E     F
     \           / \
      G         H   I

The mirror node of 'D' is node 'F'; while the mirror node of 'G' is NULL.

ありがとう。

4

2 に答える 2

3

を使用して関数のソリューションを作成しましたchar。ですかFindMirrorNode(r, n) == FindMirrorNodeData(r, n->data)？

ミラーノードをスタックに保持したまま、ツリー全体を調べて特定のデータを検索する必要があります。これは非常に単純なソリューションですが、それでも非常に効率的です。必要に応じて、末尾呼び出しをに変換できますwhile。

static Node* FindMirrorNodeRec(char given, Node* left, Node* right)
{
    // if either node is NULL then there is no mirror node
    if (left == NULL || right == NULL)
        return NULL;
    // check the current candidates
    if (given == left->data)
        return right;
    if (given == right->data)
        return left;
    // try recursively
    // (first external then internal nodes)
    Node* res = FindMirrorNodeRec(given, left->left, right->right);
    if (res != NULL)
        return res;
    return FindMirrorNodeRec(given, left->right, right->left);
}

Node* FindMirrorNodeData(Node* root, char given)
{
    if (root == NULL)
        return NULL;
    if (given == root->data)
        return root;
    // call the search function
    return FindMirrorNodeRec(given, root->left, root->right);
}
于 2010-07-04T21:37:46.303 に答える
0

クリスの美しい解決策をありがとう。機能した。

Node* FindMirrorNodeRec(Node* given, Node* left, Node* right)
{
    // There is no mirror node if either node is NULL
    if (!left || !right)
        return NULL;

    // Check the left and right
    if (given == left)
        return right;
    if (given == right)
        return left;

    // Try recursively (first external and then internal)
    Node* mir = FindMirrorNodeRec(given, left->left, right->right);
    if (mir)
        return mir;

    // Internally
    return FindMirrorNodeRec(given, left->right, right->left);
}

// Find the mirror node of the given node
// Assumption: root is not NULL, and the given node is guaranteed
//             in the tree (of course, not NULL :-)
Node* FindMirrorNode(Node* const root, Node* const given)
{
    if (!root || root == given)
        return root;

    return FindMirrorNodeRec(given, root->left, root->right);
}
于 2010-07-05T05:37:36.807 に答える