2002 Prentice Hall. All rights reserved. 1 Chapter 23 – Data Structures Outline 23.1 Introduction 23.2 Self-Referential Classes 23.3 Linked Lists 23.4.

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


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


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);


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


5


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)


6


Fig. 23.2 Two self-referential class objects linked together.

15 10


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


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


Outline10


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


Outline11


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


Outline12


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


Outline13


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


Outline14


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


Outline15


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


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


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


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


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)


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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



37

23.6.1 Binary Search Tree of Integer Values

– Postorder traversal• Get data from left child of node


• Get data from node

– Level-order traversal• Visit nodes of tree row by row, from left to right


38

23.6 Trees

Fig. 23.15 A graphical representation of a binary tree.

B

A D

C


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


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


Outline41


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


Outline42


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


Outline43


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


Outline44


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


Outline45


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


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


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


48

26.1 Binary Search Tree of Integer Values

Fig. 23.19 A binary search tree.

27

13 42

6 33 4817


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


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 }


Outline51


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


Outline52


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


Outline53


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


Outline54


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


Outline55


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 }


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


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


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


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


60

23.7 Collection Class

• Collection classes:– Prepackaged data structures

• Store collections of data

– Programmer uses already existing data structures


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


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


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


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 }


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


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.


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


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


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


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


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


Outline72

ArrayListTest.cs Program Output


Outline73

ArrayListTest.cs Program Output


74

23.25 Class Stack

• Implements stack data structure


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();


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


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


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


Outline79

StackTest.cs Program Output


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


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


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


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


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


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


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


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 }


Outline88

HashtableTest.cs Program Output

2002 Prentice Hall. All rights reserved. 1 Chapter 23 – Data Structures Outline 23.1 Introduction 23.2 Self-Referential Classes 23.3 Linked Lists 23.4.

Documents

class node

class listnode

class objects of linked

node class definition

class arraylist

class stack

class hashtable slide

prentice hall