public Node findMax(Node currRoot) { Node curr = currRoot; while (curr.getRightChild() != null) { curr = curr.getRightChild(); } return curr; }
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); } }
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; }
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(); } }
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; }
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(); }
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(); } }
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); } }
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; }
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); } } }
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); }