将通用树转换为二叉树后，如何使用二叉树找到给定通用树节点“ v”的父级？

Question

I have tried two implementations and they don't quite work.

Here is one of my implementation that I am completely stuck on.

/** Returns the parent of a given node or the node itself if it is the root */
public Position<E> parent(Position<E> v) throws IllegalArgumentException {
      if(bTree.isRoot(v)) { return v; } // returns the node v itself if v is the root.
      Position<E> parent = bTree.root(); 
      // execute this recursive method and return the parent. 
      return preorderTraversal(parent, v, null);
  }

/* This is the helper method that will traverse the binary tree in PreOrder. It updates 
 * the parent until the node v has been found.
 */
private Position<E> preorderTraversal(Position<E> focusNode, Position<E> v, Position<E> parent) {

     System.out.print(focusNode.getElement() + "\t");

      if (focusNode != null && v != focusNode && hasLeft(focusNode)) {
          parent = focusNode;
          System.out.print("setting parent to: " + parent.getElement() + "\t");
          preorderTraversal(bTree.left(focusNode), v, parent);
      }
      else if (focusNode != null && v != focusNode && hasRight(focusNode)){
          preorderTraversal(bTree.right(focusNode), v, parent);
      }
      return parent;
  }

// -------------- EXTRA HELPER METHODS ---------------
private boolean hasLeft(Position<E> temp ) {
      if (bTree.left(temp) != null) return true;
      else return false;
  }

  private boolean hasRight(Position<E> temp ) {
      if (bTree.right(temp) != null) return true;
      else return false;
  }

The problem here seems to be that it traverses the left subtree, and updates the correct parents, but while returning the value, it always returns the root node. I don't seem to understand why this is so. Another is that when traversing the right subtree, my parent nodes are always wrong. Please help!

Answer 1

You are treating left and right differently without giving a motivation. You have not specified what a general tree is (one guess is every node can have more than two descendants , but, as the converted nodes nodes seem to be comparable: how many values does an original node have? And how it is converted to a binary tree (left references have been descendant references, right for siblings?) Giving a URL might be appropriate).
Combine the checks: if (null == focusNode || v == focusNode) return parent; .
Do not assign values to a variable that contradict its meaningful name as you do to parent before recurring on left, rather pass the appropriate value: preorderTraversal(bTree.left(focusNode), v, focusNode); .
Where you proceed differently in different parts of a conditional statement without undisputable and blatantly obvious reason , put a comment: why are you passing parent when recurring on right?
(One up for quoting the method comments. Consider upgrading them to javadoc .)