/** * Internal method to remove from a subtree. * * @param x the item to remove. * @param t the node that roots the tree. * @return the new root. * @throws ItemNotFoundException if x is not found. */ protected BinaryNode<AnyType> remove(AnyType x, BinaryNode<AnyType> t) { if (t == null) throw new ItemNotFoundException(x.toString()); if (x.compareTo(t.element) < 0) t.left = remove(x, t.left); else if (x.compareTo(t.element) > 0) t.right = remove(x, t.right); else if (t.left != null && t.right != null) // Two children { t.element = findMin(t.right).element; t.right = removeMin(t.right); } else t = (t.left != null) ? t.left : t.right; return t; }
/** * Internal method to insert into a subtree. * * @param x the item to insert. * @param t the node that roots the tree. * @return the new root. * @throws DuplicateItemException if x is already present. */ protected BinaryNode<AnyType> insert(AnyType x, BinaryNode<AnyType> t) { if (t == null) t = new BinaryNode<AnyType>(x); else if (x.compareTo(t.element) < 0) t.left = insert(x, t.left); else if (x.compareTo(t.element) > 0) t.right = insert(x, t.right); else throw new DuplicateItemException(x.toString()); // Duplicate return t; }
/** * Recursive helper method to remove a value from the tree * * @param x the value to be removed * @param t the node to remove value from * @return the node with removed value */ protected BinaryNode<Integer> remove(Integer x, BinaryNode<Integer> t) { if (t == null) { return t; } int compareResult = x.compareTo(t.element); if (compareResult < 0) { t.left = remove(x, t.left); } else if (compareResult > 0) { t.right = remove(x, t.right); } else if (t.left != null && t.right != null) { t.element = findMin(t.right).element; t.right = remove(t.element, t.right); } else { t = (t.left != null) ? t.left : t.right; } return t; }
/** * Return a reference to a node that is the root of a duplicate of the binary tree rooted at the * current node. */ public BinaryNode<AnyType> duplicate() { BinaryNode<AnyType> root = new BinaryNode<AnyType>(element, null, null); if (left != null) // If there's a left subtree root.left = left.duplicate(); // Duplicate; attach if (right != null) // If there's a right subtree root.right = right.duplicate(); // Duplicate; attach return root; // Return resulting tree }
private BinaryNode singleRightRotation() { BinaryNode temp = this.left; if (temp != null) { this.left = temp.right; } temp.right = this; rotationCount++; return temp; }
public BinaryNode add(BinaryNode current, int data) { if (current == null) { current = new BinaryNode(data); } else { if (data >= (Integer) current.data) current.right = add(current.right, data); else current.left = add(current.left, data); } return current; }
/** * Internal method to insert into a subtree. * * @param x the item to insert. * @param t the node that roots the tree. * @return the new root. * @throws DuplicateItemException if x is already present. */ protected BinaryNode<AnyType> insert(AnyType x, BinaryNode<AnyType> t) { if (t == null) t = new BinaryNode<AnyType>(x); else if (x.compareTo(t.element) < 0) t.left = insert(x, t.left); else if (x.compareTo(t.element) > 0) t.right = insert(x, t.right); else { t.increaseDuplicateCount(); t.hasDuplicate = true; t.duplicate = duplicate(x, t.duplicate); } return t; }
/** * Recursive helper method to insert a value in the tree * * @param x the value to be inserted * @param t the node to insert value in * @return the node with the inserted value */ protected BinaryNode<Integer> insert(Integer x, BinaryNode<Integer> t) { if (t == null) { return new BinaryNode<Integer>(x, null, null); } int compareResults = x.compareTo((Integer) t.element); if (compareResults < 0) { t.left = insert(x, t.left); } else if (compareResults > 0) { t.right = insert(x, t.right); } return t; }
public BinaryNode toTree(BinaryNode root, int[] array, int length, int counter) { if (counter == length) { counter = 0; return null; } else { BinaryNode node = new BinaryNode(array[counter]); if (array[counter] <= (Integer) root.data) { root.right = node; counter++; toTree(root.right, array, length, counter); } else { root.left = node; counter++; toTree(root.left, array, length, counter); } } return root; }
static BinaryNode WithRightChild(BinaryNode k1) { BinaryNode k2 = k1.right; k1.right = k2.left; k2.left = k1; return k2; }
static BinaryNode doubleWithRightChild(BinaryNode k1) { k1.right = WithLeftChild(k1.right); return WithRightChild(k1); }
static BinaryNode WithLeftChild(BinaryNode k2) { BinaryNode k1 = k2.left; k2.left = k1.right; k1.right = k2; return k1; }
public void InsertRight(BinaryNode current, BinaryNode insert) { insert.right = current.right; insert.left = current; current.right = insert; }