Binary Tree

Introduction to Algorithms and
Data Structures
Lecture 12 - “I think that I shall never
see.. a data structure lovely as a”
Binary Tree
What is a Binary Tree
• A binary tree is a a collection of nodes that
consists of the root and other subsets to the root
points, which are called the left and right subtrees.
• Every parent node on a binary tree can have up to

two child nodes (roots of the two subtrees); any
more children and it becomes a general tree.
• A node that has no children is called a leaf node.

A Few Terms Regarding Binary Trees
B C
D E F
A is the root
B and C are A’s children
A is B’s parent G
B & C are the root of two subtrees
D, E, and G are leaves
This is NOT A Binary Tree
B C
D E F G H
This is a general tree because C has three child nodes

This is NOT A Binary Tree
B C
D E F G
This is a graph H
because A, B, E, H, F and C
form a circuit
Tree Traversal
• There are three common ways to traverse a tree:

– Preorder: Visit the root, traverse the left subtree
(preorder) and then traverse the right subtree (preorder)
– Postorder: Traverse the left subtree (postorder),
traverse the right subtree (postorder) and then visit the
root.
– Inorder: Traverse the left subtree (in order), visit the
root and the traverse the right subtree (in order).
Tree Traversals: An Example
A
B C
D E F
Preorder: ABDECFG
Postorder: DEBGFCA G
In Order: DBEAFGC
A
B C
D E F
Preorder: A
(visit each node as your reach it) G
A
B C
D E F
Preorder: AB
A
B C
D E F
Preorder: ABD
A
B C
D E F
Preorder: ABDE
A
B C
D E F
Preorder: ABDEC
A
B C
D E F
Preorder: ABDECF
A
B C
D E F
Preorder: ABDECFG
A
B C
D E F
Postorder:
G
A
B C
D E F
Postorder:
G
A
B C
D E F
Postorder: D
G
A
B C
D E F
Postorder: DE
G
A
B C
D E F
Postorder: DEB
G
A
B C
D E F
Postorder: DEB
G
A
B C
D E F
Postorder: DEB
G
A
B C
D E F
Postorder: DEBG
G
A
B C
D E F
Postorder: DEBGF
G
A
B C
D E F
Postorder: DEBGFC
G
A
B C
D E F
Postorder: DEBGFCA
G
A
B C
D E F
G
In Order:
A
B C
D E F
G
In Order:
A
B C
D E F
G
In Order: D
A
B C
D E F
G
In Order: DB
A
B C
D E F
G
In Order: DBE
A
B C
D E F
G
In Order: DBEA
A
B C
D E F
G
In Order: DBEA
A
B C
D E F
G
In Order: DBEAF
A
B C
D E F
G
In Order: DBEAFG
A
B C
D E F
G
In Order: DBEAFGC
A
B C
D E F
Preorder: ABDECFG
Postorder: DEBGFCA G
In Order: DBEAFGC
Tree Traversals: Another Example
A
B C
D E
G
F
Preorder: ABDFHIECG
Postorder: HIFDEBGCA
H I In Order: DHFIBEACG
A
B C
D E
G
F
Preorder: A
H I
A
B C
D E
G
F
Preorder: AB
H I
A
B C
D E
G
F
Preorder: ABD
H I
A
B C
D E
G
F
Preorder: ABDF
H I
A
B C
D E
G
F
Preorder: ABDFH
H I
A
B C
D E
G
F
Preorder: ABDFHI
H I
A
B C
D E
G
F
Preorder: ABDFHIE
H I
A
B C
D E
G
F
Preorder: ABDFHIEC
H I
A
B C
D E
G
F
Preorder: ABDFHIECG
H I
A
B C
D E
G
Postorder:
H I
A
B C
D E
G
Postorder:
H I
A
B C
D E
G
Postorder:
H I
A
B C
D E
G
Postorder:
H I
A
B C
D E
G
Postorder: H
H I
A
B C
D E
G
Postorder: HI
H I
A
B C
D E
G
Postorder: HIF
H I
A
B C
D E
G
Postorder: HIFD
H I
A
B C
D E
G
Postorder: HIFDE
H I
A
B C
D E
G
Postorder: HIFDEB
H I
A
B C
D E
G
Postorder: HIFDEB
H I
A
B C
D E
G
Postorder: HIFDEBG
H I
A
B C
D E
G
Postorder: HIFDEBGC
H I
A
B C
D E
G
H I
A
B C
D E
G
H I In Order:
A
B C
D E
G
H I In Order:
A
B C
D E
G
H I In Order: D
A
B C
D E
G
H I In Order: D
A
B C
D E
G
H I In Order: DH
A
B C
D E
G
H I In Order: DHF
A
B C
D E
G
H I In Order: DHFI
A
B C
D E
G
H I In Order: DHFIB
A
B C
D E
G
H I In Order: DHFIBE
A
B C
D E
G
H I In Order: DHFIBEA
A
B C
D E
G
H I In Order: DHFIBEAC
A
B C
D E
G
A
B C
D E
G
F
Preorder: ABDFHIECG
Basic Implementation of a Binary
Tree
• We can implement a binary in essentially
the same way as a linked list, except that
there are two nodes that comes next:
public class Node {
private int data;
private Node left;
private Node right;
public int getData() {
return data;
}
public Node getLeft() {

return left;
}
public Node getRight() {

return right;
}
public void setData(int x) {

data = x;
}
public void setLeft(Node p) {
left = p;
}
public void setRight(Node p) {

right = p;
}
}
The tree Class
public class Tree {
private Node root;
// tree() - The default constructor – Starts

// the tree as empty
public Tree() {
root = null;
}
// Tree() - An initializing constructor that

// creates a node and places in it
// the initial value
public Tree(int x) {
root = new Node();
root.setData(x);
root.setLeft(null);
root.setRight(null);
}
public Node getRoot() {

return root;
}
// newNode() - Creates a new node with a
// zero as data by default
public Node newNode() {
Node p = new Node();
p.setData(0);
p.setLeft(null);
p.setRight(null);
return(p);
}
// newNode() - Creates a new node with the
// parameter x as its value
public Node newNode(int x) {
Node p = new Node();
p.setData(x);
p.setLeft(null);
p.setRight(null);
return(p);
}
//travTree() – initializes recursive
// traversal of tree
public void travTree() {
if (root != null)
travSubtree(root);
System.out.println();
}
//travSubtree() – recursive method used to
// traverse a binary tree (inorder)
public void travSubtree(Node p) {
if (p != null) {
travSubtree(p.getLeft());
System.out.print(p.getData()
+ "\t");
travSubtree(p.getRight());
}
}
// addLeft() - Inserts a new node containing
// x as the left child of p
public void addLeft(Node p, int x) {
Node q = newNode(x);
p.setLeft(q);
}
// addRight() - Inserts a new node containing

// x as the right child of p
public void addRight(Node p, int x) {
Node q = newNode(x);
p.setRight(q);
}
}
A Basic Search Tree
• We can construct a simple search tree if we
add new nodes with value x on the tree
using this strategy:
– Every time x is less than the value in the node
we move down to the left.
– Every time x is greater than the value in the
node we move down to the right.
A Sample Search Tree
15
8 22
5 12 18 23
7 10 16 20
// insert() - Insert value x in a new node
to
// be inserted after p
public void insert(int x) {
Node p, q;
boolean found = false;
p = root;
q = null;
while (p != null && !found) {

q = p;
if (p.getData() == x)
found = true;
else if (p.getData() > x)
p = p.getLeft();
else
p = p.getRight();
}
if (found)
error("Duplicate entry");
if (q.getData() > x)
addLeft(q, x);
else
addRight(q, x);
//q = newNode(x);
}
// isXThere() - Is there a node in the
// tree containing x?
public boolean isXThere(int x) {
Node p;
p = root;
found = true;
p = p.getLeft();
else
p = p.getRight();
}
return(found);
}
public void error(String message) {
System.out.println(message);
System.exit(0);
}
// getNode() - Get the pointer for the
// node containing x
public Node getNode(int x) {
Node p, q;
p = root;
q = null;
q = p;
found = true;
p = p.getLeft();
else
p = p.getRight();
}
if (found)
return(q);
else
return(null);
}
public class TestTree {
public static void main(String[] args) {
Tree mytree = new Tree(8);
mytree.addLeft(mytree.getRoot(), 6);
mytree.addRight(mytree.getRoot(), 9);
mytree.insert(4);
mytree.insert(1);
mytree.insert(12);
if (mytree.isXThere(13))
System.out.println("great");
else
System.out.println("not great, Bob");
mytree.travTree();
}
}
Tracing TestTree
8
Tracing TestTree
8
6
Tracing TestTree
8
6
9
Tracing TestTree
8
6
9
4
Tracing TestTree
8
6
9
1
Tracing TestTree
8
6
9
4 12

Binary Tree

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Binary Tree

Uploaded by

Copyright:

Available Formats

Introduction to Algorithms and

• Every parent node on a binary tree can have up to

• A node that has no children is called a leaf node.

This is a general tree because C has three child nodes

• There are three common ways to traverse a tree:

public Node getLeft() {

public Node getRight() {

public void setData(int x) {

public void setRight(Node p) {

// tree() - The default constructor – Starts

// Tree() - An initializing constructor that

public Node getRoot() {

// addRight() - Inserts a new node containing

while (p != null && !found) {

You might also like