// 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; }
/* * formacion del arbol */ private void continueRotation(BSTNode gr, BSTNode par, BSTNode ch, BSTNode desc) { if (gr != null) { // if par has a grandparent; if (gr.right == ((SplayTreeNode) ch).parent) gr.right = ch; else gr.left = ch; } else root = ch; if (desc != null) ((SplayTreeNode) desc).parent = par; ((SplayTreeNode) par).parent = ch; ((SplayTreeNode) ch).parent = gr; }
public BSTNode minBST(int[] array, int start, int end) { if (start > end) { return null; } int mid = (start + end) / 2; BSTNode n = new BSTNode(array[mid]); size++; n.left = minBST(array, start, mid - 1); n.right = minBST(array, mid + 1, end); return n; }
public boolean remove(int x) { BSTNode current = root; BSTNode parent = null; boolean branch = true; // true =left, false =right while (current != null) { if (current.value == x) { BSTNode bigson = current; while (bigson.left != null || bigson.right != null) { parent = bigson; if (bigson.right != null) { bigson = bigson.right; branch = false; } else { bigson = bigson.left; branch = true; } } // System.out.println("Remove: current "+current.value+" parent "+parent.value+" bigson // "+bigson.value); if (parent != null) { if (branch) { parent.left = null; } else { parent.right = null; } } if (bigson != current) { current.value = bigson.value; } else {; } return true; } parent = current; // if (current.value <x ) { // THERE WAS ERROR if (current.value > x) { current = current.left; branch = true; } else { current = current.right; branch = false; } } return false; }
// recusive support method for above private BSTNode insert(T item, BSTNode current) { // if current node does not exist, make new node for item if (current == null) { current = new BSTNode(item, null, null); } // if new item is smaller, go to the left else if (item.compareTo(current.element) < 0) { current.left = insert(item, current.left); } // if new item is larger, go to the right else if (item.compareTo(current.element) > 0) { current.right = insert(item, current.right); } // otherwise we have duplicate and throw exception else { throw new MyException("Duplicate item"); } return current; }
public void add(int x) { BSTNode current = root; if (root == null) { root = new BSTNode(x); return; } while (current.value != x) { if (x < current.value) { if (current.left == null) { current.left = new BSTNode(x); } else { current = current.left; } } else { if (current.right == null) { current.right = new BSTNode(x); } else { current = current.right; } } } }