Chapter 19 – Data Structures

Outline
19.1 Introduction
19.2 Self-Referential Classes
19.3 Dynamic Memory Allocation
19.4 Linked Lists
19.5 Stacks
19.6 Queues
19.7 Trees

 2002 Prentice Hall, Inc. All rights reserved.

 19.1 Introduction

• Dynamic data structures

– Grow and shrink at execution time
– Several types
• Linked lists
• Stacks
• Queues
• Binary trees

 2002 Prentice Hall, Inc. All rights reserved.

 19.2 Self-Referential Classes

• Self-referential class
– Contains instance variable referring to object of same class
class Node {
private int data;
private Node nextNode;
// constructors and methods ...
}
• Member nextNode is a link
– nextNode “links” a Node object to another Node object

 2002 Prentice Hall, Inc. All rights reserved.

 19.2 Self-Referential Classes (cont.)

15 10

Fig 19.1 Two self-referential class objects linked together.

 2002 Prentice Hall, Inc. All rights reserved.

 19.3 Dynamic Memory Allocation

• Dynamic memory allocation

– Obtain more memory at execution time to store new objects
• Operator new
– Release memory used by objects when no longer needed

 2002 Prentice Hall, Inc. All rights reserved.

 19.4 Linked Lists

• Linked list
– Linear collection of self-referential classes (nodes)
– Connected by reference links
– Nodes can be inserted and deleted anywhere in linked list
– Last node is set to null to mark end of list

 2002 Prentice Hall, Inc. All rights reserved.

 19.4 Linked Lists (cont.)

firstNode lastNode

H D ... Q

Fig 19.2 A graphical representation of a linked list.

 2002 Prentice Hall, Inc. All rights reserved.

1 // Fig. 19.3: List.java Outline
2 // Class ListNode and class List definitions
3 package com.deitel.jhtp4.ch19;
4
5 // class to represent one node in a list List.java
6 class ListNode {
7 Self-referential class
Lines 6-10
8 // package access members; List can access these directly ListNode contains data
9 Object data; and link to nextNode
10 ListNode nextNode;
11
12 // constructor to create a ListNode that refers to object
13 ListNode( Object object )
14 {
15 this( object, null );
16 }
17
18 // constructor to create ListNode that refers to Object
19 // and to next ListNode in List
20 ListNode( Object object, ListNode node )
21 {
22 data = object;
23 nextNode = node;
24 }
25
26 // return Object in this node
27 Object getObject()
28 {
29 return data;
30 }
31

 2002 Prentice Hall, Inc.

All rights reserved.
32 // get next node Outline
33 ListNode getNext()
34 {
35 return nextNode;
36 } List.java (Part 2)
37
38 } // end class ListNode Reference
Line to
42first
39
node in linked list
40 // class List definition
41 public class List { Line 43
42 private ListNode firstNode; Reference to last
43 private ListNode lastNode; node
44 private String name; // String like "list" used in printing Line in
50linked list
45
46 // construct an empty List with a name Lines 64-65
47 public List( String string )
48 {
49 name = string;
First and last nodes in
50 firstNode = lastNode = null;
51 } empty list are null
52
53 // construct empty List with "list" as the name
54 public List()
55 {
56 this( "list" );
57 }
58
59 // Insert Object at front of List. If List is empty,
If list is empty, the first and
60 // firstNode and lastNode will refer to same object.
61 // Otherwise, firstNode refers to new node. last node should refer to the
62 public synchronized void insertAtFront( Object insertItem ) newly inserted node
63 {
64 if ( isEmpty() )
65 firstNode = lastNode = new ListNode( insertItem );
66
 2002 Prentice Hall, Inc.
All rights reserved.
67 else Outline
68 firstNode = new ListNode( insertItem, firstNode );
69 }
If list is not empty, the first
70
71 // Insert Object at end of List. If List is empty, List.java
node should refer to(Part
the 3)
72 // firstNode and lastNode will refer to same Object. newly inserted node
73 // Otherwise, lastNode's nextNode refers to new node. Line 68
74 public synchronized void insertAtBack( Object insertItem )
75 {
76 if ( isEmpty() ) If list Lines 76-77
is empty, the first and
77 firstNode = lastNode = new ListNode( insertItem );
last node should refer to the
78
79 else Lines
newly 80-81 node
inserted
80 lastNode = lastNode.nextNode =
81 new ListNode( insertItem ); Lines 91-92 the last
82 }
If list is not empty,
83 node should refer to the
84 // remove first node from List newly inserted node
85 public synchronized Object removeFromFront()
86 throws EmptyListException
87 {
88 Object removeItem = null;
89
90 // throw exception if List is empty
91 if ( isEmpty() )
92 throw new EmptyListException( name );
If list is empty, removing a
93 node causes an exception
94 // retrieve data being removed
95 removeItem = firstNode.data;
96
97 // reset the firstNode and lastNode references
98 if ( firstNode == lastNode )
99 firstNode = lastNode = null;
100
 2002 Prentice Hall, Inc.
All rights reserved.
101 else Outline
102 firstNode = firstNode.nextNode;
103
104 // return removed node data
105 return removeItem; List.java (Part 4)
106 }
107 Line 102
108 // Remove last node from List
109 public synchronized Object removeFromBack()
110 throws EmptyListException Lines 131-137
111 {
112 Object removeItem = null;
113
114 // throw exception if List is empty
115 if ( isEmpty() )
116 throw new EmptyListException( name );
If list is empty, removing a
117 node causes an exception
118 // retrieve data being removed
119 removeItem = lastNode.data;
120
121 // reset firstNode and lastNode references
122 if ( firstNode == lastNode )
123 firstNode = lastNode = null;
124
125 else {
126
127 // locate new last node
128 ListNode current = firstNode;
129
130 // loop while current node does not refer to lastNode
131 while ( current.nextNode != lastNode )
132 current = current.nextNode; If list is notempty, the second-to-last
133
node becomes the last node
 2002 Prentice Hall, Inc.
All rights reserved.
134 // current is new lastNode Outline
135 lastNode = current;
136 current.nextNode = null;
137 }
138 List.java (Part 5)
139 // return removed node data
140 return removeItem; Lines 162-165
141 }
142
143 // return true if List is empty
144 public synchronized boolean isEmpty()
145 {
146 return firstNode == null;
147 }
148
149 // output List contents
150 public synchronized void print()
151 {
152 if ( isEmpty() ) {
153 System.out.println( "Empty " + name );
154 return;
155 }
156
157 System.out.print( "The " + name + " is: " );
158 Traverse list and print node values
159 ListNode current = firstNode;
160
161 // while not at end of list, output current node's data
162 while ( current != null ) {
163 System.out.print( current.data.toString() + " " );
164 current = current.nextNode;
165 }
166
 2002 Prentice Hall, Inc.
All rights reserved.
167 System.out.println( "\n" ); Outline
168 }
169
170 } // end class List
167 System.out.println( "\n" ); List.java (Part 6)
168 }
169
170 } // end class List

 2002 Prentice Hall, Inc.

All rights reserved.
1 // Fig. 19.4: EmptyListException.java Outline
2 // Class EmptyListException definition
3 package com.deitel.jhtp4.ch19;
4
5 public class EmptyListException extends RuntimeException { EmptyListExcepti
6 on.java
7 // initialize an EmptyListException
8 public EmptyListException( String name )
9 { Lines 5-13
Exception thrown when
10 super( "The " + name + " is empty" );
11 } program attempts to remove
12 node from empty list
13 } // end class EmptyListException

 2002 Prentice Hall, Inc.

All rights reserved.
1 // Fig. 19.5: ListTest.java Outline
2 // Class ListTest
3
4 // Deitel packages
5 import com.deitel.jhtp4.ch19.List; ListTest.java
6 import com.deitel.jhtp4.ch19.EmptyListException;
7 Line 13
8 public class ListTest {
9
10 // test class List Lines
Create linked list 16-19
11 public static void main( String args[] )
12 {
13 List list = new List(); // create the List container Lines 22-29
14
15 // create objects to store in List
16 Boolean bool = Boolean.TRUE; Create values
17 Character character = new Character( '$' ); (Objects) to store
18 Integer integer = new Integer( 34567 );
19 String string = "hello";
in linked-list nodes
20
21 // use List insert methods
22 list.insertAtFront( bool );
23 list.print();
24 list.insertAtFront( character );
25 list.print();
26 list.insertAtBack( integer ); Insert values in linked list
27 list.print();
28 list.insertAtBack( string );
29 list.print();
30
31 // use List remove methods
32 Object removedObject;
33
 2002 Prentice Hall, Inc.
All rights reserved.
34 // remove objects from list; print after each removal Outline
35 try {
36 removedObject = list.removeFromFront();
37 System.out.println(
38 removedObject.toString() + " removed" ); ListTest.java
39 list.print(); (Part 2)
40
41 removedObject = list.removeFromFront();
42 System.out.println( Lines 36-54
43 removedObject.toString() + " removed" );
44 list.print(); Remove values
45 from linked list
46 removedObject = list.removeFromBack();
47 System.out.println(
48 removedObject.toString() + " removed" );
49 list.print();
50
51 removedObject = list.removeFromBack();
52 System.out.println(
53 removedObject.toString() + " removed" );
54 list.print();
55 }
56
57 // process exception if List is empty when attempt is
58 // made to remove an item
59 catch ( EmptyListException emptyListException ) {
60 emptyListException.printStackTrace();
61 }
62
63 } // end method main
64
65 } // end class ListTest

 2002 Prentice Hall, Inc.

All rights reserved.
The list is: true Outline
The list is: $ true
ListTest.java
The list is: $ true 34567
(Part 3)
The list is: $ true 34567 hello
Program Output
$ removed
The list is: true 34567 hello

true removed
The list is: 34567 hello

hello removed
The list is: 34567

34567 removed
Empty list

 2002 Prentice Hall, Inc.

All rights reserved.
 19.4 Linked Lists (cont.)

(a) firstNode
7 11
new ListNode
12
(b) firstNode
7 11
new ListNode
12

Fig 19.6 The insertAtFront operation.

 2002 Prentice Hall, Inc. All rights reserved.

 19.4 Linked Lists (cont.)
(a) firstNode lastNode new ListNode

12 7 11 5

(b) firstNode lastNode new ListNode

12 7 11 5

Fig 19.7 A graphical representation of the insertAtBack operation.

 2002 Prentice Hall, Inc. All rights reserved.

 19.4 Linked Lists (cont.)
(a) firstNode lastNode

12 7 11 5
(b) firstNode lastNode

12 7 11 5

removeItem
Fig 19.8 A graphical representation of the removeFromFront operation.

 2002 Prentice Hall, Inc. All rights reserved.

 19.4 Linked Lists (cont.)
(a) firstNode lastNode

12 7 11 5
(b) firstNode current lastNode

12 7 11 5

removeItem
Fig 19.9 A graphical representation of the removeFromBack operation.

 2002 Prentice Hall, Inc. All rights reserved.

 19.5 Stacks

• Stack
– Constrained version of a linked list
• Add and remove nodes only to and from the top of the stack
– Push method adds node to top of stack
– Pop method removes node from top of stack

 2002 Prentice Hall, Inc. All rights reserved.

1 // Fig. 19.10: StackInheritance.java Outline
2 // Derived from class List
3 package com.deitel.jhtp4.ch19;
4 StackInheritance inherits
5 public class StackInheritance extends List { StackInheritance
from List, because a stack is a
6 .java
constrained version of a linked list
7 // construct stack
8 public StackInheritance()
9 { Line 5
10 super( "stack" );
11 } Lines 14-17
12
13 // add object to stack Method push adds
14 public synchronized void push( Object object ) Lines 20-23
15 { node to top of stack
16 insertAtFront( object );
17 }
18
19 // remove object from stack Method pop removes
20 public synchronized Object pop() throws EmptyListException
21 { node from top of stack
22 return removeFromFront();
23 }
24
25 } // end class StackInheritance

 2002 Prentice Hall, Inc.

All rights reserved.
1 // Fig. 19.11: StackInheritanceTest.java Outline
2 // Class StackInheritanceTest
3
4 // Deitel packages
5 import com.deitel.jhtp4.ch19.StackInheritance; StackInheritance
6 import com.deitel.jhtp4.ch19.EmptyListException; Test.java
7
8 public class StackInheritanceTest {
9 Line 13
10 // test class StackInheritance Create stack
11 public static void main( String args[] ) Lines 16-19
12 {
13 StackInheritance stack = new StackInheritance();
14 Lines 22-29
15 // create objects to store in the stack
16 Boolean bool = Boolean.TRUE;
17 Character character = new Character( '$' ); Create values (Objects)
18 Integer integer = new Integer( 34567 ); to store in stack
19 String string = "hello";
20
21 // use push method
22 stack.push( bool );
23 stack.print();
24 stack.push( character );
25 stack.print();
26 stack.push( integer ); Insert values in stack
27 stack.print();
28 stack.push( string );
29 stack.print();
30
31 // remove items from stack
32 try {
33
34 // use pop method
35 Object removedObject = null;
 2002 Prentice Hall, Inc.
All rights reserved.
36 Outline
37 while ( true ) {
38 removedObject = stack.pop(); Remove value from stack
39 System.out.println( removedObject.toString() +
40 " popped" ); StackInheritance
41 stack.print(); Test.java
42 } (Part 2)
43 }
44
45 // catch exception if stack empty when item popped Line 38
46 catch ( EmptyListException emptyListException ) {
47 emptyListException.printStackTrace();
48 }
49
50 } // end method main
51
52 } // end class StackInheritanceTest

 2002 Prentice Hall, Inc.

All rights reserved.
 Outline
The stack is: true
StackInheritance
The stack is: $ true Test.java
(Part 3)
The stack is: 34567 $ true

The stack is: hello 34567 $ true Program Output

hello popped
The stack is: 34567 $ true

34567 popped
The stack is: $ true

$ popped
The stack is: true

true popped
Empty stack
com.deitel.jhtp4.ch19.EmptyListException: The stack is empty
at com.deitel.jhtp4.ch19.List.removeFromFront(List.java:92)
at com.deitel.jhtp4.ch19.StackInheritance.pop(
StackInheritance.java:22)
at StackInheritanceTest.main(StackInheritanceTest.java:38)

 2002 Prentice Hall, Inc.

All rights reserved.
1 // Fig. 19.12: StackComposition.java Outline
2 // Class StackComposition definition with composed List object
3 package com.deitel.jhtp4.ch19;
4
5 public class StackComposition { StackComposition
6 private List stackList;
Demonstrate how to create .java
7 stack via composition
8 // construct stack
9 public StackComposition() Lines 5-6
10 {
11 stackList = new List( "stack" ); Lines 15-18
12 }
13
14 // add object to stack Lines 21-24
15 public synchronized void push( Object object ) Method push adds
16 { node to top of stack
17 stackList.insertAtFront( object );
18 }
19
20 // remove object from stack
Method pop removes
21 public synchronized Object pop() throws EmptyListException
22 { node from top of stack
23 return stackList.removeFromFront();
24 }
25
26 // determine if stack is empty
27 public synchronized boolean isEmpty()
28 {
29 return stackList.isEmpty();
30 }
31

 2002 Prentice Hall, Inc.

All rights reserved.
32 // output stack contents Outline
33 public synchronized void print()
34 {
35 stackList.print();
36 } StackComposition
37 .java (Part 2)
38 } // end class StackComposition

 2002 Prentice Hall, Inc.

All rights reserved.
 19.6 Queues

• Queue
– Similar to a supermarket checkout line
– Nodes inserted only at tail (back)
• Method enqueue
– Nodes removed only from head (front)
• Method dequeue

 2002 Prentice Hall, Inc. All rights reserved.

1 // Fig. 19.13: QueueInheritance.java Outline
2 // Class QueueInheritance extends class List
3
4 // Deitel packages
5 package com.deitel.jhtp4.ch19; QueueInheritance
6 .java
7 public class QueueInheritance extends List {
8
9 // construct queue Lines 16-19
10 public QueueInheritance()
11 { Lines 22-25
12 super( "queue" );
13 }
14
15 // add object to queue
Method enqueue adds
16 public synchronized void enqueue( Object object )
17 { node to top of stack
18 insertAtBack( object );
19 }
20
21 // remove object from queue Method dequeue
22 public synchronized Object dequeue() throws EmptyListException removes node from
23 {
24 return removeFromFront(); top of stack
25 }
26
27 } // end class QueueInheritance

 2002 Prentice Hall, Inc.

All rights reserved.
1 // Fig. 19.14: QueueInheritanceTest.java Outline
2 // Class QueueInheritanceTest
3
4 // Deitel packages
5 import com.deitel.jhtp4.ch19.QueueInheritance; QueueInheritance
6 import com.deitel.jhtp4.ch19.EmptyListException; Test.java
7
8 public class QueueInheritanceTest {
9 Line 13
10 // test class QueueInheritance Create queue
11 public static void main( String args[] ) Lines 16-19
12 {
13 QueueInheritance queue = new QueueInheritance();
14 Lines 22-29
15 // create objects to store in queue
16 Boolean bool = Boolean.TRUE;
17 Character character = new Character( '$' ); Create values (Objects)
18 Integer integer = new Integer( 34567 ); to store in queue
19 String string = "hello";
20
21 // use enqueue method
22 queue.enqueue( bool );
23 queue.print();
24 queue.enqueue( character );
25 queue.print();
26 queue.enqueue( integer ); Insert values in queue
27 queue.print();
28 queue.enqueue( string );
29 queue.print();
30
31 // remove objects from queue
32 try {
33
34 // use dequeue method
35 Object removedObject = null;
 2002 Prentice Hall, Inc.
All rights reserved.
36 Outline
37 while ( true ) {
38 removedObject = queue.dequeue(); Remove value from queue
39 System.out.println( removedObject.toString() +
40 " dequeued" ); QueueInheritance
41 queue.print(); Test.java (Part 2)
42 }
43 }
44 Line 38
45 // process exception if queue empty when item removed
46 catch ( EmptyListException emptyListException ) {
47 emptyListException.printStackTrace();
48 }
49
50 } // end method main
51
52 } // end class QueueInheritanceTest

The queue is: true

The queue is: true $

The queue is: true $ 34567

The queue is: true $ 34567 hello

true dequeued
The queue is: $ 34567 hello

 2002 Prentice Hall, Inc.

All rights reserved.
 Outline
$ dequeued
The queue is: 34567 hello
QueueInheritance
Test.java (Part 3)
34567 dequeued
The queue is: hello

hello dequeued
Empty queue

com.deitel.jhtp4.ch19.EmptyListException: The queue is empty

at com.deitel.jhtp4.ch19.List.removeFromFront(List.java:92)
at com.deitel.jhtp4.ch19.QueueInheritance.dequeue(
QueueInheritance.java:24)
at QueueInheritanceTest.main(QueueInheritanceTest.java:38)

 2002 Prentice Hall, Inc.

All rights reserved.
 19.7 Trees

• Tree
– Non-linear, two-dimensional data structure
• (unlike linked lists, stacks and queues)
– Nodes contain two or more links
– Root node is the first node
– Each link refers to a child
• Left child is the first node in left subtree
• Right child is the first node in right subtree
• Children of a specific node is siblings
• Nodes with no children are leaf nodes

 2002 Prentice Hall, Inc. All rights reserved.

 19.7 Trees (cont.)

• Binary search tree

– Special ordering of nodes
• Values in left subtrees are less than values in right subtrees
– Inorder traversal
• Traverse left subtree, obtain node value, traverse right subtree
– Preorder traversal
• Obtain node value, traverse left subtree, traverse right subtree
– Postorder traversal
• Traverse left subtree, traverse right subtree, obtain node value

 2002 Prentice Hall, Inc. All rights reserved.

 19.7 Trees (cont.)

A D

Fig 19.15 A graphical representation of a binary tree.

 2002 Prentice Hall, Inc. All rights reserved.

 19.7 Trees (cont.)

47

25 77
11 43 65 93
7 17 31 44 68

Fig 19.16 A binary search tree containing 12 values.

 2002 Prentice Hall, Inc. All rights reserved.

1 // Fig. 19.17: Tree.java Outline
2 // Definition of class TreeNode and class Tree.
3
4 // Deitel packages
5 package com.deitel.jhtp4.ch19; Tree.java
6
7 // class TreeNode definition Lines 11-13
8 class TreeNode {
9
10 // package access members Lines 27-35
11 TreeNode leftNode;
12 int data; Left and right children
13 TreeNode rightNode;
14
15 // initialize data and make this a leaf node
16 public TreeNode( int nodeData )
17 {
18 data = nodeData;
19 leftNode = rightNode = null; // node has no children
20 }
21
22 // insert TreeNode into Tree that contains nodes;
23 // ignore duplicate values
24 public synchronized void insert( int insertValue )
25 {
26 // insert in left subtree
27 if ( insertValue < data ) { If value of inserted
28
29 // insert new TreeNode
node is less than value
30 if ( leftNode == null ) of tree node, insert
31 leftNode = new TreeNode( insertValue ); node in left subtree
32
33 // continue traversing left subtree
34 else
35 leftNode.insert( insertValue );
 2002 Prentice Hall, Inc.
All rights reserved.
37 Outline
38 // insert in right subtree
39 else if ( insertValue > data ) {
40
41 // insert new TreeNode If value Tree.java (Part 2)
of inserted node
42 if ( rightNode == null )
is greater than value of
43 rightNode = new TreeNode( insertValue ); Lines 39-48
44 tree node, insert node in
45 // continue traversing right subtree right subtree
46 else
47 rightNode.insert( insertValue );
48 }
49
50 } // end method insert
51
52 } // end class TreeNode
53
54 // class Tree definition
55 public class Tree {
56 private TreeNode root;
57
58 // construct an empty Tree of integers
59 public Tree()
60 {
61 root = null;
62 }
63
64 // Insert a new node in the binary search tree.
65 // If the root node is null, create the root node here.
66 // Otherwise, call the insert method of class TreeNode.
67 public synchronized void insertNode( int insertValue )
68 {
69 if ( root == null )
70 root = new TreeNode( insertValue );
 2002 Prentice Hall, Inc.
All rights reserved.
71 Outline
72 else
73 root.insert( insertValue );
74 }
75 Tree.java (Part 3)
76 // begin preorder traversal
77 public synchronized void preorderTraversal() Lines 83-96
78 {
79 preorderHelper( root );
80 }
81
82 // recursive method to perform preorder traversal
83 private void preorderHelper( TreeNode node )
84 {
85 if ( node == null )
86 return;
87
88 // output node data
89 System.out.print( node.data + " " );
90
91 // traverse left subtree
Preorder traversal – obtain
92 preorderHelper( node.leftNode ); data, traverse left subtree,
93 then traverse right subtree
94 // traverse right subtree
95 preorderHelper( node.rightNode );
96 }
97
98 // begin inorder traversal
99 public synchronized void inorderTraversal()
100 {
101 inorderHelper( root );
102 }
103
 2002 Prentice Hall, Inc.
All rights reserved.
104 // recursive method to perform inorder traversal Outline
105 private void inorderHelper( TreeNode node )
106 {
107 if ( node == null )
108 return; Tree.java (Part 4)
109
110 // traverse left subtree Lines 105-118
111 inorderHelper( node.leftNode );
112
113 // output node data Inorder traversal – traverse
Lines 127-140
114 System.out.print( node.data + " " ); left subtree, obtain data, then
115 traverse right subtree
116 // traverse right subtree
117 inorderHelper( node.rightNode );
118 }
119
120 // begin postorder traversal
121 public synchronized void postorderTraversal()
122 {
123 postorderHelper( root );
124 }
125
126 // recursive method to perform postorder traversal
127 private void postorderHelper( TreeNode node )
128 {
129 if ( node == null )
130 return;
131
132 // traverse left subtree
133 postorderHelper( node.leftNode );
134 Postorder traversal – traverse
135 // traverse right subtree
136 postorderHelper( node.rightNode ); left subtree, traverse right
137 subtree, then obtain data
 2002 Prentice Hall, Inc.
All rights reserved.
138 // output node data Outline
139 System.out.print( node.data + " " );
140 }
141
142 } // end class Tree Tree.java (Part 5)

 2002 Prentice Hall, Inc.

All rights reserved.
1 // Fig. 19.18: TreeTest.java Outline
2 // This program tests class Tree.
3 import com.deitel.jhtp4.ch19.Tree;
4
5 // Class TreeTest definition TreeTest.java
6 public class TreeTest {
7 Lines 17-22
8 // test class Tree
9 public static void main( String args[] )
10 { Line 26
11 Tree tree = new Tree();
12 int value;
13 Line 30
14 System.out.println( "Inserting the following values: " );
15
16 // insert 10 random integers from 0-99 in tree
17 for ( int i = 1; i <= 10; i++ ) { Insert 10 random
18 value = ( int ) ( Math.random() * 100 );
19 System.out.print( value + " " );
integers in tree
20
21 tree.insertNode( value );
22 }
23
24 // perform preorder traveral of tree
25 System.out.println ( "\n\nPreorder traversal" );
26 tree.preorderTraversal();
Traverse binary tree via
27 preorder algorithm
28 // perform inorder traveral of tree
29 System.out.println ( "\n\nInorder traversal" ); Traverse binary tree via
30 tree.inorderTraversal();
31 inorder algorithm

 2002 Prentice Hall, Inc.

All rights reserved.
32 // perform postorder traveral of tree Outline
33 System.out.println ( "\n\nPostorder traversal" );
34 tree.postorderTraversal(); Traverse binary tree via
35 System.out.println(); postorder algorithm
36 } TreeTest.java
37 (Part 2)
38 } // end class TreeTest

Line 34
Inserting the following values:
39 69 94 47 50 72 55 41 97 73

Preorder traversal
39 69 47 41 50 55 94 72 73 97

Inorder traversal
39 41 47 50 55 69 72 73 94 97

Postorder traversal
41 55 50 47 73 72 97 94 69 39

 2002 Prentice Hall, Inc.

All rights reserved.
 19.7 Trees (cont.)

27

13 42
6 17 33 48

Fig 19.19 A binary search tree.

 2002 Prentice Hall, Inc. All rights reserved.