Example #1
0
 private void rotateRight(Node<K, V> root) {
   int i;
   int i2 = 0;
   Node<K, V> pivot = root.left;
   Node<K, V> right = root.right;
   Node<K, V> pivotLeft = pivot.left;
   Node<K, V> pivotRight = pivot.right;
   root.left = pivotRight;
   if (pivotRight != null) {
     pivotRight.parent = root;
   }
   replaceInParent(root, pivot);
   pivot.right = root;
   root.parent = pivot;
   if (right != null) {
     i = right.height;
   } else {
     i = 0;
   }
   root.height = Math.max(i, pivotRight != null ? pivotRight.height : 0) + 1;
   int i3 = root.height;
   if (pivotLeft != null) {
     i2 = pivotLeft.height;
   }
   pivot.height = Math.max(i3, i2) + 1;
 }
Example #2
0
 private void rebalance(Node<K, V> unbalanced, boolean insert) {
   for (Node<K, V> node = unbalanced; node != null; node = node.parent) {
     Node<K, V> left = node.left;
     Node<K, V> right = node.right;
     int leftHeight = left != null ? left.height : 0;
     int rightHeight = right != null ? right.height : 0;
     int delta = leftHeight - rightHeight;
     if (delta == -2) {
       Node<K, V> rightLeft = right.left;
       Node<K, V> rightRight = right.right;
       int rightDelta =
           (rightLeft != null ? rightLeft.height : 0)
               - (rightRight != null ? rightRight.height : 0);
       if (rightDelta == -1 || (rightDelta == 0 && !insert)) {
         rotateLeft(node);
       } else if ($assertionsDisabled || rightDelta == 1) {
         rotateRight(right);
         rotateLeft(node);
       } else {
         throw new AssertionError();
       }
       if (insert) {
         return;
       }
     } else if (delta == 2) {
       Node<K, V> leftLeft = left.left;
       Node<K, V> leftRight = left.right;
       int leftDelta =
           (leftLeft != null ? leftLeft.height : 0) - (leftRight != null ? leftRight.height : 0);
       if (leftDelta == 1 || (leftDelta == 0 && !insert)) {
         rotateRight(node);
       } else if ($assertionsDisabled || leftDelta == -1) {
         rotateLeft(left);
         rotateRight(node);
       } else {
         throw new AssertionError();
       }
       if (insert) {
         return;
       }
     } else if (delta == 0) {
       node.height = leftHeight + 1;
       if (insert) {
         return;
       }
     } else if ($assertionsDisabled || delta == -1 || delta == 1) {
       node.height = Math.max(leftHeight, rightHeight) + 1;
       if (!insert) {
         return;
       }
     } else {
       throw new AssertionError();
     }
   }
 }
Example #3
0
  private Node<T, V> insertTree(Node<T, V> subTree, T t, V v) // called by public void insert(T t)
      { // insert to a subtree and return the reference of this subtree
    Node<T, V> ansNode = null;
    if (subTree == null) {
      ansNode = new Node<T, V>(t, v);
      ansNode.leftChild = null;
      ansNode.rightChild = null;
      ansNode.height = 0; // null tree's height is -1
    } else if (comp.compare(t, subTree.t) < 0) // insert to the leftSubTree of subTree
    {
      subTree.leftChild = insertTree(subTree.leftChild, t, v);
      if (getHeight(subTree.leftChild) - getHeight(subTree.rightChild)
          == 2) // subtree is the minimum unbalanced subTree
      {
        // singleLeftRotate or doubleLeftRightRorate
        if (getHeight(subTree.leftChild.leftChild) > getHeight(subTree.leftChild.rightChild)) {
          ansNode = singleLeftRotate(subTree);
        } else {
          ansNode = doubleLeftRightRotate(subTree);
        }
      } else {
        // Only the change of structure of tree causes the change of it's height
        subTree.height =
            1
                + (getHeight(subTree.leftChild) >= getHeight(subTree.rightChild)
                    ? getHeight(subTree.leftChild)
                    : getHeight(subTree.rightChild));
        ansNode = subTree;
      }

    } else if (comp.compare(t, subTree.t) > 0) // insert to the rightSubTree of subTree
    {
      subTree.rightChild = insertTree(subTree.rightChild, t, v);
      if (getHeight(subTree.rightChild) - getHeight(subTree.leftChild)
          == 2) // subtree is the minimum unbalanced subTree
      {
        // singleLeftRotate or doubleLeftRightRorate
        if (getHeight(subTree.rightChild.rightChild) > getHeight(subTree.rightChild.leftChild)) {
          ansNode = singleRightRotate(subTree);
        } else {
          ansNode = doubleRightLeftRotate(subTree);
        }
      } else {
        // Only the change of structure of tree causes the change of it's height
        subTree.height =
            1
                + (getHeight(subTree.leftChild) > getHeight(subTree.rightChild)
                    ? getHeight(subTree.leftChild)
                    : getHeight(subTree.rightChild));
        ansNode = subTree;
      }
    }
    return ansNode;
  }
Example #4
0
 private int height() {
   int h = 1;
   if (left == null && right == null) {
     return h;
   } else if (left == null && right != null) {
     h += right.height();
   } else if (left != null && right == null) {
     h += left.height();
   } else {
     h += Math.max(left.height(), right.height());
   }
   return h;
 }
Example #5
0
 public int leftHeight() {
   if (left == null) {
     return 0;
   } else {
     return left.height();
   }
 }
Example #6
0
 public int rightHeight() {
   if (right == null) {
     return 0;
   } else {
     return right.height();
   }
 }
Example #7
0
 private Node delete(Node x, Key key) {
   if (x == null) return null;
   int comp = key.compareTo(x.key);
   if (comp < 0) x.left = delete(x.left, key);
   else if (comp > 0) x.right = delete(x.right, key);
   else {
     if (x.left == null) {
       if (x.pred != null) x.pred.succ = x.succ;
       if (x.succ != null) x.succ.pred = x.pred;
       return x.right;
     }
     if (x.right == null) {
       if (x.pred != null) x.pred.succ = x.succ;
       if (x.succ != null) x.succ.pred = x.pred;
       return x.left;
     }
     Node t = max(x.left);
     t.left = deleteMaxWithOutDeleteThread(x.left);
     t.right = x.right;
     if (x.pred != null) x.pred.succ = x.succ;
     if (x.succ != null) x.succ.pred = x.pred;
     x = t;
   }
   x.N = size(x.left) + size(x.right) + 1;
   x.height = Math.max(height(x.left), height(x.right)) + 1;
   x.avgCompares =
       (avgCompares(x.left) * size(x.left) + avgCompares(x.right) * size(x.right) + size(x))
           / size(x);
   return x;
 }
Example #8
0
 private Node put(Node x, Key key, Value val) {
   if (x == null) {
     Node pre = floor(root, key);
     Node nex = ceiling(root, key);
     lastest = new Node(key, val, 1, 1, 1);
     if (pre != null) pre.succ = lastest;
     if (nex != null) nex.pred = lastest;
     lastest.succ = nex;
     lastest.pred = pre;
     return lastest;
   }
   int comp = key.compareTo(x.key);
   if (comp < 0) x.left = put(x.left, key, val);
   else if (comp > 0) x.right = put(x.right, key, val);
   else {
     lastest = x;
     x.value = val;
   }
   x.N = size(x.right) + size(x.left) + 1;
   x.height = Math.max(height(x.left), height(x.right)) + 1;
   x.avgCompares =
       (avgCompares(x.left) * size(x.left) + avgCompares(x.right) * size(x.right) + size(x))
           / size(x);
   return x;
 }
Example #9
0
 // OUTER methods here are wrapper methods for the root
 public int getHeight() {
   if (root == null) {
     return 0;
   } else {
     return root.height();
   }
 }
Example #10
0
  /**
   * ********************************* rotation operation
   * ******************************************************
   */
  private Node<T, V> singleLeftRotate(Node<T, V> subTree) {
    // rotate
    Node<T, V> ansNode = subTree.leftChild;
    subTree.leftChild = ansNode.rightChild;
    ansNode.rightChild = subTree;

    // update height of rotated nodes
    // Only the change of structure of tree causes the change of it's height
    subTree.height =
        1
            + (getHeight(subTree.leftChild) >= getHeight(subTree.rightChild)
                ? getHeight(subTree.leftChild)
                : getHeight(subTree.rightChild));

    ansNode.height =
        1
            + (getHeight(ansNode.leftChild) >= getHeight(ansNode.rightChild)
                ? getHeight(ansNode.leftChild)
                : getHeight(ansNode.rightChild));

    return ansNode;
  }
Example #11
0
 private Node deleteMaxWithOutDeleteThread(Node x) {
   if (x == null) return null;
   if (x.right == null) {
     return x.left;
   }
   x.right = deleteMax(x.right);
   x.N = size(x.left) + size(x.right) + 1;
   x.height = Math.max(height(x.left), height(x.right)) + 1;
   x.avgCompares =
       (avgCompares(x.left) * size(x.left) + avgCompares(x.right) * size(x.right) + size(x))
           / size(x);
   return x;
 }
Example #12
0
 private void computeSize(Array<Node> nodes, float indent) {
   float ySpacing = this.ySpacing;
   for (int i = 0, n = nodes.size; i < n; i++) {
     Node node = nodes.get(i);
     float rowWidth = indent + iconSpacing;
     Actor actor = node.actor;
     if (actor instanceof Layout) {
       Layout layout = (Layout) actor;
       rowWidth += layout.getPrefWidth();
       node.height = layout.getPrefHeight();
       layout.pack();
     } else {
       rowWidth += actor.getWidth();
       node.height = actor.getHeight();
     }
     if (node.icon != null) {
       rowWidth += iconSpacing * 2 + node.icon.getMinWidth();
       node.height = Math.max(node.height, node.icon.getMinHeight());
     }
     prefWidth = Math.max(prefWidth, rowWidth);
     prefHeight -= node.height + ySpacing;
     if (node.expanded) computeSize(node.children, indent + indentSpacing);
   }
 }
Example #13
0
 private Node deleteMax(Node x) {
   if (x == null) return null;
   if (x.right == null) {
     if (x.pred != null) x.pred.succ = x.succ;
     if (x.succ != null) x.succ.pred = x.pred;
     return x.left;
   }
   x.right = deleteMax(x.right);
   x.N = size(x.left) + size(x.right) + 1;
   x.height = Math.max(height(x.left), height(x.right)) + 1;
   x.avgCompares =
       (avgCompares(x.left) * size(x.left) + avgCompares(x.right) * size(x.right) + size(x))
           / size(x);
   return x;
 }
Example #14
0
 void removeInternal(Node<K, V> node, boolean unlink) {
   if (unlink) {
     node.prev.next = node.next;
     node.next.prev = node.prev;
   }
   Node<K, V> left = node.left;
   Node<K, V> right = node.right;
   Node<K, V> originalParent = node.parent;
   if (left == null || right == null) {
     if (left != null) {
       replaceInParent(node, left);
       node.left = null;
     } else if (right != null) {
       replaceInParent(node, right);
       node.right = null;
     } else {
       replaceInParent(node, null);
     }
     rebalance(originalParent, false);
     this.size--;
     this.modCount++;
     return;
   }
   Node<K, V> adjacent = left.height > right.height ? left.last() : right.first();
   removeInternal(adjacent, false);
   int leftHeight = 0;
   left = node.left;
   if (left != null) {
     leftHeight = left.height;
     adjacent.left = left;
     left.parent = adjacent;
     node.left = null;
   }
   int rightHeight = 0;
   right = node.right;
   if (right != null) {
     rightHeight = right.height;
     adjacent.right = right;
     right.parent = adjacent;
     node.right = null;
   }
   adjacent.height = Math.max(leftHeight, rightHeight) + 1;
   replaceInParent(node, adjacent);
 }
Example #15
0
  private Node<T, V> deleteTree(T delT, Node<T, V> subTree) {
    Node<T, V> ansNode = null;

    if (subTree == null) {
      System.err.println(delT + "doesn't exist.");
      System.err.flush();
      ansNode = subTree;
    } else if (comp.compare(delT, subTree.t) < 0) // delT maybe in the leftSubTree of subTree
    {
      subTree.leftChild =
          deleteTree(delT, subTree.leftChild); // the height of leftSubTree of subTree may decrease
      // once leftSubTree was return, it is balanced

      if (getHeight(subTree.rightChild) - getHeight(subTree.leftChild)
          >= 2) // subtree is the minimum unbalanced subTree
      {
        // singleRightRotate or doubleRightLeftRorate
        if (getHeight(subTree.rightChild.rightChild) >= getHeight(subTree.rightChild.leftChild)) {
          ansNode = singleRightRotate(subTree);
        } else {
          ansNode = doubleRightLeftRotate(subTree);
        }
      } else // subTree is balanced, but need to update its height
      {
        // Only the change of structure of tree causes the change of it's height
        subTree.height =
            1
                + (getHeight(subTree.leftChild) >= getHeight(subTree.rightChild)
                    ? getHeight(subTree.leftChild)
                    : getHeight(subTree.rightChild));
        ansNode = subTree;
      }
    } else if (comp.compare(delT, subTree.t) > 0) // delT maybe in the rightSubTree of subTree
    {
      subTree.rightChild =
          deleteTree(
              delT, subTree.rightChild); // the height of rightSubTree of subTree may decrease
      // once rightSubTree was return, it is balanced

      if (getHeight(subTree.leftChild) - getHeight(subTree.rightChild)
          >= 2) // subtree is the minimum unbalanced subTree
      {
        // singleLeftRotate or doubleLeftRightRotate
        if (getHeight(subTree.leftChild.leftChild) >= getHeight(subTree.leftChild.rightChild)) {
          ansNode = singleLeftRotate(subTree);
        } else {
          ansNode = doubleLeftRightRotate(subTree);
        }
      } else {
        // Only the change of structure of tree causes the change of it's height
        subTree.height =
            1
                + (getHeight(subTree.leftChild) >= getHeight(subTree.rightChild)
                    ? getHeight(subTree.leftChild)
                    : getHeight(subTree.rightChild));
        ansNode = subTree;
      }
    } else if (comp.compare(delT, subTree.t) == 0) {
      if (subTree.leftChild == null && subTree.rightChild == null) {
        ansNode = null; // once null is returned, subTree will be recycled anytime
      } else if (subTree.leftChild != null && subTree.rightChild != null) {
        subTree.t = getMin(subTree.rightChild).t;
        subTree.v = getMin(subTree.rightChild).v;
        subTree.rightChild =
            deleteTree(
                subTree.t,
                subTree.rightChild); // the height of rightSubTree of subTree may decrease
        // once rightSubTree was return, it is balanced
        if (getHeight(subTree.leftChild) - getHeight(subTree.rightChild)
            >= 2) // subtree is the minimum unbalanced subTree
        {
          // singleLeftRotate or doubleLeftRightRotate
          if (getHeight(subTree.leftChild.leftChild) >= getHeight(subTree.leftChild.rightChild)) {
            ansNode = singleLeftRotate(subTree);
          } else {
            ansNode = doubleLeftRightRotate(subTree);
          }
        } else {
          // Only the change of structure of tree causes the change of it's height
          subTree.height =
              1
                  + (getHeight(subTree.leftChild) >= getHeight(subTree.rightChild)
                      ? getHeight(subTree.leftChild)
                      : getHeight(subTree.rightChild));
          ansNode = subTree;
        }
      } else {
        if (subTree.leftChild != null && subTree.rightChild == null) {
          ansNode = subTree.leftChild; // once returned, subTree will be recycled anytime
          subTree.leftChild = null;
        } else if (subTree.leftChild == null && subTree.rightChild != null) {
          ansNode = subTree.rightChild;
          subTree.rightChild = null;
        }
      }
    }

    return ansNode;
  }
 // methods to reset and get the height of a node
 private void resetHeight(Node n) {
   n.height = Math.max(getHeight(n.left), getHeight(n.right)) + 1;
 }