Java Tree.numChildren方法代码示例

import edu.stanford.nlp.trees.Tree; //导入方法依赖的package包/类
public static Tree removeEmptyNodes(Tree tree)
    {
        Tree[] children = tree.children();
        for (int i = 0; i < children.length; i++)
        {
            Tree child = children[i];
            // heuristic: all leaf nodes have a special anchor symbol '<>' in the end.
            // If we don't find this, then we should remove the node.
            if (child.numChildren() == 0 && !child.label().value().contains("<>"))
            {
//                System.out.println("node " + child);                
                tree.removeChild(i);
            } else
            {
                removeEmptyNodes(child);
            }
        }
        return tree;
    }
 

import edu.stanford.nlp.trees.Tree; //导入方法依赖的package包/类
public static Tree getMinimalConnectedStructure(Tree tree, Tree firstLeaf, Tree lastLeaf, int lastLeafIndex)
{
    // find common ancestor node by traversing the tree bottom-up from the last leaf and up
    Tree commonAncestorNode = lastLeaf.parent(tree);
    while(!commonAncestorNode.getLeaves().get(0).equals(firstLeaf))
    {
        commonAncestorNode = commonAncestorNode.parent(tree);
    }
    // found the common ancestor, now we need to clone the tree and chop the children non-terminals the span of which is outwith the last leaf
    Tree result = commonAncestorNode.deepCopy();
    List<Tree> leaves = result.getLeaves();
    lastLeaf = leaves.get(lastLeafIndex);
    Tree p = lastLeaf.parent(result);
    Tree d = lastLeaf;
    while(p != null)
    {
        if(p.numChildren() > 1)
        {
            // remove siblings to the right of d
            int index = indexOfChild(p, d.nodeNumber(result), result);
            pruneChildrenAfter(p, index);
        }
        d = p;
        p = p.parent(result);
    }
    return result;
}
 

import edu.stanford.nlp.trees.Tree; //导入方法依赖的package包/类
public static void pruneChildrenAfter(Tree parent, int index)
{
    int numOfChildren = parent.numChildren();
    for(int i = index + 1; i < numOfChildren; i++)
    {
        parent.removeChild(index + 1);
    }
}
 

import edu.stanford.nlp.trees.Tree; //导入方法依赖的package包/类
public static String removeSubtreesAfterWord(String inputTree, int numOfLeaves)
{
    Tree tree = Tree.valueOf(inputTree);
    List<Tree> leaves = tree.getLeaves();
    if(leaves.size() > numOfLeaves)
    {
        // find common ancestor between last valid leaf and extraneous leaf
        Tree firstLeaf = leaves.get(numOfLeaves - 1);
        Tree lastLeaf = leaves.get(leaves.size() - 1);
        Tree commonAncestorNode = lastLeaf.parent(tree);            
        while(!commonAncestorNode.getLeaves().contains(firstLeaf))
        {
            commonAncestorNode = commonAncestorNode.parent(tree);
        }
        // found the common ancestor, now we need to chop the children nodes the span of which is outwith the last valid leaf

        Tree p = lastLeaf.parent(tree);
        while(p != commonAncestorNode)
        {
            int numOfChildren = p.numChildren();
            for(int i = 0; i < numOfChildren; i++)
                p.removeChild(0);     
            p = p.parent(tree);
        }
        // remove last leftover parent node of the invalid leaf
        commonAncestorNode.removeChild(commonAncestorNode.numChildren() - 1);
        return tree.toString();
    }
    else
    {        
        return inputTree;
    }        
    
}
 

import edu.stanford.nlp.trees.Tree; //导入方法依赖的package包/类
/**
 *
 * @param root
 * @param left
 * @param right
 * @param n
 *          is the length of the sentence is tokens.
 * @param p
 * @param tokenizationUUID
 * @return The constituent ID
 * @throws AnalyticException
 */
private static int constructConstituent(Tree root, int left,
    int right, int n, Parse p, UUID tokenizationUUID, HeadFinder hf)
    throws AnalyticException {

  Constituent constituent = new Constituent();
  constituent.setId(p.getConstituentListSize());
  constituent.setTag(root.value());
  constituent.setStart(left);
  constituent.setEnding(right);
  p.addToConstituentList(constituent);
  Tree headTree = null;
  if (!root.isLeaf()) {
    try {
      headTree = hf.determineHead(root);
    } catch (java.lang.IllegalArgumentException iae) {
      LOGGER.warn("Failed to find head, falling back on rightmost constituent.", iae);
      headTree = root.children()[root.numChildren() - 1];
    }
  }
  int i = 0, headTreeIdx = -1;

  int leftPtr = left;
  for (Tree child : root.getChildrenAsList()) {
    int width = child.getLeaves().size();
    int childId = constructConstituent(child, leftPtr, leftPtr
        + width, n, p, tokenizationUUID, hf);
    constituent.addToChildList(childId);

    leftPtr += width;
    if (headTree != null && child == headTree) {
      assert (headTreeIdx < 0);
      headTreeIdx = i;
    }
    i++;
  }

  if (headTreeIdx >= 0)
    constituent.setHeadChildIndex(headTreeIdx);

  if (!constituent.isSetChildList())
    constituent.setChildList(new ArrayList<Integer>());
  return constituent.getId();
}