Beispiel #1
0
 public Node findMax(Node currRoot) {
   Node curr = currRoot;
   while (curr.getRightChild() != null) {
     curr = curr.getRightChild();
   }
   return curr;
 }
Beispiel #2
0
  public void right_rotate(Node curr) {
    if (curr != null) {
      if (curr.getLeftChild() == null) {
        System.out.println("Cannot rotate right since left child is not present");
        return;
      }

      Node rotateWith = curr.getLeftChild();
      rotateWith.setParent(curr.getParent());

      if (curr.getParent() != null) {
        Node currParent = curr.getParent();
        if (curr == currParent.getLeftChild()) currParent.setLeftChild(rotateWith);
        else currParent.setRightChild(rotateWith);
      } else {
        root = rotateWith;
      }

      curr.setLeftChild(rotateWith.getRightChild());

      if (rotateWith.getRightChild() != null) rotateWith.getRightChild().setParent(curr);

      rotateWith.setRightChild(curr);
      curr.setParent(rotateWith);
    }
  }
Beispiel #3
0
 private void computeBalance(Node curr) {
   int leftHeight = -1, rightHeight = -1;
   if (curr.getLeftChild() != null) {
     leftHeight = curr.getLeftChild().getHeight();
   }
   if (curr.getRightChild() != null) {
     rightHeight = curr.getRightChild().getHeight();
   }
   curr.setBalance(rightHeight - leftHeight);
 }
 // encapsulated working method
 private Node search(int key, Node currRoot) {
   if (currRoot.getKey() == key) {
     return currRoot;
   } else if (key < currRoot.getKey() && currRoot.getLeftChild() != null) {
     return search(key, currRoot.getLeftChild());
   } else if (key > currRoot.getKey() && currRoot.getRightChild() != null) {
     return search(key, currRoot.getRightChild());
   } else {
     System.out.println("Element is not present in the tree");
     return null;
   }
 }
 // 前序遍历
 static <T> void priorderTraversal(Node<T> node) {
   if (node != null) {
     visitNode(node);
     priorderTraversal(node.getLeftChild());
     priorderTraversal(node.getRightChild());
   }
 }
  private int checkHeight(Node root) {
    if (root == null) {
      return 0;
    }

    // Check if left is balanced
    int leftHeight = checkHeight(root.getLeftChild());
    // System.out.println("Height of " + root.getLeftChild() + " is " + leftHeight);
    if (leftHeight == -1) {
      return -1; // Not balanced
    }

    // Check if right is balanced
    int rightHeight = checkHeight(root.getRightChild());
    // System.out.println("Height of " + root.getRightChild() + " is " + rightHeight);
    if (rightHeight == -1) {
      return -1; // Not balanced
    }

    // Check of current node is balanced
    int heightDiff = leftHeight - rightHeight;
    if (Math.abs(heightDiff) > 1) {
      return -1; // Not balanced
    } else {
      // System.out.println("Height of this tree is: " + (Math.max(leftHeight, rightHeight) + 1));
      return Math.max(leftHeight, rightHeight) + 1; // return height
    }
  }
 /**
  * This method determines the height of a tree.
  *
  * @param root
  * @return height
  */
 public int getHeight(Node root) {
   if (root == null) {
     return 0;
   } else {
     return Math.max(getHeight(root.getLeftChild()), getHeight(root.getRightChild())) + 1;
   }
 }
 // encapsulated/private working method
 private void insert(Node newNode, Node currRoot) {
   if (newNode.getKey() <= currRoot.getKey()) {
     if (currRoot.getLeftChild() != null) {
       insert(newNode, currRoot.getLeftChild());
     } else {
       currRoot.setLeftChild(newNode);
       newNode.setParent(currRoot);
     }
   } else {
     if (currRoot.getRightChild() != null) {
       insert(newNode, currRoot.getRightChild());
     } else {
       currRoot.setRightChild(newNode);
       newNode.setParent(currRoot);
     }
   }
 }
  public int total_inversions() {
    LinkedList<Node> queue = new LinkedList<Node>();
    Node curr = root;
    int level = 0;
    curr.setLevelNo(level);

    int sizeOfPrevNodes = 0;
    int sizeOfLeftSubtree = 0;
    int noOfInversions = 0;

    if (curr != null) {
      queue.addLast(curr);
    }

    while (!queue.isEmpty()) {
      curr = queue.removeFirst();

      if (curr.getLevelNo() != level) {
        level++;
        sizeOfPrevNodes = 0;
      }

      if (curr.getLeftChild() != null) {
        sizeOfLeftSubtree = curr.getLeftChild().getSizeOfSubtreeMinusOne() + 1;
        curr.getLeftChild().setLevelNo(level + 1);
        queue.addLast(curr.getLeftChild());
      } else {
        sizeOfLeftSubtree = 0;
      }

      if (curr.getRightChild() != null) {
        curr.getRightChild().setLevelNo(level + 1);
        queue.addLast(curr.getRightChild());
      }

      noOfInversions += sizeOfLeftSubtree + sizeOfPrevNodes;

      System.out.print((sizeOfLeftSubtree + sizeOfPrevNodes) + " ");

      sizeOfPrevNodes += curr.getSizeOfSubtreeMinusOne();
    }

    System.out.println();

    return noOfInversions;
  }
Beispiel #10
0
  public Node successor(int key) {
    Node curr = search(key);

    if (curr.getRightChild() != null) {
      return findMin(curr.getRightChild());
    } else if (curr == findMax(root)) {
      System.out.println(
          "this element is the maximum in the tree and hence does not have a successor");
      return null;
    } else {
      while (curr.getParent().getRightChild() == curr) {
        curr = curr.getParent();
      }

      return curr.getParent();
    }
  }
Beispiel #11
0
  public void insert_restore_AVL_prop(Node curr) {
    curr.setHeight(-1);
    curr.setBalance(0);

    while (curr != null && curr.getBalance() == 0) {
      curr.setHeight(curr.getHeight() + 1);

      computeBalance(curr);

      curr = curr.getParent();
    }

    if (curr != null) {
      computeBalance(curr);

      if (curr.getBalance() == -2) {
        if (curr.getLeftChild().getBalance() == 1) {

          left_rotate(curr.getLeftChild());
          height_of_node(curr.getLeftChild());
          computeBalance(curr.getLeftChild());
          computeBalance(curr.getLeftChild().getLeftChild());
        }

        right_rotate(curr);
        height_of_node(curr.getParent());
        computeBalance(curr);
        computeBalance(curr.getParent());
      } else if (curr.getBalance() == 2) {
        if (curr.getRightChild().getBalance() == -1) {

          right_rotate(curr.getRightChild());
          height_of_node(curr.getRightChild());
          computeBalance(curr.getRightChild());
          computeBalance(curr.getRightChild().getRightChild());
        }

        left_rotate(curr);
        height_of_node(curr.getParent());
        computeBalance(curr);
        computeBalance(curr.getParent());
      }
    }
  }
 // 二叉树深度
 static <T> int getDepth(Node<T> node) {
   if (node == null) {
     return 0;
   }
   int leftDepth = 0;
   int rightDepth = 0;
   leftDepth = getDepth(node.getLeftChild());
   rightDepth = getDepth(node.getRightChild());
   return (leftDepth > rightDepth ? leftDepth : rightDepth) + 1;
 }
 private boolean checkBST(Node root, int min, int max) {
   if (root == null) {
     return true;
   }
   if (root.getKey() < min || root.getKey() > max) {
     return false;
   }
   return checkBST(root.getLeftChild(), min, root.getKey())
       && checkBST(root.getRightChild(), root.getKey(), max);
 }
  public void level_order_traversal() {
    LinkedList<Node> queue = new LinkedList<Node>();
    Node curr = root;

    if (curr != null) {
      queue.addLast(curr);
    }

    while (!queue.isEmpty()) {
      curr = queue.removeFirst();
      if (curr.getLeftChild() != null) {
        queue.addLast(curr.getLeftChild());
      }
      if (curr.getRightChild() != null) {
        queue.addLast(curr.getRightChild());
      }
      System.out.print(curr.getKey() + " ");
    }
    System.out.println();
  }
  private int size_of_subtree(Node currNode) {
    int size = 0;

    if (currNode.getLeftChild() == null && currNode.getRightChild() == null) {
      currNode.setSizeOfSubtreeMinusOne(size);
      return size;
    }

    if (currNode.getLeftChild() != null) {
      size = size_of_subtree(currNode.getLeftChild()) + 1;
      currNode.setSizeOfSubtreeMinusOne(size);
    }

    if (currNode.getRightChild() != null) {
      size = size_of_subtree(currNode.getRightChild()) + 1;
      currNode.setSizeOfSubtreeMinusOne(currNode.getSizeOfSubtreeMinusOne() + size);
    }

    return size;
  }
Beispiel #16
0
  private int height_of_node(Node currNode) {
    if (currNode == null) {
      return -1;
    }

    currNode.setHeight(
        1
            + Math.max(
                height_of_node(currNode.getLeftChild()), height_of_node(currNode.getRightChild())));
    return currNode.getHeight();
  }
Beispiel #17
0
  public void delete_restore_AVL_prop(Node curr) {
    height_of_node(curr);

    while (curr != null) {
      computeBalance(curr);

      if (curr.getBalance() == -2) {
        if (curr.getLeftChild().getBalance() == 1) {

          left_rotate(curr.getLeftChild());
          height_of_node(curr.getLeftChild());
          computeBalance(curr.getLeftChild());
          computeBalance(curr.getLeftChild().getLeftChild());
        }

        right_rotate(curr);
        height_of_node(curr.getParent());
        computeBalance(curr);
        computeBalance(curr.getParent());

        curr = curr.getParent();
      } else if (curr.getBalance() == 2) {
        if (curr.getRightChild().getBalance() == -1) {

          right_rotate(curr.getRightChild());
          height_of_node(curr.getRightChild());
          computeBalance(curr.getRightChild());
          computeBalance(curr.getRightChild().getRightChild());
        }

        left_rotate(curr);
        height_of_node(curr.getParent());
        computeBalance(curr);
        computeBalance(curr.getParent());

        curr = curr.getParent();
      }

      curr = curr.getParent();
    }
  }
Beispiel #18
0
  public void set_balance_of_all_nodes() {
    LinkedList<Node> queue = new LinkedList<Node>();
    Node curr = root;

    if (curr != null) {
      queue.addLast(curr);
    }

    while (!queue.isEmpty()) {
      curr = queue.removeFirst();

      if (curr.getLeftChild() != null) {
        queue.addLast(curr.getLeftChild());
      }

      if (curr.getRightChild() != null) {
        queue.addLast(curr.getRightChild());
      }

      computeBalance(curr);
    }
  }
Beispiel #19
0
  private List<NodeValue> traverse(Node node) {
    if (node == null) return null;
    List<NodeValue> list = new LinkedList<NodeValue>();
    List<NodeValue> result;

    list.add(node.getKey());
    result = traverse(node.getLeftChild());
    if (result != null) {
      list.addAll(result);
      result.clear();
    }

    result = traverse(node.getRightChild());
    if (result != null) list.addAll(result);

    return list;
  }
Beispiel #20
0
  public void delete(int key) {
    Node curr = search(key);
    Node restore = null;

    if (curr != null) {
      if (curr.getLeftChild() == null && curr.getRightChild() == null) {
        if (curr.getParent().getLeftChild() == curr) curr.getParent().setLeftChild(null);
        else curr.getParent().setRightChild(null);
        delete_restore_AVL_prop(curr.getParent());
      } else if (curr.getLeftChild() == null) {
        transplant(curr, curr.getRightChild());
        delete_restore_AVL_prop(curr.getParent());
      } else if (curr.getRightChild() == null) {
        transplant(curr, curr.getLeftChild());
        delete_restore_AVL_prop(curr.getParent());
      } else {
        Node successor = successor(curr.getKey());
        // since we have already handled the case of node to be deleted being leaf, the successor
        // that we get know will be the minimum of right subtree and hence won't have any left child
        if (successor.getParent() != curr) {
          transplant(
              successor,
              successor
                  .getRightChild()); // since successor doesn't have left child, we delete it and
          // replace it by its right child
          successor.setRightChild(curr.getRightChild());
          successor.getRightChild().setParent(successor);
          restore = successor.getParent();
        } else {
          restore = successor;
        }
        transplant(curr, successor);
        successor.setLeftChild(curr.getLeftChild());
        successor.getLeftChild().setParent(successor);
        delete_restore_AVL_prop(restore);
      }
    }
  }
Beispiel #21
0
 private Node getLeaf(Node node, FeatureVector fv) {
   if (node.getLeftChild() == null && node.getRightChild() == null) return node;
   else if (fv.value(node.getGainRatio().getMaxValuedIndex())
       <= node.getGainRatio().getMaxValuedThreshold()) return getLeaf(node.getLeftChild(), fv);
   else return getLeaf(node.getRightChild(), fv);
 }