public static <T, E extends Comparable<E>> List<T> getNonOverlapping( List<? extends T> items, Function<? super T,Interval<E>> toIntervalFunc) { List<T> nonOverlapping = new ArrayList<>(); IntervalTree<E,Interval<E>> intervals = new IntervalTree<>(); for (T item:items) { Interval<E> i = toIntervalFunc.apply(item); boolean addOk = intervals.addNonOverlapping(i); if (addOk) { nonOverlapping.add(item); } } return nonOverlapping; }
public List<PhraseMatch> findNonOverlappingPhrases(List<PhraseMatch> phraseMatches) { if (phraseMatches.size() > 1) { return IntervalTree.getNonOverlapping(phraseMatches, PHRASEMATCH_LENGTH_ENDPOINTS_COMPARATOR); } else { return phraseMatches; } }
public boolean addNonNested(T target) { if (containsInterval(target, false)) return false; add(target); return true; }
TreeNode<E,T> rightmost = getRightmostNode(node); rightmost.right = origRight; if (rightmost.right != null) { rightmost.right.parent = rightmost; adjustUpwards(rightmost.right,node); return false; boolean res = remove(node.left, target); if (res) { node.maxEnd = Interval.max(node.maxEnd, node.left.maxEnd); return false; boolean res = remove(node.right, target); if (res) { node.maxEnd = Interval.max(node.maxEnd, node.right.maxEnd);
public static <E extends Comparable<E>, T extends HasInterval<E>> List<T> getOverlapping(TreeNode<E,T> n, E p) { List<T> overlapping = new ArrayList<>(); getOverlapping(n, p, overlapping); return overlapping; }
public static <T, E extends Comparable<E>> List<T> getNonNested( List<? extends T> items, Function<? super T,Interval<E>> toIntervalFunc, Comparator<? super T> compareFunc) { List<T> sorted = new ArrayList<>(items); Collections.sort(sorted, compareFunc); List<T> res = new ArrayList<>(); IntervalTree<E,Interval<E>> intervals = new IntervalTree<>(); for (T item:sorted) { Interval<E> i = toIntervalFunc.apply(item); boolean addOk = intervals.addNonNested(i); if (addOk) { res.add(item); } else { // log.info("Discarding " + item); } } return res; }
@Override public boolean remove(Object o) { try { return remove((T) o); } catch (ClassCastException ex) { return false; } }
public static <E extends Comparable<E>, T extends HasInterval<E>> boolean overlaps(TreeNode<E,T> n, E p) { return overlaps(n, Interval.toInterval(p,p)); } public static <E extends Comparable<E>, T extends HasInterval<E>> boolean overlaps(TreeNode<E,T> node, Interval<E> target) {
@Override public boolean add(T target) { return add(root, target, defaultAlpha); }
if (value == null) return false; if (target.equals(value)) { int leftSize = (left != null)? left.size():0; int rightSize = (right != null)? right.size():0; if (leftSize == 0) { if (rightSize == 0) { left = left.left; IntervalTree<E,T> rightmost = getRightmostNode(); rightmost.right = origRight; return false; boolean res = left.remove(target); if (res) { this.maxEnd = Interval.max(maxEnd, left.maxEnd); return false; boolean res = right.remove(target); if (res) { this.maxEnd = Interval.max(maxEnd, right.maxEnd);
public void add(T target) { if (target == null) return; if (value == null) { this.value = target; this.maxEnd = target.getInterval().getEnd(); this.size = 1; } else { this.maxEnd = Interval.max(maxEnd, target.getInterval().getEnd()); this.size++; if (target.getInterval().getBegin().compareTo(value.getInterval().getBegin()) <= 0) { // Should go on left if (left == null) { left = new IntervalTree<E,T>(); } left.add(target); } else { // Should go on right if (right == null) { right = new IntervalTree<E,T>(); } right.add(target); } } }
public TreeNode<E,T> leftRotate(TreeNode<E,T> oldRoot) { if (oldRoot == null || oldRoot.isEmpty() || oldRoot.right == null) return oldRoot; TreeNode<E,T> oldRightLeft = oldRoot.right.left; TreeNode<E,T> newRoot = oldRoot.right; newRoot.left = oldRoot; oldRoot.right = oldRightLeft; // Adjust parents and such newRoot.parent = oldRoot.parent; newRoot.maxEnd = oldRoot.maxEnd; newRoot.size = oldRoot.size; if (newRoot.parent != null) { if (newRoot.parent.left == oldRoot) { newRoot.parent.left = newRoot; } else if (newRoot.parent.right == oldRoot) { newRoot.parent.right = newRoot; } else { throw new IllegalStateException("Old root not a child of it's parent"); } } oldRoot.parent = newRoot; if (oldRightLeft != null) oldRightLeft.parent = oldRoot; adjust(oldRoot); return newRoot; }
public static <E extends Comparable<E>, T extends HasInterval<E>> boolean overlaps(IntervalTree<E,T> n, Interval<E> target) { // Don't search nodes that don't exist if (n == null || n.isEmpty()) return false; // If target is to the right of the rightmost point of any interval // in this node and all children, there won't be any matches. if (target.second.compareTo(n.maxEnd) > 0) return false; // Check this node if (n.value.getInterval().overlaps(target)) { return true; } // If target is to the left of the start of this interval, then search left if (target.second.compareTo(n.value.getInterval().first()) <= 0) { // Search left children if (n.left != null) { return overlaps(n.left, target); } } else { if (n.right != null) { return overlaps(n.right, target); } } return false; }
public IntervalTree<E,T> getRightmostNode() { if (right == null) return this; else { return right.getRightmostNode(); } }
TreeNode<E,T> rightmost = getRightmostNode(node); rightmost.right = origRight; if (rightmost.right != null) { rightmost.right.parent = rightmost; adjustUpwards(rightmost.right,node); return false; boolean res = remove(node.left, target); if (res) { node.maxEnd = Interval.max(node.maxEnd, node.left.maxEnd); return false; boolean res = remove(node.right, target); if (res) { node.maxEnd = Interval.max(node.maxEnd, node.right.maxEnd);
public static <E extends Comparable<E>, T extends HasInterval<E>> List<T> getOverlapping(TreeNode<E,T> n, Interval<E> target) { List<T> overlapping = new ArrayList<>(); getOverlapping(n, target, overlapping); return overlapping; }
public boolean addNonNested(T target) { if (containsInterval(target, false)) return false; add(target); return true; }
public static <T, E extends Comparable<E>> List<T> getNonNested( List<? extends T> items, Function<? super T,Interval<E>> toIntervalFunc, Comparator<? super T> compareFunc) { List<T> sorted = new ArrayList<>(items); Collections.sort(sorted, compareFunc); List<T> res = new ArrayList<>(); IntervalTree<E,Interval<E>> intervals = new IntervalTree<>(); for (T item:sorted) { Interval<E> i = toIntervalFunc.apply(item); boolean addOk = intervals.addNonNested(i); if (addOk) { res.add(item); } else { // log.info("Discarding " + item); } } return res; }
@Override public boolean removeAll(Collection<?> c) { boolean modified = false; for (Object t:c) { if (remove(t)) { modified = true; } } return modified; }