iSharkFly-Docs/java-tutorials
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

binary tree changed to follow a recursive approach

Browse Source
This commit is contained in:
Marcos 2017-12-15 20:26:16 +01:00
parent a91c6659d6
commit 15bc324430
1 changed files with 94 additions and 91 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

185
core-java/src/main/java/com/baeldung/tree/BinaryTree.java
View File

@ -16,29 +16,23 @@ public class BinaryTree {
return; return;
} }
Node parent = root; addRecursive(root, value);
Node current = root; }
while (true) { private Node addRecursive(Node current, int value) {
if (newNode.value < parent.value) { if (current == null) {
current = parent.left; return new Node(value);
if (current == null) {
parent.left = newNode;
break;
}
} else {
current = parent.right;
if (current == null) {
parent.right = newNode;
break;
}
}
parent = current;
} }
if (value < current.value) {
current.left = addRecursive(current.left, value);
} else {
current.right = addRecursive(current.right, value);
}
return current;
} }
public boolean isEmpty() { public boolean isEmpty() {
@ -46,115 +40,107 @@ public class BinaryTree {
} }
public boolean containsNode(int value) { public boolean containsNode(int value) {
return containsNodeRecursive(root, value);
}
Node current = root; private boolean containsNodeRecursive(Node current, int value) {
while (current != null) {
if (value == current.value) {
return true;
}
if (value < current.value) {
current = current.left;
} else {
current = current.right;
}
if (current == null) {
return false;
} else if (value == current.value) {
return true;
} else if (value < current.value) {
return containsNodeRecursive(current.left, value);
} else {
return containsNodeRecursive(current.right, value);
} }
return false;
} }
public void delete(int value) { public void delete(int value) {
Node current = root; NodeVO nodeToDeleteAux = findNodeToDelete(root, root, false, value);
Node parent = root;
Node nodeToDelete = null;
boolean isLeftChild = false;
while (nodeToDelete == null && current != null) { if (nodeToDeleteAux == null) {
if (value == current.value) {
nodeToDelete = current;
} else if (value < current.value) {
parent = current;
current = current.left;
isLeftChild = true;
} else {
parent = current;
current = current.right;
isLeftChild = false;
}
}
if (nodeToDelete == null) {
return; return;
} }
// Case 1: no children // Case 1: no children
if (nodeToDelete.left == null && nodeToDelete.right == null) { if (nodeToDeleteAux.node.left == null && nodeToDeleteAux.node.right == null) {
if (nodeToDelete == root) { if (nodeToDeleteAux.node == root) {
root = null; root = null;
} else if (isLeftChild) { } else if (nodeToDeleteAux.isLeftChild) {
parent.left = null; nodeToDeleteAux.parent.left = null;
} else { } else {
parent.right = null; nodeToDeleteAux.parent.right = null;
} }
} }
// Case 2: only 1 child // Case 2: only 1 child
else if (nodeToDelete.right == null) { else if (nodeToDeleteAux.node.right == null) {
if (nodeToDelete == root) { if (nodeToDeleteAux.node == root) {
root = nodeToDelete.left; root = nodeToDeleteAux.node.left;
} else if (isLeftChild) { } else if (nodeToDeleteAux.isLeftChild) {
parent.left = nodeToDelete.left; nodeToDeleteAux.parent.left = nodeToDeleteAux.node.left;
} else { } else {
parent.right = nodeToDelete.left; nodeToDeleteAux.parent.right = nodeToDeleteAux.node.left;
} }
} else if (nodeToDelete.left == null) { } else if (nodeToDeleteAux.node.left == null) {
if (nodeToDelete == root) { if (nodeToDeleteAux.node == root) {
root = nodeToDelete.right; root = nodeToDeleteAux.node.right;
} else if (isLeftChild) { } else if (nodeToDeleteAux.isLeftChild) {
parent.left = nodeToDelete.right; nodeToDeleteAux.parent.left = nodeToDeleteAux.node.right;
} else { } else {
parent.right = nodeToDelete.right; nodeToDeleteAux.parent.right = nodeToDeleteAux.node.right;
} }
} }
// Case 3: 2 children // Case 3: 2 children
else if (nodeToDelete.left != null && nodeToDelete.right != null) { else if (nodeToDeleteAux.node.left != null && nodeToDeleteAux.node.right != null) {
Node replacement = findReplacement(nodeToDelete); Node replacement = findReplacement(nodeToDeleteAux.node);
if (nodeToDelete == root) { if (nodeToDeleteAux.node == root) {
root = replacement; root = replacement;
} else if (isLeftChild) { } else if (nodeToDeleteAux.isLeftChild) {
parent.left = replacement; nodeToDeleteAux.parent.left = replacement;
} else { } else {
parent.right = replacement; nodeToDeleteAux.parent.right = replacement;
} }
} }
} }
private NodeVO findNodeToDelete(Node current, Node parent, boolean isLeftChild, int value) {
if (current == null) {
return null;
} else if (value == current.value) {
return new NodeVO(current, parent, isLeftChild);
} else if (value < current.value) {
return findNodeToDelete(current.left, current, true, value);
} else {
return findNodeToDelete(current.right, current, false, value);
}
}
private Node findReplacement(Node nodeToDelete) { private Node findReplacement(Node nodeToDelete) {
Node replacement = nodeToDelete; NodeVO replacementNodeVO = findSmallestNode(nodeToDelete, nodeToDelete);
Node parentReplacement = nodeToDelete;
Node current = nodeToDelete.right;
while (current != null) { if (replacementNodeVO.node != nodeToDelete.right) {
parentReplacement = replacement; replacementNodeVO.parent.left = replacementNodeVO.node.right;
replacement = current; replacementNodeVO.node.right = nodeToDelete.right;
current = current.left;
} }
if (replacement != nodeToDelete.right) { replacementNodeVO.node.left = nodeToDelete.left;
parentReplacement.left = replacement.right;
replacement.right = nodeToDelete.right; return replacementNodeVO.node;
}
private NodeVO findSmallestNode(Node root, Node parent) {
if (root.left == null) {
return new NodeVO(root, parent);
} }
replacement.left = nodeToDelete.left; return findSmallestNode(root.left, root);
return replacement;
} }
public void traverseInOrder(Node node) { public void traverseInOrder(Node node) {
@ -202,6 +188,23 @@ public class BinaryTree {
} }
} }
class NodeVO {
Node node;
Node parent;
boolean isLeftChild;
NodeVO(Node node, Node parent) {
this.node = node;
this.parent = parent;
}
NodeVO(Node node, Node parent, boolean isLeftChild) {
this.node = node;
this.parent = parent;
this.isLeftChild = isLeftChild;
}
}
class Node { class Node {
int value; int value;
Node left; Node left;