Java Tutorial Lab 9

LAB #9
Prepared by: Berk Soysal
2016 Winter

Recursion is the process of defining
something in terms of itself.
2016 Winter

public class Example{
private static int a=0;
public static void main(String[] args){
myRecursiveMethod();
}
public static int myRecursiveMethod(){
a++;
if(a==10){
System.out.println("Recursion ends when a is " + a);
return a;
}
System.out.println("a is:"+ a);
return myRecursiveMethod();
}
}
2016 Winter

public class Mystery extends Program {
public void run() {
int result = compute(4);
System.out.println(result);
}
public int compute(int n) {
if(n == 1) {
return 1;
} else {
return n * compute(n - 1); // here's the recursive invocation
}
}
}
2016 Winter

You may object: How is this useful? I could just as easily
have written the program using a loop!
We prefer recursive solutions over iterative ones when:
• The implementation of the recursion is much simpler
than the iterative solution(e.g. factorial calculation,
binary search trees)
• I can be reasonably assured that the depth of the
recursion will not cause a stack overflow.
• In most of other situations LOOPS are preferred!
2016 Winter

• A binary tree is composed of zero or more nodes
– In Java, a reference to a binary tree may be null
• Each node contains:
– A value (some sort of data item)
– A reference or pointer to a left child (may be null), and
– A reference or pointer to a right child (may be null)
• A binary tree may be empty (contain no nodes)
• If not empty, a binary tree has a root node
– Every node in the binary tree is reachable from the root node by
a unique path
• A node with no left child and no right child is called a
leaf.
– In some binary trees, only the leaves contain a value
2016 Winter

a
b c
d e
g h i
l
f
j k
The root is
drawn at the
top
2016 Winter

• The following two binary trees are different:
• In the first binary tree, node A has a left child but no right
child; in the second, node A has a right child but no left
child
• Put another way: Left and right are not relative terms
A
B
A
B
2016 Winter

• The size of a binary tree is
the number of nodes in it
– This tree has size 12
• The depth of a node is its
distance from the root
– a is at depth zero
– e is at depth 2
• The depth of a binary tree is
the depth of its deepest
node
– This tree has depth 4
2016 Winter

• A binary tree is balanced if every level above the lowest is
“full” (contains 2n nodes)
• In most applications, a reasonably balanced binary tree is
desirable
a
b c
d e f g
h i j
A balanced binary tree
a
b
c
d
e
f
g h
i j
An unbalanced binary tree
2016 Winter

• A binary tree is sorted if every node in the tree is larger
than (or equal to) its left descendants, and smaller than
(or equal to) its right descendants
• Equal nodes can go either on the left or the right (but it
has to be consistent)
10
8 15
4 12 20
17
2016 Winter

• Look at array location (lo + hi)/2
2 3 5 7 11 13 17
0 1 2 3 4 5 6
Searching for 5:
(0+6)/2 = 3
hi = 2;
(0 + 2)/2 = 1 lo = 2;
(2+2)/2=2
7
3 13
2 5 11 17
Using a binary
search tree
2016 Winter

• A binary tree is defined recursively: it consists of a
root, a left subtree, and a right subtree.
• To traverse (or walk) the binary tree is to visit each
node in the binary tree exactly once.
• Tree traversals are naturally recursive.
• Since a binary tree has three “parts,” there are six
possible ways to traverse the binary tree:
– root, left, right
– left, root, right
– left, right, root
– root, right, left
– right, root, left
– right, left, root
2016 Winter

• In preorder, the root is visited first
• Here’s a preorder traversal to print out all the
elements in the binary tree:
public void preorderPrint(BinaryTree bt) {
if (bt == null) return;
System.out.println(bt.value);
preorderPrint(bt.leftChild);
preorderPrint(bt.rightChild);
}
2016 Winter

• In inorder, the root is visited in the middle
• Here’s an inorder traversal to print out all the
elements in the binary tree:
public void inorderPrint(BinaryTree bt) {
inorderPrint(bt.leftChild);
inorderPrint(bt.rightChild);
}
2016 Winter

• In postorder, the root is visited last
• Here’s a postorder traversal to print out all
the elements in the binary tree:
public void postorderPrint(BinaryTree bt) {
postorderPrint(bt.leftChild);
postorderPrint(bt.rightChild);
}
2016 Winter

• The order in which the nodes are visited during a tree
traversal can be easily determined by imagining there
is a “flag” attached to each node, as follows:
• To traverse the tree, collect the flags:
preorder inorder postorder
A
B C
D E F G
A
B C
D E F G
A
B C
D E F G
A B D E C F G D B E A F C G D E B F G C A
2016 Winter

Following website offers a great animation on Binary Search Tree Construction
https://www.cs.usfca.edu/~galles/visualization/BST.html
25
3 37
1 19 48

Java Tutorial Lab 9

More Related Content

What's hot (20)

Viewers also liked (7)

Similar to Java Tutorial Lab 9 (20)

Recently uploaded (20)

Java Tutorial Lab 9