/**
* Clip nodes height above limit.
*
* @param tree to clip
* @param limit height limit
*/
private void limitNodes(MutableTree tree, double limit) {
for (int i = 0; i < tree.getInternalNodeCount(); i++) {
final NodeRef n = tree.getInternalNode(i);
if (tree.getNodeHeight(n) > limit) {
tree.setNodeHeight(n, limit);
}
}
MutableTree.Utils.correctHeightsForTips(tree);
}
/*
1
├──── 2
│ ├──── 3
│ │ ├──── 4
│ │ └──── 5
│ └───── 6
├──── 7
├──── 8
│ ├──── 9
│ └──── 10
└──── 11
└──── 12
└──── 13
└──── 14
*/
@Nonnull
static MutableTree<Integer> createMockTree() {
final MutableTree<Integer> result = Trees.newLinkedTree(1);
MutableTreeNode<Integer> root = result.getRoot();
MutableTreeNode<Integer> child2 = root.addChild(2);
MutableTreeNode<Integer> child3 = child2.addChild(3);
child3.addChild(4);
child3.addChild(5);
child2.addChild(6);
root.addChild(7);
MutableTreeNode<Integer> child8 = root.addChild(8);
child8.addChild(9);
child8.addChild(10);
root.addChild(11).addChild(12).addChild(13).addChild(14);
return result;
}
public void attemptToScaleTree(MutableTree tree, double rootHeight) {
// avoid empty tree
if (tree.getRoot() == null) return;
double scale = rootHeight / tree.getNodeHeight(tree.getRoot());
for (int i = 0; i < tree.getInternalNodeCount(); i++) {
NodeRef n = tree.getInternalNode(i);
tree.setNodeHeight(n, tree.getNodeHeight(n) * scale);
}
MutableTree.Utils.correctHeightsForTips(tree);
}
@Test
public void testRemoveNodeIf() throws Exception {
// remove all even elements
MutableTree<Integer> tree = createMockTree();
tree.removeNodeIf(
new JPredicate<TreeNode<Integer>>() {
@Override
public boolean apply(@Nullable TreeNode<Integer> input) {
return input.getValue() % 2 == 0;
}
});
Assert.assertEquals(3, tree.getSize());
for (TreeNode<Integer> node : tree) {
Assert.assertTrue(node.getValue() % 2 != 0);
}
// remove all elements
tree = createMockTree();
tree.removeNodeIf(
new JPredicate<TreeNode<Integer>>() {
@Override
public boolean apply(@Nullable TreeNode<Integer> input) {
return true;
}
});
Assert.assertEquals(1, tree.getSize());
// remove all odd elements
tree = createMockTree();
tree.removeNodeIf(
new JPredicate<TreeNode<Integer>>() {
@Override
public boolean apply(@Nullable TreeNode<Integer> input) {
return input.getValue() % 2 != 0;
}
});
Assert.assertEquals(5, tree.getSize());
for (TreeNode<Integer> node : tree) {
if (node != tree.getRoot()) {
Assert.assertTrue(node.getValue() % 2 == 0);
}
}
}
public MutableTree sortedDelete(MutableTree root, int deleteVal) {
if (root == null) return null;
if (root.getValue() == deleteVal) { // wurzel soll geloescht werden
if (root.getLeft() == null && root.getRight() == null) { // nur root
// leeren baum zurueckgeben
return null;
} // else { //wurzel hat kinder
// root = root.copy(); //ab hier brauchen wir eine kopie
if (root.getRight() != null) { // rechter teilbaum vorhanden.
MutableTree rightMin = (MutableTree) root.getRight().getMin();
// root.value = rightMin.value; //kleinstes Element in die Wurzel kopieren
// root.right = sortedDelete(root.right, rightMin.value); //und aus rechtem teilbaum
// loeschen
MutableTree newRoot = new DavidMutableTree(rightMin.getValue());
newRoot.setLeft(root.getLeft());
newRoot.setRight(sortedDelete(root.getRight(), rightMin.getValue()));
return newRoot;
} // else { //kein rechter teilbaum
// root = root.left; //loeschen "wie in liste"
return root.getLeft();
// }
// der sonderfall (right != null && left==null) wird nicht betrachtet
// so spaart man sich ein paar vergleiche, einigen dublicate code
// mit einem kleinen risiko etwas mehraufwand zu betreiben
// }
} // else { //wurzel wird nicht geloescht
MutableTree newRoot = new DavidMutableTree(root.getValue()); // kopie anlegen
if (deleteVal < root.getValue()) { // element zum loeschen ist links
newRoot.setLeft(sortedDelete(root.getLeft(), deleteVal)); // element links loeschen
newRoot.setRight(root.getRight()); // rechts bleibt unveraendert
return newRoot;
} // else { //analog mit rechts
newRoot.setRight(sortedDelete(root.getRight(), deleteVal));
newRoot.setLeft(root.getLeft());
return newRoot;
// }
// root = newRoot; //alte referenz mit neuem baum ueberschreiben
// }
// no return here, to ensure no altered tree is returned
// return root; //root, den "neuen baum", zurueckgeben.
}
