Created
April 26, 2019 03:02
-
-
Save dfparker2002/0f271d7c08fb427b0d5209b8db9315da to your computer and use it in GitHub Desktop.
BinaryTree example + test
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
/* | |
src: https://github.com/eugenp/tutorials/blob/8a8be56535978fab018ab7f26d12c3028c67bdd9/data-structures/src/main/java/com/baeldung/tree/BinaryTree.java | |
*/ | |
import java.util.LinkedList; | |
import java.util.Queue; | |
public class BinaryTree { | |
Node root; | |
public void add(int value) { | |
root = addRecursive(root, value); | |
} | |
private Node addRecursive(Node current, int value) { | |
if (current == null) { | |
return new Node(value); | |
} | |
if (value < current.value) { | |
current.left = addRecursive(current.left, value); | |
} else if (value > current.value) { | |
current.right = addRecursive(current.right, value); | |
} | |
return current; | |
} | |
public boolean isEmpty() { | |
return root == null; | |
} | |
public int getSize() { | |
return getSizeRecursive(root); | |
} | |
private int getSizeRecursive(Node current) { | |
return current == null ? 0 : getSizeRecursive(current.left) + 1 + getSizeRecursive(current.right); | |
} | |
public boolean containsNode(int value) { | |
return containsNodeRecursive(root, value); | |
} | |
private boolean containsNodeRecursive(Node current, int value) { | |
if (current == null) { | |
return false; | |
} | |
if (value == current.value) { | |
return true; | |
} | |
return value < current.value | |
? containsNodeRecursive(current.left, value) | |
: containsNodeRecursive(current.right, value); | |
} | |
public void delete(int value) { | |
root = deleteRecursive(root, value); | |
} | |
private Node deleteRecursive(Node current, int value) { | |
if (current == null) { | |
return null; | |
} | |
if (value == current.value) { | |
// Case 1: no children | |
if (current.left == null && current.right == null) { | |
return null; | |
} | |
// Case 2: only 1 child | |
if (current.right == null) { | |
return current.left; | |
} | |
if (current.left == null) { | |
return current.right; | |
} | |
// Case 3: 2 children | |
int smallestValue = findSmallestValue(current.right); | |
current.value = smallestValue; | |
current.right = deleteRecursive(current.right, smallestValue); | |
return current; | |
} | |
if (value < current.value) { | |
current.left = deleteRecursive(current.left, value); | |
return current; | |
} | |
current.right = deleteRecursive(current.right, value); | |
return current; | |
} | |
private int findSmallestValue(Node root) { | |
return root.left == null ? root.value : findSmallestValue(root.left); | |
} | |
public void traverseInOrder(Node node) { | |
if (node != null) { | |
traverseInOrder(node.left); | |
System.out.print(" " + node.value); | |
traverseInOrder(node.right); | |
} | |
} | |
public void traversePreOrder(Node node) { | |
if (node != null) { | |
System.out.print(" " + node.value); | |
traversePreOrder(node.left); | |
traversePreOrder(node.right); | |
} | |
} | |
public void traversePostOrder(Node node) { | |
if (node != null) { | |
traversePostOrder(node.left); | |
traversePostOrder(node.right); | |
System.out.print(" " + node.value); | |
} | |
} | |
public void traverseLevelOrder() { | |
if (root == null) { | |
return; | |
} | |
Queue<Node> nodes = new LinkedList<>(); | |
nodes.add(root); | |
while (!nodes.isEmpty()) { | |
Node node = nodes.remove(); | |
System.out.print(" " + node.value); | |
if (node.left != null) { | |
nodes.add(node.left); | |
} | |
if (node.right != null) { | |
nodes.add(node.right); | |
} | |
} | |
} | |
class Node { | |
int value; | |
Node left; | |
Node right; | |
Node(int value) { | |
this.value = value; | |
right = null; | |
left = null; | |
} | |
} | |
} | |
import static org.junit.Assert.assertEquals; | |
import static org.junit.Assert.assertFalse; | |
import static org.junit.Assert.assertTrue; | |
import org.junit.Test; | |
public class BinaryTreeUnitTest { | |
@Test | |
public void givenABinaryTree_WhenAddingElements_ThenTreeNotEmpty() { | |
BinaryTree bt = createBinaryTree(); | |
assertTrue(!bt.isEmpty()); | |
} | |
@Test | |
public void givenABinaryTree_WhenAddingElements_ThenTreeContainsThoseElements() { | |
BinaryTree bt = createBinaryTree(); | |
assertTrue(bt.containsNode(6)); | |
assertTrue(bt.containsNode(4)); | |
assertFalse(bt.containsNode(1)); | |
} | |
@Test | |
public void givenABinaryTree_WhenAddingExistingElement_ThenElementIsNotAdded() { | |
BinaryTree bt = createBinaryTree(); | |
int initialSize = bt.getSize(); | |
assertTrue(bt.containsNode(3)); | |
bt.add(3); | |
assertEquals(initialSize, bt.getSize()); | |
} | |
@Test | |
public void givenABinaryTree_WhenLookingForNonExistingElement_ThenReturnsFalse() { | |
BinaryTree bt = createBinaryTree(); | |
assertFalse(bt.containsNode(99)); | |
} | |
@Test | |
public void givenABinaryTree_WhenDeletingElements_ThenTreeDoesNotContainThoseElements() { | |
BinaryTree bt = createBinaryTree(); | |
assertTrue(bt.containsNode(9)); | |
bt.delete(9); | |
assertFalse(bt.containsNode(9)); | |
} | |
@Test | |
public void givenABinaryTree_WhenDeletingNonExistingElement_ThenTreeDoesNotDelete() { | |
BinaryTree bt = createBinaryTree(); | |
int initialSize = bt.getSize(); | |
assertFalse(bt.containsNode(99)); | |
bt.delete(99); | |
assertFalse(bt.containsNode(99)); | |
assertEquals(initialSize, bt.getSize()); | |
} | |
@Test | |
public void it_deletes_the_root() { | |
int value = 12; | |
BinaryTree bt = new BinaryTree(); | |
bt.add(value); | |
assertTrue(bt.containsNode(value)); | |
bt.delete(value); | |
assertFalse(bt.containsNode(value)); | |
} | |
@Test | |
public void givenABinaryTree_WhenTraversingInOrder_ThenPrintValues() { | |
BinaryTree bt = createBinaryTree(); | |
bt.traverseInOrder(bt.root); | |
} | |
@Test | |
public void givenABinaryTree_WhenTraversingPreOrder_ThenPrintValues() { | |
BinaryTree bt = createBinaryTree(); | |
bt.traversePreOrder(bt.root); | |
} | |
@Test | |
public void givenABinaryTree_WhenTraversingPostOrder_ThenPrintValues() { | |
BinaryTree bt = createBinaryTree(); | |
bt.traversePostOrder(bt.root); | |
} | |
@Test | |
public void givenABinaryTree_WhenTraversingLevelOrder_ThenPrintValues() { | |
BinaryTree bt = createBinaryTree(); | |
bt.traverseLevelOrder(); | |
} | |
private BinaryTree createBinaryTree() { | |
BinaryTree bt = new BinaryTree(); | |
bt.add(6); | |
bt.add(4); | |
bt.add(8); | |
bt.add(3); | |
bt.add(5); | |
bt.add(7); | |
bt.add(9); | |
return bt; | |
} | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment