2002 prentice hall. all rights reserved. 1 chapter 23 – data structures outline 23.1 introduction...
TRANSCRIPT
2002 Prentice Hall. All rights reserved.
1
Chapter 23 – Data Structures
Outline23.1 Introduction23.2 Self-Referential Classes23.3 Linked Lists23.4 Stacks23.5 Queues23.6 Trees
23.6.1 Binary Search Tree of Integer Values23.6.2 Binary Search Tree of IComparable Objects
23.7 Collection Classes23.7.1 Class Array23.7.2 Class ArrayList23.7.3 Class Stack23.7.4 Class Hashtable
2002 Prentice Hall. All rights reserved.
2
23.1 Introduction
• Dynamic data structures– Grow and shrink at execution time
– Linked Lists:• Lined up in a row
• Insertions and removals can occur anywhere in the list
– Stacks:• Insertions and removals only at top
– Queues:• Insertions made at back, removals from front
– Binary Trees:• Facilitate high-speed searching and sorting of data
• Efficient elimination of duplicate items
2002 Prentice Hall. All rights reserved.
3
23.2 Self-Referential Classes
• Contains a reference member to an object of the same class type– Reference can be used to link objects of the same type
together
• Dynamic data structures require dynamic memory allocation– Ability to obtain memory when needed and release memory
when it is not needed
– Uses new operator• Ex: Node nodeToAdd = new Node(10);
2002 Prentice Hall. All rights reserved.
4
23.2 Self-Referential Class
1 class Node
2 {
3 private int data;
4 private Node next;
5
6 public Node( int d )
7 {
8 /* constructor body */
9 }
10
11 public int Data
12 {
13 get
14 {
15 /* get body */
16 }
17
Fig. 23.1 Sample self-referential Node class definition (part 1)
Reference to object of same type
2002 Prentice Hall. All rights reserved.
5
23.2 Self-Referential Class
18 set
19 {
20 /* set body */
21 }
22 }
23 24 public Node Next25 {26 get27 {28 /* get body */29 }30 31 set32 {33 /* set body */34 }35 }36 }
Fig. 23.1 Sample self-referential Node class definition (part 2)
2002 Prentice Hall. All rights reserved.
6
23.2 Self-Referential Class
Fig. 23.2 Two self-referential class objects linked together.
15 10
2002 Prentice Hall. All rights reserved.
7
23.3 Linked Lists
• Linked List:– Linear collection of self-referential nodes connected by links
• Nodes: class objects of linked-lists
• Programs access linked lists through a reference to first node
– Subsequent nodes accessed by link-reference members
– Last node’s link set to null to indicate end of list
• Nodes can hold data of any type
• Nodes created dynamically
– Similar to arrays, however:• Arrays are a fixed size
• Linked lists have no limit to size
– More nodes can be added as program executes
2002 Prentice Hall. All rights reserved.
8
23.3 Linked Lists
Fig. 23.3 A graphical representation of a linked list.
H D …… Q
firstNode lastNode
2002 Prentice Hall.All rights reserved.
Outline9
LinkedListLibrary.cs
1 // Fig. 23.4: LinkedListLibrary.cs2 // Class ListNode and class List definitions.3 4 using System;5 6 namespace LinkedListLibrary7 {8 // class to represent one node in a list9 class ListNode10 {11 private object data;12 private ListNode next;13 14 // constructor to create ListNode that refers to dataValue15 // and is last node in list16 public ListNode( object dataValue ) 17 : this( dataValue, null )18 {19 }20 21 // constructor to create ListNode that refers to dataValue22 // and refers to next ListNode in List23 public ListNode( object dataValue, ListNode nextNode )24 {25 data = dataValue; 26 next = nextNode; 27 }28 29 // property Next30 public ListNode Next31 {32 get33 {34 return next;35 }
Reference to next ListNode in linked list
Accessor method so a List can access next member variable
Constructor for first item in list
Invoke normal constructor, which will set data to dataValue and next to null
Constructor to set data and next values to parameter values
2002 Prentice Hall.All rights reserved.
Outline10
LinkedListLibrary.cs
36 37 set38 {39 next = value;40 }41 }42 43 // property Data44 public object Data45 {46 get47 {48 return data;49 }50 } 51 52 } // end class ListNode53 54 // class List definition55 public class List56 {57 private ListNode firstNode;58 private ListNode lastNode;59 private string name; // string like "list" to display60 61 // construct empty List with specified name62 public List( string listName )63 {64 name = listName;65 firstNode = lastNode = null;66 }67
Accessor method so a List can access data member variable
Reference to first node in list
Reference to last node in list
Set reference to first and last nodes to null
2002 Prentice Hall.All rights reserved.
Outline11
LinkedListLibrary.cs
68 // construct empty List with "list" as its name69 public List() : this( "list" )70 { 71 }72 73 // Insert object at front of List. If List is empty, 74 // firstNode and lastNode will refer to same object.75 // Otherwise, firstNode refers to new node.76 public void InsertAtFront( object insertItem )77 {78 lock ( this )79 {80 if ( IsEmpty() )81 firstNode = lastNode = 82 new ListNode( insertItem );83 else84 firstNode = 85 new ListNode( insertItem, firstNode );86 }87 }88 89 // Insert object at end of List. If List is empty, 90 // firstNode and lastNode will refer to same object.91 // Otherwise, lastNode's Next property refers to new node.92 public void InsertAtBack( object insertItem )93 {94 lock ( this )95 {96 if ( IsEmpty() )97 firstNode = lastNode = 98 new ListNode( insertItem );99
Method to insert an object at the front of the list
Test if list is empty
Get list lock
If list is empty, create new node and set firstNode and lastNode to refer to it
If list is not empty, insert object by setting its next reference to the first node
Method to insert object into back of list
Get list lock
Test if list is empty
If list is empty create a new node and set firstNode and lastNode to reference it
2002 Prentice Hall.All rights reserved.
Outline12
LinkedListLibrary.cs
100 else101 lastNode = lastNode.Next = 102 new ListNode( insertItem );103 }104 }105 106 // remove first node from List107 public object RemoveFromFront()108 {109 lock ( this )110 {111 object removeItem = null;112 113 if ( IsEmpty() )114 throw new EmptyListException( name );115 116 removeItem = firstNode.Data; // retrieve data117 118 // reset firstNode and lastNode references119 if ( firstNode == lastNode )120 firstNode = lastNode = null;121 122 else 123 firstNode = firstNode.Next;124 125 return removeItem; // return removed data126 }127 }128 129 // remove last node from List130 public object RemoveFromBack()131 {132 lock ( this )133 {134 object removeItem = null;
If list is not empty, create a new node and set the last node’s next reference to the new node
Method to remove an object from the front of list
Get lock
Throw exception if list is empy
Set removeItem equal to data in first node
If there is only one node in the list, set firstNode and lastNode references to null
If there is more then one node, set firstNode to reference the second nodeReturn data stored
in node
Method to remove an object from the back of the list
2002 Prentice Hall.All rights reserved.
Outline13
LinkedListLibrary.cs
135 136 if ( IsEmpty() )137 throw new EmptyListException( name );138 139 removeItem = lastNode.Data; // retrieve data140 141 // reset firstNode and lastNode references142 if ( firstNode == lastNode )143 firstNode = lastNode = null;144 145 else 146 {147 ListNode current = firstNode;148 149 // loop while current node is not lastNode150 while ( current.Next != lastNode ) 151 current = current.Next; // move to next node152 153 // current is new lastNode154 lastNode = current;155 current.Next = null;156 }157 158 return removeItem; // return removed data159 }160 }161 162 // return true if List is empty163 public bool IsEmpty()164 {165 lock ( this )166 {167 return firstNode == null;168 }169 }
Set removeItem equal to the data in the last node
If there is only one node, set firstNode and lastNode to refer to null
Loop until next to last node is reached
Set lastNode to refer to the next to last node
Set reference of new last node to null
Return data of old last node
Method to test if list is empty
2002 Prentice Hall.All rights reserved.
Outline14
LinkedListLibrary.cs
170 171 // output List contents172 virtual public void Print()173 {174 lock ( this )175 {176 if ( IsEmpty() ) 177 {178 Console.WriteLine( "Empty " + name );179 return;180 }181 182 Console.Write( "The " + name + " is: " );183 184 ListNode current = firstNode;185 186 // output current node data while not at end of list187 while ( current != null ) 188 {189 Console.Write( current.Data + " " );190 current = current.Next;191 }192 193 Console.WriteLine( "\n" );194 }195 }196 197 } // end class List198
Method to output the list
Tell user if list is empty
Output data in list
2002 Prentice Hall.All rights reserved.
Outline15
LinkedListLibrary.cs
199 // class EmptyListException definition200 public class EmptyListException : ApplicationException201 {202 public EmptyListException( string name )203 : base( "The " + name + " is empty" )204 {205 }206 207 } // end class EmptyListException208 209 } // end namespace LinkedListLibrary
Handles illegal operations on an empty list
2002 Prentice Hall.All rights reserved.
Outline16
ListTest.cs
1 // Fig 23.5: ListTest.cs 2 // Testing class List.3 4 using System;5 using LinkedListLibrary;6 7 namespace ListTest8 {9 // class to test List class functionality10 class ListTest11 {12 static void Main( string[] args )13 { 14 List list = new List(); // create List container15 16 // create data to store in List17 bool aBoolean = true;18 char aCharacter = '$';19 int anInteger = 34567;20 string aString = "hello";21 22 // use List insert methods23 list.InsertAtFront( aBoolean );24 list.Print();25 list.InsertAtFront( aCharacter );26 list.Print();27 list.InsertAtBack( anInteger );28 list.Print();29 list.InsertAtBack( aString );30 list.Print();31 32 // use List remove methods33 object removedObject;34
Create list of objects
Insert objects at beginning of listinto list using InsertAtFront method
Insert objects at end of listinto list using InsertAtBack method
Print the list
Create data to put in list
2002 Prentice Hall.All rights reserved.
Outline17
ListTest.cs
35 // remove data from list and print after each removal36 try 37 {38 removedObject = list.RemoveFromFront();39 Console.WriteLine( removedObject + " removed" );40 list.Print();41 42 removedObject = list.RemoveFromFront();43 Console.WriteLine( removedObject + " removed" );44 list.Print();45 46 removedObject = list.RemoveFromBack();47 Console.WriteLine( removedObject + " removed" );48 list.Print();49 50 removedObject = list.RemoveFromBack();51 Console.WriteLine( removedObject + " removed" );52 list.Print();53 }54 55 // process exception if list empty when attempt is 56 // made to remove item57 catch ( EmptyListException emptyListException ) 58 {59 Console.Error.WriteLine( "\n" + emptyListException );60 } 61 62 } // end method Main63 64 } // end class ListTest65 }
Remove objects from front of list using method RemoveFromFront
Remove objects from back of list using method RemoveFromBack
Print the list after each remove
If remove is called on an empty list tell user
2002 Prentice Hall.All rights reserved.
Outline18
ListTest.cs Program Output
The list is: True The list is: $ True The list is: $ True 34567 The list is: $ True 34567 hello $ removedThe list is: True 34567 hello True removedThe list is: 34567 hello hello removedThe list is: 34567 34567 removedEmpty list
2002 Prentice Hall. All rights reserved.
19
23.3 Linked Lists
Fig. 23.6 A graphical representation of the InsertAtFront operation.
117
12
new ListNode
(a) firstNode
12
new ListNode
117
firstNode(b)
2002 Prentice Hall. All rights reserved.
20
23.3 Linked Lists
Fig. 23.7 A graphical representation of the InsertAtBack operation.
(a)
712
New ListNode
11 5
firstNode lastNode
7 11
firstNode New ListNode(b)
12 5
lastNode
2002 Prentice Hall. All rights reserved.
21
23.3 Linked Lists
Fig. 23.8 A graphical representation of the RemoveFromFront operation.
(a)
712
lastNode
11 5
firstNode
7 11
firstNode lastNode(b)
12 5
removeItem
2002 Prentice Hall. All rights reserved.
22
23.3 Linked Lists
Fig. 23.9 A graphical representation of the RemoveFromBack operation.
(a)
712
lastNode
11 5
firstNode
7 11
firstNode lastNode(b)
12 5
current
removeItem
2002 Prentice Hall. All rights reserved.
23
23.4 Stacks
• Special version of linked list:– Last-in, first-out (LIFO) data structure:
• Takes and releases new nodes only at top
• Operations:– Push: adds new node to top of stack
– Pop: removes top node from stack
• Can be used for:– Storing return addresses
– Storing local variables
2002 Prentice Hall.All rights reserved.
Outline24
StackInheritanceLibrary.cs
1 // Fig. 23.10: StackInheritanceLibrary.cs2 // Implementing a stack by inheriting from class List.3 4 using System;5 using LinkedListLibrary;6 7 namespace StackInheritanceLibrary8 {9 // class StackInheritance inherits class List's capabilities10 public class StackInheritance : List 11 {12 // pass name "stack" to List constructor13 public StackInheritance() : base( "stack" )14 {15 }16 17 // place dataValue at top of stack by inserting 18 // dataValue at front of linked list19 public void Push( object dataValue ) 20 { 21 InsertAtFront( dataValue ); 22 }23 24 // remove item from top of stack by removing25 // item at front of linked list26 public object Pop()27 { 28 return RemoveFromFront(); 29 }30 31 } // end class StackInheritance32 }
StackInheritance class is derived from List class
Call InsertAtFront method of List class to push objects
Call RemoveFromFront method of List class to pop objects
2002 Prentice Hall.All rights reserved.
Outline25
StackInheritanceTest.cs
1 // Fig. 23.11: StackInheritanceTest.cs2 // Testing class StackInheritance.3 4 using System;5 using StackInheritanceLibrary;6 using LinkedListLibrary;7 8 namespace StackInheritanceTest9 {10 // demonstrate functionality of class StackInheritance11 class StackInheritanceTest12 {13 static void Main( string[] args )14 {15 StackInheritance stack = new StackInheritance();16 17 // create objects to store in the stack18 bool aBoolean = true;19 char aCharacter = '$';20 int anInteger = 34567;21 string aString = "hello";22 23 // use method Push to add items to stack24 stack.Push( aBoolean );25 stack.Print();26 stack.Push( aCharacter );27 stack.Print();28 stack.Push( anInteger );29 stack.Print();30 stack.Push( aString );31 stack.Print();32 33 // use method Pop to remove items from stack34 object removedObject = null;35
Create stack
Create objects to store in stack
Push objects onto the stack
Print stack after each push
2002 Prentice Hall.All rights reserved.
Outline26
StackInheritanceTest.cs
36 // remove items from stack37 try 38 { 39 while ( true ) 40 {41 removedObject = stack.Pop();42 Console.WriteLine( removedObject + " popped" );43 stack.Print();44 }45 }46 47 // if exception occurs, print stack trace48 catch ( EmptyListException emptyListException ) 49 {50 Console.Error.WriteLine( 51 emptyListException.StackTrace );52 }53 54 } // end method Main55 56 } // end class StackInheritanceTest57 }
Remove objects from stack
Empty stack exception
2002 Prentice Hall.All rights reserved.
Outline27
StackInheritanceTest.cs Program Output
The stack is: True The stack is: $ True The stack is: 34567 $ True The stack is: hello 34567 $ True hello poppedThe stack is: 34567 $ True 34567 poppedThe stack is: $ True $ poppedThe stack is: True True poppedEmpty stack at LinkedListLibrary.List.RemoveFromFront() in z:\ch24\linkedlistlibrary\linkedlistlibrary.cs:line 114 at StackInheritanceLibrary.StackInheritance.Pop() in z:\ch24\stackinheritancelibrary\ stackinheritancelibrary.cs:line 28 at StackInheritanceTest.StackInheritanceTest.Main(String[] args in z:\ch24\fig24_11\stackinheritancetest.cs:line 41
2002 Prentice Hall.All rights reserved.
Outline28
StackCompositionLibrary.cs
1 // Fig. 23.12: StackCompositionLibrary.cs 2 // StackComposition definition with composed List object.3 4 using System;5 using LinkedListLibrary;6 7 namespace StackCompositionLibrary8 {9 // class StackComposition encapsulates List's capabilities10 public class StackComposition11 {12 private List stack;13 14 // construct empty stack15 public StackComposition()16 {17 stack = new List( "stack" );18 }19 20 // add object to stack21 public void Push( object dataValue ) 22 { 23 stack.InsertAtFront( dataValue ); 24 }25 26 // remove object from stack27 public object Pop()28 { 29 return stack.RemoveFromFront(); 30 }31
Create List object
Call method InsertAtFront to push
Use method RemoveFromFrontto pop
2002 Prentice Hall.All rights reserved.
Outline29
StackCompositionLibrary.cs
32 // determine whether stack is empty33 public bool IsEmpty()34 {35 return stack.IsEmpty();36 }37 38 // output stack contents39 public void Print()40 {41 stack.Print();42 }43 44 } // end class StackComposition 45 }
Call is empty to see if list has nodes
Call method Print for output
2002 Prentice Hall. All rights reserved.
30
23.5 Queues
• First-in, first-out (FIFO) data structure– Nodes removed from head, added to tail
• Operations:– Enqueue: insert node
– Dequeue: remove node
• Many computer applications:– Printer spooling
– Information packets on networks
2002 Prentice Hall.All rights reserved.
Outline31
QueueInheritanceLibrary.cs
1 // Fig. 23.13: QueueInheritanceLibrary.cs2 // Implementing a queue by inheriting from class List.3 4 using System;5 using LinkedListLibrary;6 7 namespace QueueInheritanceLibrary8 {9 // class QueueInheritance inherits List's capabilities10 public class QueueInheritance : List 11 {12 // pass name "queue" to List constructor13 public QueueInheritance() : base( "queue" )14 {15 }16 17 // place dataValue at end of queue by inserting 18 // dataValue at end of linked list19 public void Enqueue( object dataValue )20 {21 InsertAtBack( dataValue );22 }23 24 // remove item from front of queue by removing25 // item at front of linked list26 public object Dequeue( )27 { 28 return RemoveFromFront(); 29 }30 31 } // end of QueueInheritance32 }
Call InsertAtBack to enqueue
Call RemoveFromFront to dequeue
Class QueueInheritance derives from class List
2002 Prentice Hall.All rights reserved.
Outline32
QueueTest.cs
1 // Fig. 23.14: QueueTest.cs2 // Testing class QueueInheritance.3 4 using System;5 using QueueInheritanceLibrary;6 using LinkedListLibrary;7 8 namespace QueueTest9 {10 // demonstrate functionality of class QueueInheritance11 class QueueTest12 {13 static void Main( string[] args )14 {15 QueueInheritance queue = new QueueInheritance();16 17 // create objects to store in the stack18 bool aBoolean = true;19 char aCharacter = '$';20 int anInteger = 34567;21 string aString = "hello";22 23 // use method Enqueue to add items to queue24 queue.Enqueue( aBoolean );25 queue.Print();26 queue.Enqueue( aCharacter );27 queue.Print();28 queue.Enqueue( anInteger );29 queue.Print();30 queue.Enqueue( aString );31 queue.Print();32 33 // use method Dequeue to remove items from queue34 object removedObject = null;35
Create queue
Create objects to be inserted into queue
Enqueue objects
Print queue after each enqueue
2002 Prentice Hall.All rights reserved.
Outline33
QueueTest.cs
36 // remove items from queue37 try 38 {39 while ( true ) 40 {41 removedObject = queue.Dequeue();42 Console.WriteLine( removedObject + " dequeue" );43 queue.Print();44 }45 }46 47 // if exception occurs, print stack trace48 catch ( EmptyListException emptyListException ) 49 {50 Console.Error.WriteLine( 51 emptyListException.StackTrace );52 }53 54 } // end method Main55 56 } // end class QueueTest57 }
Dequeue objects
Print queue after each enqueue
2002 Prentice Hall.All rights reserved.
Outline34
QueueTest.cs Program Output
The queue is: True The queue is: True $ The queue is: True $ 34567 The queue is: True $ 34567 hello True dequeueThe queue is: $ 34567 hello $ dequeueThe queue is: 34567 hello 34567 dequeueThe queue is: hello hello dequeueEmpty queue at LinkedListLibrary.List.RemoveFromFront() in z:\ch24\linkedlistlibrary\linkedlistlibrary.cs:line 114 at QueueInheritanceLibrary.QueueInheritance.Dequeue() in z:\ch24\queueinheritancelibrary\ queueinheritancelibrary.cs:line 28 at QueueTest.QueueTest.Main(String[] args) in z:\ch24\fig24_13\queuetest.cs:line 41
2002 Prentice Hall. All rights reserved.
35
23.6 Trees
• Tree: non-linear, two-dimensional data sturcuture• Binary tree:
– Contain two links
– Root node: first node in a tree• Links refer to child nodes
– Node with no children is a leaf node
– Binary Search tree:• Values in left subtree are less than the value of the subtree’s
parent
• Values in right subtree are greater than the value of the subtree’s parent
2002 Prentice Hall. All rights reserved.
36
23.6.1 Binary Search Tree of Integer Values
• Traversal: method of retrieving data from a tree– In these methods if there is a subtree, recursively the
traversal is called recursively
– Inorder traversal:• Get data from left child of node
• Get data from node
• Get data from right child of node
– Preorder traversal:• Get data from node
• Get data from left child of node
• Get data from right child of node
2002 Prentice Hall. All rights reserved.
37
23.6.1 Binary Search Tree of Integer Values
– Postorder traversal• Get data from left child of node
• Get data from right child of node
• Get data from node
– Level-order traversal• Visit nodes of tree row by row, from left to right
2002 Prentice Hall. All rights reserved.
38
23.6 Trees
Fig. 23.15 A graphical representation of a binary tree.
B
A D
C
2002 Prentice Hall. All rights reserved.
39
23.6 Trees
Fig. 23.16 A binary search tree containing 12 values.
47
25 77
11
7 17
65 93
68
43
31 44
2002 Prentice Hall.All rights reserved.
Outline40
BinaryTreeLibrary.cs
1 // Fig. 23.17: BinaryTreeLibrary.cs2 // Definition of class TreeNode and class Tree.3 4 using System;5 6 namespace BinaryTreeLibrary7 {8 // class TreeNode definition9 class TreeNode 10 {11 private TreeNode leftNode; 12 private int data; 13 private TreeNode rightNode; 14 15 // initialize data and make this a leaf node16 public TreeNode( int nodeData )17 { 18 data = nodeData; 19 leftNode = rightNode = null; // node has no children20 }21 22 // LeftNode property23 public TreeNode LeftNode 24 {25 get 26 {27 return leftNode;28 }29 30 set31 {32 leftNode = value;33 }34 }35
Left and right subtree references
Data stored in node
Since new nodes are leaf, set subtree references to null
Accessor methods for left subtree
2002 Prentice Hall.All rights reserved.
Outline41
BinaryTreeLibrary.cs
36 // Data property37 public int Data38 {39 get 40 {41 return data;42 }43 44 set 45 {46 data = value;47 }48 }49 50 // RightNode property51 public TreeNode RightNode 52 {53 get 54 {55 return rightNode;56 }57 58 set59 {60 rightNode = value;61 }62 }63 64
Accessor methods for nodes data
Accessor methods for right subtree
2002 Prentice Hall.All rights reserved.
Outline42
BinaryTreeLibrary.cs
65 // insert TreeNode into Tree that contains nodes;66 // ignore duplicate values67 public void Insert( int insertValue )68 {69 // insert in left subtree70 if ( insertValue < data ) 71 {72 // insert new TreeNode73 if ( leftNode == null )74 leftNode = new TreeNode( insertValue );75 76 // continue traversing left subtree77 else78 leftNode.Insert( insertValue );79 }80 81 // insert in right subtree82 else if ( insertValue > data ) 83 {84 // insert new TreeNode85 if ( rightNode == null )86 rightNode = new TreeNode( insertValue );87 88 // continue traversing right subtree89 else90 rightNode.Insert( insertValue );91 }92 93 } // end method Insert94 95 } // end class TreeNode96
Method to determine location of new node
If value of new node is less than root, and the left subtree is empty, insert node as left child of root
If left subtree is not empty, recursively call Insert to determine location of new node in subtree
If value of new node is greater than root, and the right subtree is empty, insert node as right child of root
If right subtree is not empty, recursively call Insert to determine location of new node in subtree
2002 Prentice Hall.All rights reserved.
Outline43
BinaryTreeLibrary.cs
97 // class Tree definition98 public class Tree 99 {100 private TreeNode root;101 102 // construct an empty Tree of integers103 public Tree() 104 { 105 root = null; 106 }107 108 // Insert a new node in the binary search tree.109 // If the root node is null, create the root node here.110 // Otherwise, call the insert method of class TreeNode.111 public void InsertNode( int insertValue )112 {113 lock ( this ) 114 { 115 if ( root == null )116 root = new TreeNode( insertValue );117 118 else119 root.Insert( insertValue );120 }121 }122 123 // begin preorder traversal124 public void PreorderTraversal()125 { 126 lock ( this ) 127 {128 PreorderHelper( root ); 129 }130 }131
Reference to root of tree
Set root to null when tree first created
Method to insert a new node into tree
If tree is empty insert new node as root
If tree is not empty call Insert to determine location of new node
Perform preorder traversal
Call PreorderHelper to help perform traversal
2002 Prentice Hall.All rights reserved.
Outline44
BinaryTreeLibrary.cs
132 // recursive method to perform preorder traversal133 private void PreorderHelper( TreeNode node )134 {135 if ( node == null )136 return;137 138 // output node data139 Console.Write( node.Data + " " ); 140 141 // traverse left subtree142 PreorderHelper( node.LeftNode ); 143 144 // traverse right subtree145 PreorderHelper( node.RightNode ); 146 }147 148 // begin inorder traversal149 public void InorderTraversal()150 { 151 lock ( this ) 152 {153 InorderHelper( root ); 154 }155 }156 157 // recursive method to perform inorder traversal158 private void InorderHelper( TreeNode node )159 {160 if ( node == null )161 return;162 163 // traverse left subtree164 InorderHelper( node.LeftNode );165
Method to help with preorder traversal
Call PreorderHelper recursively on left subtree
Display node data
Call PreorderHelper recursively on right subtree
Perform inorder traversal
Call InorderHelper to help with traversal
Method to help with inorder traversal
Call InorderHelper recursively on left subtree
2002 Prentice Hall.All rights reserved.
Outline45
BinaryTreeLibrary.cs
166 // output node data167 Console.Write( node.Data + " " );168 169 // traverse right subtree170 InorderHelper( node.RightNode );171 }172 173 // begin postorder traversal174 public void PostorderTraversal()175 { 176 lock ( this ) 177 {178 PostorderHelper( root ); 179 }180 }181 182 // recursive method to perform postorder traversal183 private void PostorderHelper( TreeNode node )184 {185 if ( node == null )186 return;187 188 // traverse left subtree189 PostorderHelper( node.LeftNode );190 191 // traverse right subtree192 PostorderHelper( node.RightNode );193 194 // output node data195 Console.Write( node.Data + " " );196 }197 198 } // end class Tree199 }
Display node data
Call InorderHelper recursively on right subtree
Perform postorder traversal
Call PostorderHelper to help with traversal
Method to help with postorder traversal
Call PostorderHelper recursively on left subtree
Call PostorderHelper recursively on right subtree
Display node data
2002 Prentice Hall.All rights reserved.
Outline46
TreeTest.cs
1 // Fig. 23.18: TreeTest.cs2 // This program tests class Tree.3 4 using System;5 using BinaryTreeLibrary;6 7 namespace TreeTest8 {9 // class TreeTest definition10 public class TreeTest 11 {12 // test class Tree13 static void Main( string[] args )14 {15 Tree tree = new Tree();16 int insertValue;17 18 Console.WriteLine( "Inserting values: " );19 Random random = new Random();20 21 // insert 10 random integers from 0-99 in tree 22 for ( int i = 1; i <= 10; i++ ) 23 {24 insertValue = random.Next( 100 );25 Console.Write( insertValue + " " );26 27 tree.InsertNode( insertValue );28 }29 30 // perform preorder traveral of tree31 Console.WriteLine( "\n\nPreorder traversal" );32 tree.PreorderTraversal();33
Create a tree
Insert ten nodes in tree
Call preorder traversal
2002 Prentice Hall.All rights reserved.
Outline47
TreeTest.cs
Program Output
34 // perform inorder traveral of tree35 Console.WriteLine( "\n\nInorder traversal" );36 tree.InorderTraversal();37 38 // perform postorder traveral of tree39 Console.WriteLine( "\n\nPostorder traversal" );40 tree.PostorderTraversal();41 Console.WriteLine();42 }43 44 } // end class TreeTest45 }
Inserting values: 39 69 94 47 50 72 55 41 97 73 Preorder traversal39 69 47 41 50 55 94 72 73 97 Inorder traversal39 41 47 50 55 69 72 73 94 97 Postorder traversal41 55 50 47 73 72 97 94 69 39
Call inorder traversal
Call postorder traversal
2002 Prentice Hall. All rights reserved.
48
26.1 Binary Search Tree of Integer Values
Fig. 23.19 A binary search tree.
27
13 42
6 33 4817
2002 Prentice Hall. All rights reserved.
49
23.6.2 Binary Search Tree of Icomparable Objects
• Can use polymorphism to manipulate objects of different types in uniform ways– Binary search trees can be implemented to manipulate data
of any object that implements the Icomparable interface
2002 Prentice Hall.All rights reserved.
Outline50
BinaryTreeLibrary2.cs
1 // Fig. 23.20: BinaryTreeLibrary2.cs2 // Definition of class TreeNode and class Tree for IComparable3 // objects.4 5 using System;6 7 namespace BinaryTreeLibrary28 {9 // class TreeNode definition10 class TreeNode 11 {12 private TreeNode leftNode; 13 private IComparable data; 14 private TreeNode rightNode; 15 16 // initialize data and make this a leaf node17 public TreeNode( IComparable nodeData )18 { 19 data = nodeData; 20 leftNode = rightNode = null; // node has no children21 }22 23 // LeftNode property24 public TreeNode LeftNode 25 {26 get 27 {28 return leftNode;29 }30 31 set32 {33 leftNode = value;34 }35 }
2002 Prentice Hall.All rights reserved.
Outline51
BinaryTreeLibrary2.cs
36 37 // Data property38 public IComparable Data39 {40 get 41 {42 return data;43 }44 45 set 46 {47 data = value;48 }49 }50 51 // RightNode property52 public TreeNode RightNode 53 {54 get 55 {56 return rightNode;57 }58 59 set60 {61 rightNode = value;62 }63 }64
2002 Prentice Hall.All rights reserved.
Outline52
BinaryTreeLibrary2.cs
65 // insert TreeNode into Tree that contains nodes;66 // ignore duplicate values67 public void Insert( IComparable insertValue )68 {69 // insert in left subtree70 if ( insertValue.CompareTo( data ) < 0 ) 71 {72 // insert new TreeNode73 if ( leftNode == null )74 leftNode = new TreeNode( insertValue );75 76 // continue traversing left subtree77 else78 leftNode.Insert( insertValue );79 }80 81 // insert in right subtree82 else if ( insertValue.CompareTo( data ) > 0 ) 83 {84 // insert new TreeNode85 if ( rightNode == null )86 rightNode = new TreeNode( insertValue );87 88 // continue traversing right subtree89 else90 rightNode.Insert( insertValue );91 }92 93 } // end method Insert94 95 } // end class TreeNode96
Use Icomparable’s method CompareTo to determine if new node is less than its parent
Use Icomparable’s method CompareTo to determine if new node is greater than its parent
2002 Prentice Hall.All rights reserved.
Outline53
BinaryTreeLibrary2.cs
97 // class Tree definition98 public class Tree 99 {100 private TreeNode root;101 102 // construct an empty Tree of integers103 public Tree() 104 { 105 root = null; 106 }107 108 // Insert a new node in the binary search tree.109 // If the root node is null, create the root node here.110 // Otherwise, call the insert method of class TreeNode.111 public void InsertNode( IComparable insertValue )112 {113 lock ( this ) 114 { 115 if ( root == null )116 root = new TreeNode( insertValue );117 118 else119 root.Insert( insertValue );120 }121 }122 123 // begin preorder traversal124 public void PreorderTraversal()125 { 126 lock ( this ) 127 {128 PreorderHelper( root ); 129 }130 }131
2002 Prentice Hall.All rights reserved.
Outline54
BinaryTreeLibrary2.cs
132 // recursive method to perform preorder traversal133 private void PreorderHelper( TreeNode node )134 {135 if ( node == null )136 return;137 138 // output node data139 Console.Write( node.Data + " " ); 140 141 // traverse left subtree142 PreorderHelper( node.LeftNode ); 143 144 // traverse right subtree145 PreorderHelper( node.RightNode ); 146 }147 148 // begin inorder traversal149 public void InorderTraversal()150 { 151 lock ( this ) 152 {153 InorderHelper( root ); 154 }155 }156 157 // recursive method to perform inorder traversal158 private void InorderHelper( TreeNode node )159 {160 if ( node == null )161 return;162 163 // traverse left subtree164 InorderHelper( node.LeftNode );165
2002 Prentice Hall.All rights reserved.
Outline55
BinaryTreeLibrary2.cs
166 // output node data167 Console.Write( node.Data + " " );168 169 // traverse right subtree170 InorderHelper( node.RightNode );171 }172 173 // begin postorder traversal174 public void PostorderTraversal()175 { 176 lock ( this ) 177 {178 PostorderHelper( root ); 179 }180 }181 182 // recursive method to perform postorder traversal183 private void PostorderHelper( TreeNode node )184 {185 if ( node == null )186 return;187 188 // traverse left subtree189 PostorderHelper( node.LeftNode );190 191 // traverse right subtree192 PostorderHelper( node.RightNode );193 194 // output node data195 Console.Write( node.Data + " " );196 }197 198 } // end class Tree199 }
2002 Prentice Hall.All rights reserved.
Outline56
TreeTest.cs
1 // Fig. 23.21: TreeTest.cs2 // This program tests class Tree.3 4 using System;5 using BinaryTreeLibrary2;6 7 namespace TreeTest8 {9 // class TreeTest definition10 public class TreeTest 11 {12 // test class Tree13 static void Main( string[] args )14 {15 int[] intArray = { 8, 2, 4, 3, 1, 7, 5, 6 };16 double[] doubleArray = 17 { 8.8, 2.2, 4.4, 3.3, 1.1, 7.7, 5.5, 6.6 };18 string[] stringArray = { "eight", "two", "four", 19 "three", "one", "seven", "five", "six" };20 21 // create int Tree22 Tree intTree = new Tree();23 populateTree( intArray, intTree, "intTree" );24 traverseTree( intTree, "intTree" );25 26 // create double Tree27 Tree doubleTree = new Tree();28 populateTree( doubleArray, doubleTree, "doubleTree" );29 traverseTree( doubleTree, "doubleTree" );30 31 // create string Tree32 Tree stringTree = new Tree();33 populateTree( stringArray, stringTree, "stringTree" );34 traverseTree( stringTree, "stringTree" );35 }
Populate trees with int, double and string values
2002 Prentice Hall.All rights reserved.
Outline57
TreeTest.cs
36 37 // populate Tree with array elements38 static void populateTree( 39 Array array, Tree tree, string name )40 {41 Console.WriteLine( "\nInserting into " + name + ":" );42 43 foreach ( IComparable data in array ) 44 {45 Console.Write( data + " " );46 tree.InsertNode( data );47 }48 }49 50 // insert perform traversals51 static void traverseTree( Tree tree, string treeType )52 {53 // perform preorder traveral of tree54 Console.WriteLine( 55 "\n\nPreorder traversal of " + treeType );56 tree.PreorderTraversal();57 58 // perform inorder traveral of tree59 Console.WriteLine( 60 "\n\nInorder traversal of " + treeType );61 tree.InorderTraversal();62
Method to add data from arrays to trees
Insert nodes into tree
Method to traverse tree
Perform preorder traversal
Perform inorder traversal
2002 Prentice Hall.All rights reserved.
Outline58
TreeTest.cs
Program Output
63 // perform postorder traveral of tree64 Console.WriteLine( 65 "\n\nPostorder traversal of " + treeType );66 tree.PostorderTraversal();67 Console.WriteLine( "\n" );68 }69 70 } // end class TreeTest71 }
Inserting into intTree:8 2 4 3 1 7 5 6
Preorder traversal of intTree8 2 1 4 3 7 5 6
Inorder traversal of intTree1 2 3 4 5 6 7 8
Postorder traversal of intTree1 3 6 5 7 4 2 8
Perform postorder traversal
2002 Prentice Hall.All rights reserved.
Outline59
TreeTest.cs Program Output
Inserting into doubleTree:8.8 2.2 4.4 3.3 1.1 7.7 5.5 6.6 Preorder traversal of doubleTree8.8 2.2 1.1 4.4 3.3 7.7 5.5 6.6 Inorder traversal of doubleTree1.1 2.2 3.3 4.4 5.5 6.6 7.7 8.8 Postorder traversal of doubleTree1.1 3.3 6.6 5.5 7.7 4.4 2.2 8.8 Inserting into stringTree:eight two four three one seven five six Preorder traversal of stringTreeeight two four five three one seven six Inorder traversal of stringTreeeight five four one seven six three two Postorder traversal of stringTreefive six seven one three four two eight
2002 Prentice Hall. All rights reserved.
60
23.7 Collection Class
• Collection classes:– Prepackaged data structures
• Store collections of data
– Programmer uses already existing data structures
2002 Prentice Hall. All rights reserved.
61
23.7.1 Class Array
• Properties:– Length: returns length of array
– Reverse: can reverse elements of entire or part of an array
– Sort: sorts an array
– Copy: copies one array into another array
– BinarySearch: searches an array for a specified value
– Clear: removes all elements from an array
– CreateInstance: create a new array of a specified type
– LastIndexOf: returns index of last occurrence of an object
2002 Prentice Hall.All rights reserved.
Outline62
UsingArray.cs
1 // Fig. 23.22: UsingArray.cs2 // Using Array class to perform common array manipulations.3 4 using System;5 using System.Windows.Forms;6 using System.Collections;7 8 namespace UsingArray9 {10 // demonstrate algorithms of class Array11 class UsingArray12 {13 private int[] intValues = { 1, 2, 3, 4, 5, 6 };14 private double[] doubleValues = 15 { 8.4, 9.3, 0.2, 7.9, 3.4 };16 private int[] intValuesCopy;17 private string output; 18 19 // method to build and display program output20 public void Start()21 {22 intValuesCopy = new int[ intValues.Length ];23 24 output = "Initial array values:\n";25 PrintArray(); // output initial array contents26 27 // sort doubleValues28 Array.Sort( doubleValues );29 30 // copy intValues into intValuesCopy31 Array.Copy( intValues, intValuesCopy, 32 intValues.Length );33
Sort array in ascending order
Copy values from one array to another array
2002 Prentice Hall.All rights reserved.
Outline63
UsingArray.cs
34 output += "\nArray values after Sort and Copy:\n";35 PrintArray(); // output array contents36 output += "\n";37 38 // search for 5 in intValues39 int result = Array.BinarySearch( intValues, 5 );40 output += 41 ( result >= 0 ? "5 found at element " + result :42 "5 not found" ) + " in intValues\n";43 44 // search for 8763 in intValues45 result = Array.BinarySearch( intValues, 8763 );46 output += 47 ( result >= 0 ? "8763 found at element " + result :48 "8763 not found" ) + " in intValues";49 50 MessageBox.Show( output, "Using Class Array",51 MessageBoxButtons.OK, MessageBoxIcon.Information );52 }53 54 // append array content to output string55 private void PrintArray()56 {57 output += "doubleValues: ";58 59 foreach ( double element in doubleValues )60 output += element + " ";61 62 output += "\nintValues: ";63 64 foreach ( int element in intValues )65 output += element + " ";66 67 output += "\nintValuesCopy: ";68
Search sorted array for parameter passed
2002 Prentice Hall.All rights reserved.
Outline64
UsingArray.cs
Program Output
69 foreach ( int element in intValuesCopy )70 output += element + " ";71 72 output += "\n";73 }74 75 // main entry point for application76 static void Main( string[] args )77 {78 UsingArray application = new UsingArray();79 80 application.Start();81 }82 83 } // end class UsingArray84 }
2002 Prentice Hall. All rights reserved.
65
23.7.2 Class ArrayList
• Arrays have a fixed size• Provides functionality of array, but can be resized
dynamically• Property Capacity:
– Contains number of elements an array can hold
– Can be doubled if array needs to grow
2002 Prentice Hall. All rights reserved.
66
23.7.2 Class ArrayList
Method Description Add Adds an object to the ArrayList. Returns an int specifying the index at
which the object was added.
Clear Removes all the elements from the ArrayList.
Contains Returns true if the specified object is in the ArrayList; otherwise, returns false.
IndexOf Returns the index of the first occurrence of the specified object in the ArrayList.
Insert Inserts an object at the specified index.
Remove Removes the first occurrence of the specified object.
RemoveAt Removes an object at the specified index.
RemoveRange Removes a specified number of elements starting at a specified index in the ArrayList.
Sort Sorts the ArrayList.
TrimToSize Sets the Capacity of the ArrayList to be the number of elements the ArrayList currently contains.
Fig. 23.23 Some methods of class ArrayList.
2002 Prentice Hall.All rights reserved.
Outline67
ArrayListTest.cs
1 // Fig. 23.24: ArrayListTest.cs2 // Using class ArrayList.3 4 using System;5 using System.Drawing;6 using System.Collections;7 using System.ComponentModel;8 using System.Windows.Forms;9 using System.Data;10 using System.Text;11 12 namespace ArrayListTest13 {14 // demonstrating ArrayList functionality15 public class ArrayListTest : System.Windows.Forms.Form16 {17 private System.Windows.Forms.Button addButton;18 private System.Windows.Forms.TextBox inputTextBox;19 private System.Windows.Forms.Label inputLabel;20 private System.Windows.Forms.Button removeButton;21 private System.Windows.Forms.Button firstButton;22 private System.Windows.Forms.Button lastButton;23 private System.Windows.Forms.Button isEmptyButton;24 private System.Windows.Forms.Button containsButton;25 private System.Windows.Forms.Button locationButton;26 private System.Windows.Forms.Button trimButton;27 private System.Windows.Forms.Button statisticsButton;28 private System.Windows.Forms.Button displayButton;29 30 // Required designer variable.31 private System.ComponentModel.Container components = null;32 private System.Windows.Forms.TextBox consoleTextBox;33 34 // ArrayList for manipulating strings35 private ArrayList arrayList = new ArrayList( 1 );
Create an array list of one element
2002 Prentice Hall.All rights reserved.
Outline68
ArrayListTest.cs
36 37 public ArrayListTest()38 {39 // Required for Windows Form Designer support40 InitializeComponent();41 }42 43 // Visual Studio.NET generated code44 45 // main entry point for the application46 [STAThread]47 static void Main() 48 {49 Application.Run( new ArrayListTest() );50 }51 52 // add item to end of arrayList53 private void addButton_Click(54 object sender, System.EventArgs e )55 {56 arrayList.Add( inputTextBox.Text );57 consoleTextBox.Text = 58 "Added to end: " + inputTextBox.Text;59 inputTextBox.Clear();60 }61 62 // remove specified item from arrayList63 private void removeButton_Click(64 object sender, System.EventArgs e )65 {66 arrayList.Remove( inputTextBox.Text );67 consoleTextBox.Text = "Removed: " + inputTextBox.Text;68 inputTextBox.Clear();69 }70
Call method add to add an element to arrayList
Method to add an element to arrayList when user clicks add button
Method to remove an object when user clicks button
Call method remove to remove object
2002 Prentice Hall.All rights reserved.
Outline69
ArrayListTest.cs
71 // display first element72 private void firstButton_Click(73 object sender, System.EventArgs e )74 {75 // get first element76 try77 {78 consoleTextBox.Text = 79 "First element: " + arrayList[ 0 ];80 }81 82 // show exception if no elements in arrrayList83 catch ( ArgumentOutOfRangeException outOfRange )84 {85 consoleTextBox.Text = outOfRange.ToString();86 }87 }88 89 // display last element90 private void lastButton_Click(91 object sender, System.EventArgs e )92 {93 // get last element94 try95 {96 consoleTextBox.Text = "Last element: " + 97 arrayList[ arrayList.Count - 1 ];98 }99 100 // show exception if no elements in arrrayList101 catch ( ArgumentOutOfRangeException outOfRange )102 {103 consoleTextBox.Text = outOfRange.ToString();104 }105 }
Display last element when user clicks button
Get last element in arrayList
Display first element when user clicks button
2002 Prentice Hall.All rights reserved.
Outline70
ArrayListTest.cs
106 107 // determine whether arrayList is empty108 private void isEmptyButton_Click(109 object sender, System.EventArgs e )110 {111 consoleTextBox.Text = ( arrayList.Count == 0 ? 112 "arrayList is empty" : "arrayList is not empty" );113 }114 115 // determine whether arrayList contains specified object116 private void containsButton_Click(117 object sender, System.EventArgs e )118 {119 if ( arrayList.Contains( inputTextBox.Text ) )120 consoleTextBox.Text = "arrayList contains " +121 inputTextBox.Text;122 else123 consoleTextBox.Text = inputTextBox.Text + 124 " not found";125 }126 127 // determine location of specified object128 private void locationButton_Click(129 object sender, System.EventArgs e )130 {131 consoleTextBox.Text = "Element is at location " +132 arrayList.IndexOf( inputTextBox.Text );133 }134
Test if array is empty
Method to determine if object is in arrayList when user clicks button
Test if object is in arrayList
Method to determine index of specified object when user clicks button
Determine index of object
2002 Prentice Hall.All rights reserved.
Outline71
ArrayListTest.cs
135 // trim arrayList to current size136 private void trimButton_Click(137 object sender, System.EventArgs e )138 {139 arrayList.TrimToSize();140 consoleTextBox.Text = "Vector trimmed to size";141 }142 143 // show arrayList current size and capacity144 private void statisticsButton_Click(145 object sender, System.EventArgs e )146 {147 consoleTextBox.Text = "Size = " + arrayList.Count + 148 "; capacity = " + arrayList.Capacity;149 }150 151 // display contents of arrayList152 private void displayButton_Click(153 object sender, System.EventArgs e )154 {155 IEnumerator enumerator = arrayList.GetEnumerator();156 StringBuilder buffer = new StringBuilder();157 158 while ( enumerator.MoveNext() )159 buffer.Append( enumerator.Current + " " );160 161 consoleTextBox.Text = buffer.ToString();162 }163 }164 }
Method to reduce size to capacity when button clicked
Call TrimToSize to reduce size of arrayList to number of elements in arrayList
Display capacity and size or arrayList when button clicked
Method to display elements when button clicked
Create enumerator for traversal
Use enumerator to traverse arrayList and output contents to buffer
Display contents of buffer
2002 Prentice Hall.All rights reserved.
Outline72
ArrayListTest.cs Program Output
2002 Prentice Hall.All rights reserved.
Outline73
ArrayListTest.cs Program Output
2002 Prentice Hall. All rights reserved.
74
23.25 Class Stack
• Implements stack data structure
2002 Prentice Hall.All rights reserved.
Outline75
StackTest.cs
1 // Fig. 23.25: StackTest.cs2 // Demonstrates class Stack of namespace System.Collections.3 4 using System;5 using System.Drawing;6 using System.Collections;7 using System.ComponentModel;8 using System.Windows.Forms;9 using System.Data;10 using System.Text;11 12 namespace StackTest13 {14 // demonstrate Stack collection15 public class StackTest : System.Windows.Forms.Form16 {17 private System.Windows.Forms.Label inputLabel;18 private System.Windows.Forms.TextBox inputTextBox;19 private System.Windows.Forms.Button pushButton;20 private System.Windows.Forms.Button popButton;21 private System.Windows.Forms.Button peekButton;22 private System.Windows.Forms.Button isEmptyButton;23 private System.Windows.Forms.Button searchButton;24 private System.Windows.Forms.Button displayButton;25 private System.Windows.Forms.Label statusLabel;26 27 // Required designer variable.28 private System.ComponentModel.Container components = null;29 30 private Stack stack;31 32 public StackTest()33 {34 // Required for Windows Form Designer support35 InitializeComponent();
2002 Prentice Hall.All rights reserved.
Outline76
StackTest.cs
36 37 // create Stack38 stack = new Stack();39 }40 41 // Visual Studio.NET generated code42 43 // main entry point for the application44 [STAThread]45 static void Main() 46 {47 Application.Run( new StackTest() );48 }49 50 // push element onto stack51 private void pushButton_Click(52 object sender, System.EventArgs e )53 {54 stack.Push( inputTextBox.Text ); 55 statusLabel.Text = "Pushed: " + inputTextBox.Text;56 }57 58 // pop element from stack59 private void popButton_Click(60 object sender, System.EventArgs e )61 {62 // pop element63 try64 { 65 statusLabel.Text = "Popped: " + stack.Pop();66 }67
Create new stack
Insert specified object into stack when user clicks button
Invoke method push to insert object
Remove top element from stack when user clicks button
Call method pop to remove item
2002 Prentice Hall.All rights reserved.
Outline77
StackTest.cs
68 // print message if stack is empty69 catch ( InvalidOperationException invalidOperation )70 {71 statusLabel.Text = invalidOperation.ToString();72 }73 }74 75 // peek at top element of stack76 private void peekButton_Click(77 object sender, System.EventArgs e )78 {79 // view top element80 try81 { 82 statusLabel.Text = "Top: " + stack.Peek();83 }84 85 // print message if stack is empty86 catch ( InvalidOperationException invalidOperation )87 {88 statusLabel.Text = invalidOperation.ToString();89 }90 }91 92 // determine whether stack is empty93 private void isEmptyButton_Click(94 object sender, System.EventArgs e )95 {96 statusLabel.Text = ( stack.Count == 0 ? 97 "Stack is empty" : "Stack is not empty" );98 }99
Method to return top object in stack without returning it when user clicks button
Call method Peek to view top object
Method to test if stack is empty
Determine if stack is empty
2002 Prentice Hall.All rights reserved.
Outline78
StackTest.cs
100 // determine whether specified element is on stack101 private void searchButton_Click(102 object sender, System.EventArgs e )103 {104 string result = stack.Contains( inputTextBox.Text ) ? 105 " found" : " not found";106 107 statusLabel.Text = inputTextBox.Text + result;108 }109 110 // display stack contents111 private void displayButton_Click(112 object sender, System.EventArgs e )113 {114 IEnumerator enumerator = stack.GetEnumerator();115 StringBuilder buffer = new StringBuilder();116 117 // while the enumerator can move on to the next element118 // print that element out.119 while ( enumerator.MoveNext() )120 buffer.Append( enumerator.Current + " " );121 122 statusLabel.Text = buffer.ToString();123 }124 }125 }
Search stack for specified object
Determine if object is in stack
2002 Prentice Hall.All rights reserved.
Outline79
StackTest.cs Program Output
2002 Prentice Hall. All rights reserved.
80
23.7.4 Class Hashtable
• Hashing:– Convert a key into a subscript and store information at that
index of an array
– Use same key for retrieval of information
– Collisions:• When two different objects hash to the same subscript
– Can hash again
– Can store second object in next open cell
– Each cell can be a linked list that contains all objects that hash to its subscript
• Load factor: ratio of number of objects in hash table to the size of the hash table
2002 Prentice Hall. All rights reserved.
81
23.7.4 Class Hashtable
• Class Hashtable provides functionality of hash tables without knowing how they work
• Hash function: determines where to place data in a hash table
2002 Prentice Hall.All rights reserved.
Outline82
HashtableTest.cs
1 // Fig. 23.26: HashtableTest.cs2 // Demonstrate class Hashtable of namespace System.Collections.3 4 using System;5 using System.Drawing;6 using System.Collections;7 using System.ComponentModel;8 using System.Windows.Forms;9 using System.Data;10 using System.Text;11 12 namespace HashTableTest13 {14 // demonstrate Hashtable functionality15 public class HashTableTest : System.Windows.Forms.Form16 {17 private System.Windows.Forms.Label firstNameLabel;18 private System.Windows.Forms.Label lastNameLabel;19 private System.Windows.Forms.Button addButton;20 private System.Windows.Forms.TextBox lastNameTextBox;21 private System.Windows.Forms.TextBox consoleTextBox;22 private System.Windows.Forms.TextBox firstNameTextBox;23 private System.Windows.Forms.Button getButton;24 private System.Windows.Forms.Button removeButton;25 private System.Windows.Forms.Button emptyButton;26 private System.Windows.Forms.Button containsKeyButton;27 private System.Windows.Forms.Button clearTableButton;28 private System.Windows.Forms.Button listObjectsButton;29 private System.Windows.Forms.Button listKeysButton;30 private System.Windows.Forms.Label statusLabel;31 32 // Required designer variable.33 private System.ComponentModel.Container components = null;34
2002 Prentice Hall.All rights reserved.
Outline83
HashtableTest.cs
35 // Hashtable to demonstrate functionality36 private Hashtable table;37 38 public HashTableTest()39 {40 // Required for Windows Form Designer support41 InitializeComponent();42 43 // create Hashtable object44 table = new Hashtable();45 }46 47 // Visual Studio.NET generated code48 49 // main entry point for the application50 [STAThread]51 static void Main() 52 {53 Application.Run( new HashTableTest() );54 }55 56 // add last name and Employee object to table57 private void addButton_Click(58 object sender, System.EventArgs e )59 {60 Employee employee = new Employee( firstNameTextBox.Text,61 lastNameTextBox.Text );62 63 // add new key/value pair64 try65 {66 table.Add( lastNameTextBox.Text, employee );67 statusLabel.Text = "Put: " + employee.ToString();68 }69
Add new person to table when button clicked
Add employee object to the table using last name as a hash key
2002 Prentice Hall.All rights reserved.
Outline84
HashtableTest.cs
70 // if key is null or already in table, output message71 catch ( ArgumentException argumentException )72 {73 statusLabel.Text = argumentException.ToString();74 }75 }76 77 // get object for given key78 private void getButton_Click(79 object sender, System.EventArgs e )80 {81 object result = table[ lastNameTextBox.Text ];82 83 if ( result != null )84 statusLabel.Text = "Get: " + result.ToString();85 else86 statusLabel.Text = "Get: " + lastNameTextBox.Text +87 " not in table";88 }89 90 // remove key/value pair from table91 private void removeButton_Click(92 object sender, System.EventArgs e )93 {94 table.Remove( lastNameTextBox.Text );95 statusLabel.Text = "Object Removed";96 }97 98 // determine whether table is empty99 private void emptyButton_Click(100 object sender, System.EventArgs e )101 {102 statusLabel.Text = "Table is " + (103 table.Count == 0 ? "empty" : "not empty" );104 }
Method to get object associated with specified key when user clicks button
Retrieve object associated with key
Method to remove a specified key and object from the hash table
Remove object by invoking method Remove
Method to determine if table is empty when user clicks button
Determine if table is empty
2002 Prentice Hall.All rights reserved.
Outline85
HashtableTest.cs
105 106 // determine whether table contains specified key107 private void containsKeyButton_Click(108 object sender, System.EventArgs e )109 {110 statusLabel.Text = "Contains key: " + 111 table.ContainsKey( lastNameTextBox.Text );112 }113 114 // discard all table contents115 private void clearTableButton_Click(116 object sender, System.EventArgs e )117 {118 table.Clear();119 statusLabel.Text = "Clear: Table is now empty";120 }121 122 // display list of objects in table123 private void listObjectsButton_Click(124 object sender, System.EventArgs e )125 {126 IDictionaryEnumerator enumerator = 127 table.GetEnumerator();128 StringBuilder buffer = new StringBuilder();129 130 while ( enumerator.MoveNext() )131 buffer.Append( enumerator.Value + "\r\n" );132 133 consoleTextBox.Text = buffer.ToString();134 }135
When user clicks button, determine if specified key is in hash table
Invoke method ContainsKey to determine if key is in table
Delete all objects from table when user clicks
Use enumerator to output objects in hashtable
2002 Prentice Hall.All rights reserved.
Outline86
HashtableTest.cs
136 // display list of keys in table137 private void listKeysButton_Click(138 object sender, System.EventArgs e )139 {140 IDictionaryEnumerator enumerator = 141 table.GetEnumerator();142 StringBuilder buffer = new StringBuilder();143 144 while ( enumerator.MoveNext() )145 buffer.Append( enumerator.Key + "\r\n" );146 147 consoleTextBox.Text = buffer.ToString();148 }149 150 } // end class HashtableTest151 152 // class Employee for use with HashtableTest153 class Employee154 {155 private string first, last;156 157 // constructor158 public Employee( string fName, string lName )159 {160 first = fName;161 last = lName;162 }163
Use enumerator to display keys of hash table
2002 Prentice Hall.All rights reserved.
Outline87
HashtableTest.cs
Program Output
164 // return Employee first and last names as string165 public override string ToString()166 {167 return first + " " + last;168 }169 170 } // end class Employee171 }
2002 Prentice Hall.All rights reserved.
Outline88
HashtableTest.cs Program Output