Example #1
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 #2
0
 // create a complete binary tree based on the array
 Node createCompleteTree(int[] array) {
   // special cases
   if (array.length == 0) return null;
   if (array.length == 1) return new Node(array[0]);
   LinkedList<Node> Nodes = new LinkedList<>();
   Node root = new Node(array[0]);
   Nodes.add(root);
   int index = 1;
   while (!Nodes.isEmpty()) {
     Node temp = Nodes.pollLast();
     // add left child
     Node newNode = new Node(array[index]);
     temp.leftChild = newNode;
     Nodes.addFirst(newNode);
     index++;
     // check whether out of range
     if (index == array.length) break;
     // add right child
     newNode = new Node(array[index]);
     temp.rightChild = newNode;
     Nodes.addFirst(newNode);
     index++;
     // check whether out of range
     if (index == array.length) break;
   }
   return root;
 }
Example #3
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 #4
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;
  }
Example #5
0
  private Node<T, V> doubleLeftRightRotate(Node<T, V> subTree) {

    subTree.leftChild = singleRightRotate(subTree.leftChild);
    Node<T, V> ansNode = singleLeftRotate(subTree);
    return ansNode;
  }