public int compareTo(T child, T otherChild) { if (max) { return child.compareTo(otherChild); } else { return -1 * (child.compareTo(otherChild)); } }
/** * Partition the table so that values from first to pivIndex are less than or equal to the pivot * value, and values from pivIndex to last are greater than the pivot value. * * @param table The table to be partitioned * @param first The index of the low bound * @param last The index of the high bound * @return The location of the pivot value */ @Override protected <T extends Comparable<T>> int partition(T[] table, int first, int last) { // Select the first item as the pivot value. T pivot = table[first]; int up = first; int down = last; do { /* Invariant: All items in table[first . . . up - 1] <= pivot All items in table[down + 1 . . . last] > pivot */ while ((up < last) && (pivot.compareTo(table[up]) >= 0)) { up++; } // assert: up equals last or table[up] > pivot. while (pivot.compareTo(table[down]) < 0) { down--; } // assert: down equals first or table[down] <= pivot. if (up < down) { // if up is to the left of down. // Exchange table[up] and table[down]. swap(table, up, down); } } while (up < down); // Repeat while up is left of down. // Exchange table[first] and table[down] thus putting the // pivot value where it belongs. swap(table, first, down); // Return the index of the pivot value. return down; }
protected AVLNode<T> insert(T data, AVLNode<T> t) throws Exception { if (t == null) t = new AVLNode<T>(data); else if (data.compareTo(t.data) < 0) { t.left = insert(data, t.left); if (height(t.left) - height(t.right) == 2) { if (data.compareTo(t.left.data) < 0) { t = rotateWithLeftChild(t); countSingleRotations++; } else { t = doubleRotateWithleftChild(t); countDoubleRotations++; } } } else if (data.compareTo(t.data) > 0) { t.right = insert(data, t.right); if (height(t.right) - height(t.left) == 2) { if (data.compareTo(t.right.data) > 0) { t = rotateWithRightChild(t); countSingleRotations++; } else { t = doubleRotateWithRightChild(t); countDoubleRotations++; } } } else { throw new Exception("Attempting to insert to duplicate value"); } t.height = max(height(t.left), height(t.right)) + 1; return t; }
public T eliminar(T elemento) { NodoLista<T> actual = primero; if (elemento == null || longitud == 0) { return null; } else if (elemento.compareTo(actual.darElemento()) == 0) { primero = actual.darSiguiente(); if (primero != null) { primero.cambiarAnterior(null); } longitud--; return elemento; } else { actual = actual.darSiguiente(); while (actual != null) { if (elemento.compareTo(actual.darElemento()) == 0) { NodoLista<T> anterior = actual.darAnterior(); NodoLista<T> siguiente = actual.darSiguiente(); anterior.cambiarSiguiente(siguiente); if (siguiente != null) { siguiente.cambiarAnterior(anterior); } longitud--; return elemento; } else { actual = actual.darSiguiente(); } } } return null; }
protected void verifyTransitiveComparison(T x, T y, T z) { assertNotNull(x); assertNotNull(y); assertNotNull(z); int x_y = x.compareTo(y); int y_z = y.compareTo(z); int x_z = x.compareTo(z); checkForMinMaxInt(x_y); checkForMinMaxInt(y_z); checkForMinMaxInt(x_z); if ((x_y > 0) && (y_z > 0)) { assertTrue(x_z > 0); } else if ((x_y < 0) && (y_z < 0)) { assertTrue(x_z < 0); } else { String msg = "Comparison of " + x.toString() + ", " + y.toString() + " and " + z.toString() + " is NOT Transitive. " + "Y must be 'between' X and Z."; assertTrue(msg, false); } }
// recursive support method for above private BSTNode delete(T item, BSTNode current) { // if current is null, nothing new to return if (current != null) { // if item is smaller, go left if (item.compareTo(current.element) < 0) { current.left = delete(item, current.left); } // if item is larger, go right else if (item.compareTo(current.element) > 0) { current.right = delete(item, current.right); } else { // get smallest of right subtree, then delete this node if (current.left != null && current.right != null) { current.element = findMinimum(current.right); current.right = delete(current.element, current.right); } // if only left child, replace with this else if (current.left != null && current.right == null) { current = current.left; } // if only right child, replace with this else if (current.left == null && current.right != null) { current = current.right; } else { // if no children, delete node by setting to null current = null; } } } return current; }
static <T extends Comparable<? super T>> void intersection(List<T> a, List<T> b, List<T> out) { ListIterator<T> aIterator = a.listIterator(); ListIterator<T> bIterator = b.listIterator(); ListIterator<T> outIterator = out.listIterator(); // out=new LinkedList<T>(); try { T aTemp = next(aIterator); T bTemp = next(bIterator); while (aTemp != null && bTemp != null) { if (aTemp.compareTo(bTemp) == 0) { // out.add(aTemp); outIterator.add(aTemp); aTemp = next(aIterator); bTemp = next(bIterator); } else if (aTemp.compareTo(bTemp) < 0) { aTemp = next(aIterator); } else { bTemp = next(bIterator); } } } catch (NullPointerException ex) { System.out.println("The input array(s) is/are empty. Please check!!"); } }
protected void verifyComparableToVsEquals(T o1, T o2) { assertNotNull(o1); assertNotNull(o2); assertTrue((o1.compareTo(o2) == 0) == (o1.equals(o2))); assertTrue((o2.compareTo(o1) == 0) == (o2.equals(o1))); assertTrue((o1.compareTo(o2) == 0) == (o2.compareTo(o1) == 0)); }
public int compareTo(Pair<T> pair) { int rv = first.compareTo(pair.first); if (rv == 0) { rv = second.compareTo(pair.second); } return rv; }
private AANode<T> remove(T element, AANode<T> node) { if (node == null) { return node; } else if (element.compareTo(node.getValue()) > 0) { node.setRight(remove(element, node.getRight())); } else if (element.compareTo(node.getValue()) < 0) { node.setLeft(remove(element, node.getLeft())); } else { if (node.getLevel() == 1) { return null; } else if (node.getLeft() == null) { AANode<T> left = getSuccessor(node); node.setRight(remove(left.getValue(), node.getRight())); node.setValue(left.getValue()); } else { AANode<T> left = getPredecessor(node); node.setLeft(remove(left.getValue(), node.getLeft())); node.setValue(left.getValue()); } } node = decreaseLevel(node); node = skew(node); node.setRight(skew(node.getRight())); if (node.getRight() != null) { node.getRight().setRight(skew(node.getRight().getRight())); } node = split(node); node.setRight(split(node).getRight()); return node; }
@Override public boolean offer(T data) { boolean offered = false; if (root == null) { root = new Node<T>(data); offered = true; } else if (data.compareTo(root.getValue()) == -1) { if (root.getLeft() == null) { root.setLeft(new Node<T>(data)); offered = true; } else { offered = offer(data, root.getLeft(), root); } } else if (data.compareTo(root.getValue()) == 1) { if (root.getRight() == null) { root.setRight(new Node<T>(data)); offered = true; } else { offered = offer(data, root.getRight(), root); } } balance(root, null); if (offered) { numValues++; } return offered; }
/** * 比較する * * @param o1 * @param o2 * @param order * @return */ private <T extends Comparable<? super T>> int compareTo(T o1, T o2, boolean order) { if (this.order) { return o1.compareTo(o2); } else { return o2.compareTo(o1); } }
public <T extends Number & Comparable<T>> NumberField(T min, T max, T value, NumberFormatter f) { super(f); formatter = f; f.setMinimum(min); f.setMaximum(max); if (value != null) setValue(value.compareTo(min) < 0 ? min : value.compareTo(max) > 0 ? max : value); }
private T find(T x, ThreadedBinaryNode<T> t) throws ItemNotFound { if (x.compareTo(t.element) < 0) if (t.isLeftThread) throw new ItemNotFound("Item " + x + " not found"); else return find(x, t.left); else if (x.compareTo(t.element) > 0) if (t.isRightThread) throw new ItemNotFound("Item " + x + " not found"); else return find(x, t.right); else return t.element; }
public static <T extends Comparable<? super T>> void assertSorted(Iterator<T> i) { if (!i.hasNext()) return; T last = i.next(); while (i.hasNext()) { T t = i.next(); assertTrue(last.compareTo(t) <= 0); assertTrue(t.compareTo(last) >= 0); last = t; } }
public static <T extends Comparable<T>> T maximum(T x, T y, T z) { T max = x; // assume x is initially the largest if (y.compareTo(max) > 0) { max = y; // y is the largest so far } if (z.compareTo(max) > 0) { max = z; // z is the largest now } return max; // returns the largest object }
/** * Gets the minimum and maximum of an array of objects of type T. * * @param a an array of objects of type T * @return a pair with the min and max value, or null if a is null or empty */ public static <T extends Comparable> Pair<T> minmax(T[] a) { if (a == null || a.length == 0) return null; T min = a[0]; T max = a[0]; for (int i = 1; i < a.length; i++) { if (min.compareTo(a[i]) > 0) min = a[i]; if (max.compareTo(a[i]) < 0) max = a[i]; } return new Pair<T>(min, max); }
/** * Clamps {@code value} to this range. * * <p>If the value is within this range, it is returned. Otherwise, if it is {@code <} than the * lower endpoint, the lower endpoint is returned, else the upper endpoint is returned. * Comparisons are performed using the {@link Comparable} interface. * * @param value a non-{@code null} {@code T} reference * @return {@code value} clamped to this range. */ public T clamp(T value) { checkNotNull(value, "value must not be null"); if (value.compareTo(mLower) < 0) { return mLower; } else if (value.compareTo(mUpper) > 0) { return mUpper; } else { return value; } }
private T findRec(Node<T> node, T key) { if (node == null) { return null; } else if (key.compareTo(node.key) == 0) { return node.key; } else if (key.compareTo(node.key) < 0) { return findRec(node.left, key); } else { return findRec(node.right, key); } }
private static <T extends Comparable<T>> T max( T a, T b, T c) { // Burada generic metodumuz Comparable sınıfından miras alacağını belirttik T ise // dönüş tipidir.. T büyük = a; if (b.compareTo(a) > 0) büyük = b; if (c.compareTo(büyük) > 0) büyük = c; return büyük; }
private boolean recContains(T element, BSTNode<T> tree) // Returns true if tree contains an element e such that // e.compareTo(element) == 0; otherwise, returns false. { if (tree == null) return false; // element is not found else if (element.compareTo(tree.getInfo()) < 0) return recContains(element, tree.getLeft()); // Search left subtree else if (element.compareTo(tree.getInfo()) > 0) return recContains(element, tree.getRight()); // Search right subtree else return true; // element is found }
private boolean toSearch(Node<T> p, T data) { if (p == null) { return false; } if (data.compareTo(p.data) == 0) { return true; } if (data.compareTo(p.data) > 0) { return toSearch(p.right, data); } else return toSearch(p.left, data); }
private T recGet(T element, BSTNode<T> tree) // Returns an element e from tree such that e.compareTo(element) == 0; // if no such element exists, returns null. { if (tree == null) return null; // element is not found else if (element.compareTo(tree.getInfo()) < 0) return recGet(element, tree.getLeft()); // get from left subtree else if (element.compareTo(tree.getInfo()) > 0) return recGet(element, tree.getRight()); // get from right subtree else return tree.getInfo(); // element is found }
public boolean contains(T value) { if (value.compareTo(data) == 0) { return true; } else if (value.compareTo(data) > 0 && left != null) { return left.contains(value); } else if (value.compareTo(data) < 0 && right != null) { return right.contains(value); } else { return false; } }
private Node<T> toInsert(Node<T> p, T data) { if (p == null) { return new Node<T>(data); } if (data.compareTo(p.data) == 0) { return p; } if (data.compareTo(p.data) > 0) { p.right = toInsert(p.right, data); } else p.left = toInsert(p.left, data); return p; }
private BSTNode<T> recRemove(T element, BSTNode<T> tree) { if (tree == null) found = false; else if (element.compareTo(tree.getInfo()) < 0) tree.setLeft(recRemove(element, tree.getLeft())); else if (element.compareTo(tree.getInfo()) > 0) tree.setRight(recRemove(element, tree.getRight())); else { tree = removeNode(tree); found = true; } return tree; }
void insert(T x, ThreadedBinaryNode<T> t) throws DuplicateItem { if (x.compareTo(t.element) < 0) if (t.isLeftThread) { t.left = new ThreadedBinaryNode(x, t.left, t); t.isLeftThread = false; } else insert(x, t.left); else if (x.compareTo(t.element) > 0) if (t.isRightThread) { t.right = new ThreadedBinaryNode(x, t, t.right); t.isRightThread = false; } else insert(x, t.right); else throw new DuplicateItem("attempt to insert duplicateitem"); }
static <T extends Comparable<? super T>> void union(List<T> a, List<T> b, List<T> out) { ListIterator<T> aIterator = a.listIterator(); ListIterator<T> bIterator = b.listIterator(); int aIndex = 0; int bIndex = 0; try { T aTemp = aIterator.next(); T bTemp = bIterator.next(); while (aIndex + 1 <= a.size() && bIndex + 1 <= b.size()) { { if (aTemp.compareTo(bTemp) == 0) { out.add(aTemp); aIndex++; bIndex++; if (aIterator.hasNext()) aTemp = aIterator.next(); if (bIterator.hasNext()) bTemp = bIterator.next(); } else if (aTemp.compareTo(bTemp) < 0) { aIndex++; out.add(aTemp); if (aIterator.hasNext()) aTemp = aIterator.next(); } else { bIndex++; out.add(bTemp); if (bIterator.hasNext()) bTemp = bIterator.next(); } } if (a.size() >= aIndex + 1 && bIndex + 1 > b.size()) { out.add(aTemp); aIndex++; while (aIterator.hasNext()) { aTemp = aIterator.next(); out.add(aTemp); } } else if (b.size() >= bIndex + 1 && aIndex + 1 > a.size()) { bIndex++; out.add(bTemp); while (bIterator.hasNext()) { bTemp = bIterator.next(); out.add(bTemp); } } } } catch (NoSuchElementException ex) { System.out.println("The input array(s) is/are empty. Please check!!"); ex.printStackTrace(); } }
public AVLNode<T> remove(T x, AVLNode<T> t) { if (t == null) { System.out.println("Sorry but you're mistaken, " + t + " doesn't exist in this tree :)\n"); return null; } System.out.println("Remove starts... " + t.data + " and " + x); if (x.compareTo(t.data) < 0) { t.left = remove(x, t.left); int le = t.left != null ? t.left.height : 0; if ((t.right != null) && (t.right.height - le >= 2)) { int rightHeight = t.right.right != null ? t.right.right.height : 0; int leftHeight = t.right.left != null ? t.right.left.height : 0; if (rightHeight >= leftHeight) t = rotateWithLeftChild(t); else t = doubleRotateWithRightChild(t); } } else if (x.compareTo(t.data) > 0) { t.right = remove(x, t.right); int ri = t.right != null ? t.right.height : 0; if ((t.left != null) && (t.left.height - ri >= 2)) { int leftHeight = t.left.left != null ? t.left.left.height : 0; int rightHeight = t.left.right != null ? t.left.right.height : 0; if (leftHeight >= rightHeight) t = rotateWithRightChild(t); else t = doubleRotateWithleftChild(t); } } else if (t.left != null) { t.data = findMax(t.left).data; remove(t.data, t.left); if ((t.right != null) && (t.right.height - t.left.height >= 2)) { int rightHeight = t.right.right != null ? t.right.right.height : 0; int leftHeight = t.right.left != null ? t.right.left.height : 0; if (rightHeight >= leftHeight) t = rotateWithLeftChild(t); else t = doubleRotateWithRightChild(t); } } else { t = (t.left != null) ? t.left : t.right; } if (t != null) { int leftHeight = (t.left != null) ? t.left.height : 0; int rightHeight = (t.right != null) ? t.right.height : 0; t.height = max(leftHeight, rightHeight) + 1; } return t; }
private T find(T key) { Node<T> current = root; while (current != null) { if (key.compareTo(current.key) < 0) { current = current.left; } else if (key.compareTo(current.key) > 0) { current = current.right; } else { return current.key; } } return null; }