Пример #1
0
  /**
   * @param parent: The parent of the element to be removed
   * @param remove: The element to remove from the Tree
   * @param direction: false if remove is to the left of parent, true otherwise
   *     <p>This method physically removes the AVLNode with the element from the AVLTree, replacing
   *     it with the appropriate successor. *
   */
  private void enactRemoval(AVLNode<E> parent, AVLNode<E> remove, boolean direction) {
    AVLNode<E> temp = null;
    AVLNode<E> left = remove.getLeft();
    AVLNode<E> right = remove.getRight();

    // if the Node to remove is not a leaf, find the appropriate successor
    if (left != null || right != null) {
      temp = findSuccessor(remove);
    }

    // if remove is the right child of parent, update parent's right node
    if (direction && (parent != rootAbove)) {
      parent.setRightNode(temp);
    }

    // otherwise, update its left node with the successor
    else parent.setLeftNode(temp);

    // and update temp to point to remove's children
    if (temp != null) {

      if (temp != left) {
        temp.setLeftNode(remove.getLeft());
      }

      if (temp != right) {
        temp.setRightNode(remove.getRight());
      }
    }

    // and finally, discard those references from remove
    // so that the removed Node is garbage collected sooner
    remove.setLeftNode(null);
    remove.setRightNode(null);
  }
Пример #2
0
  /**
   * @param root: The element for which to find a successor AVLNode
   * @return AVLNode<E>: The successor Node *
   */
  private AVLNode<E> findSuccessor(AVLNode<E> root) {
    AVLNode<E> temp = root;
    AVLNode<E> parent = null;

    // if the balance favors the right, traverse right
    // otherwise, traverse left
    boolean direction = (temp.getBalance() > 0);

    parent = temp;
    temp = (direction) ? temp.getRight() : temp.getLeft();

    if (temp == null) return temp;

    // and find the farthest left-Node on the right side,
    // or the farthest right-Node on the left side
    while ((temp.getRight() != null && !direction) || (temp.getLeft() != null && direction)) {

      parent = temp;
      temp = (direction) ? temp.getLeft() : temp.getRight();
    }

    // finally, update the successor's parent's references
    // to adjust for a left child on the right node, or a right
    // child on the left-node
    if (temp == parent.getLeft()) {
      parent.setLeftNode(temp.getRight());
      temp.setRightNode(null);
    } else {
      parent.setRightNode(temp.getLeft());
      temp.setLeftNode(null);
    }

    return temp;
  }
Пример #3
0
  /**
   * @param rotateBase: The root of the subtree that is being rotated
   * @param rootAbove: The AVLNode that points to rotateBase
   *     <p>This method rotates the subtree balancing it to within a margin of |1|.
   */
  public void rotate(AVLNode<E> rotateBase, AVLNode<E> rootAbove) {
    int balance = rotateBase.getBalance();

    if (Math.abs(balance) < 2) {
      // System.out.println("No rotate");
    }

    // gets the child on the side with the greater height
    AVLNode<E> child = (balance < 0) ? rotateBase.getLeft() : rotateBase.getRight();

    if (child == null) return;

    int childBalance = child.getBalance();
    AVLNode<E> grandChild = null;

    // both the child and grandchild are on the
    // left side, so rotate the child up to the root position
    if (balance < -1 && childBalance < 0) {
      if (rootAbove != this.rootAbove && rootAbove.getRight() == rotateBase) {
        rootAbove.setRightNode(child);
      } else {
        rootAbove.setLeftNode(child);
      }

      grandChild = child.getRight();
      child.setRightNode(rotateBase);
      rotateBase.setLeftNode(grandChild);
      return;
    }

    // both the child and the grandchild are on the
    // right side, so rotate the child up to the root position
    else if (balance > 1 && childBalance > 0) {
      if (rootAbove != this.rootAbove && rootAbove.getRight() == rotateBase) {
        rootAbove.setRightNode(child);
      } else {
        rootAbove.setLeftNode(child);
      }

      grandChild = child.getLeft();
      child.setLeftNode(rotateBase);
      rotateBase.setRightNode(grandChild);
      return;
    }

    // the child is on the left side, but the grandchild is on the
    // right side, so rotate the grandchild up to the child position
    // so the condition of the first if statement is satisfied,
    // then recurse to have the first if statement evaluated
    else if (balance < -1 && childBalance > 0) {
      grandChild = child.getRight();
      rotateBase.setLeftNode(grandChild);
      child.setRightNode(grandChild.getLeft());
      grandChild.setLeftNode(child);
      rotate(rotateBase, rootAbove);
      return;
    }

    // the child is on the right side, but the grandchild is on the
    // left side, so rotate the grandchild up to the child position
    // so the condition of the second if statement is satisfied,
    // then recurse to have the second if statement evaluated
    else if (balance > 1 && childBalance < 0) {
      grandChild = child.getLeft();
      rotateBase.setRightNode(grandChild);
      child.setLeftNode(grandChild.getRight());
      grandChild.setRightNode(child);
      rotate(rotateBase, rootAbove);
      return;
    }
  }