3

I've been thinking of this problem, and I have not found a good, efficient solution.

How to find the mirror node of a given node (or item) in a binary tree?

// 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
}

NOTE: I'm NOT asking on how to find a mirror tree of a given tree :-)

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.

Thanks.

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 回答