2000 Deitel & Associates, Inc. All rights reserved. 2000 Deitel & Associates, Inc. All rights reserved. Chapter 15 – Data Structures Outline 15.1 Introduction 15.2 Self-Referential Classes 15.3 Dynamic Memory Allocation 15.4 Linked Lists 15.5 Stacks 15.6 Queues 15.7 Trees
39
Embed
2000 Deitel & Associates, Inc. All rights reserved. Chapter 15 – Data Structures Outline 15.1Introduction 15.2Self-Referential Classes 15.3Dynamic Memory.
This document is posted to help you gain knowledge. Please leave a comment to let me know what you think about it! Share it to your friends and learn new things together.
Transcript
2000 Deitel & Associates, Inc. All rights reserved. 2000 Deitel & Associates, Inc. All rights reserved.
Chapter 15 – Data Structures
Outline
15.1 Introduction
15.2 Self-Referential Classes
15.3 Dynamic Memory Allocation
15.4 Linked Lists
15.5 Stacks
15.6 Queues
15.7 Trees
2000 Deitel & Associates, Inc. All rights reserved. 2000 Deitel & Associates, Inc. All rights reserved.
15.1 Introduction
• dynamic data structures - grow and shrink during execution
• Linked lists - insertions and removals made anywhere
• Stacks - insertions and removals made only at top of stack
• Queues - insertions made at the back and removals made
from the front
• Binary trees - high-speed searching and sorting of data and efficient elimination of duplicate data items
2000 Deitel & Associates, Inc. All rights reserved. 2000 Deitel & Associates, Inc. All rights reserved.
15.2 Self-Referential Classes
• self-referential class– class that contains a pointer to a class object of the same type
– can be linked together to form useful data structures such as lists, queues, stacks and trees
– terminated with a NULL pointer (0)
• Two self-referential class objects linked together
1015
NULL pointer (points to nothing)Data member and pointer
2000 Deitel & Associates, Inc. All rights reserved. 2000 Deitel & Associates, Inc. All rights reserved.
15.2 Self-Referential Classes (II)
class Node { public: Node( int ); void setData( int ); int getData() const; void setNextPtr( Node * ); const Node *getNextPtr() const;private: int data; Node *nextPtr;};
• nextPtr - points to an object of type Node
– referred to as a link – ties one Node to another Node
2000 Deitel & Associates, Inc. All rights reserved. 2000 Deitel & Associates, Inc. All rights reserved.
15.3 Dynamic Memory Allocation
• dynamic memory allocation– obtain and release memory during execution
• new– takes an argument and returns a pointer to object being allocated
• runs the Node constructor and stores pointer to that memory in newPtr
• throws a bad_alloc exception if no memory is available
• delete– calls Node destructor and deallocates memory allocated with new
– delete newPtr;
• newPtr is not deleted; the space newPtr points to is deallocated
2000 Deitel & Associates, Inc. All rights reserved. 2000 Deitel & Associates, Inc. All rights reserved.
15.4 Linked Lists
• linked list – linear collection of self-referential class objects, called nodes,
connected by pointer links
– accessed via a pointer to the first node of the list
– subsequent nodes are accessed via the link-pointer member
– the link pointer in the last node is set to null to mark the list’s end
• Use a linked list instead of an array when– the number of data elements is unpredictable
– the list needs to be sorted
2000 Deitel & Associates, Inc. All rights reserved. 2000 Deitel & Associates, Inc. All rights reserved.
15.4 Linked Lists (II)
• Types of linked lists:– singly linked list
• begins with a pointer to the first node• terminates with a null pointer• only traversed in one direction
– circular, singly linked• pointer in the last node points back to the first node
– doubly linked list• two “start pointers”- first element and last element• each node has a forward pointer and a backward pointer• allows traversals both forwards and backwards
– circular, doubly linked list• forward pointer of the last node points to the first node and
backward pointer of the first node points to the last node
2000 Deitel & Associates, Inc. All rights reserved. 2000 Deitel & Associates, Inc. All rights reserved.
Outline
Creating a Linked List
1. Class definition
1.1 Function definitions
1 // Fig. 15.3: listnd.h
2 // ListNode template definition
3 #ifndef LISTND_H
4 #define LISTND_H
5
6 template< class NODETYPE > class List; // forward declaration
7
8 template<class NODETYPE>
9 class ListNode {
10 friend class List< NODETYPE >; // make List a friend
11 public:
12 ListNode( const NODETYPE & ); // constructor
13 NODETYPE getData() const; // return data in the node
14 private:
15 NODETYPE data; // data
16 ListNode< NODETYPE > *nextPtr; // next node in the list
2000 Deitel & Associates, Inc. All rights reserved. 2000 Deitel & Associates, Inc. All rights reserved.
Outline
1. Load header
1.1 Class definition
1.2 Function definitions
1.3 Constructor
29 // Fig. 15.3: list.h30 // Template List class definition31 #ifndef LIST_H32 #define LIST_H3334 #include <iostream>35 #include <cassert>36 #include "listnd.h"3738 using std::cout;3940 template< class NODETYPE >41 class List {42 public:43 List(); // constructor44 ~List(); // destructor45 void insertAtFront( const NODETYPE & );46 void insertAtBack( const NODETYPE & );47 bool removeFromFront( NODETYPE & );48 bool removeFromBack( NODETYPE & );49 bool isEmpty() const;50 void print() const;51 private:52 ListNode< NODETYPE > *firstPtr; // pointer to first node53 ListNode< NODETYPE > *lastPtr; // pointer to last node5455 // Utility function to allocate a new node56 ListNode< NODETYPE > *getNewNode( const NODETYPE & );57 };5859 // Default constructor60 template< class NODETYPE >61 List< NODETYPE >::List() : firstPtr( 0 ), lastPtr( 0 ) { }
List has two pointers and can create new nodes
2000 Deitel & Associates, Inc. All rights reserved. 2000 Deitel & Associates, Inc. All rights reserved.
Outline
1.4 Destructor
1.5 insertAtFront
6263 // Destructor64 template< class NODETYPE >65 List< NODETYPE >::~List()66 {67 if ( !isEmpty() ) { // List is not empty68 cout << "Destroying nodes ...\n";6970 ListNode< NODETYPE > *currentPtr = firstPtr, *tempPtr;7172 while ( currentPtr != 0 ) { // delete remaining nodes73 tempPtr = currentPtr;74 cout << tempPtr->data << '\n';75 currentPtr = currentPtr->nextPtr;76 delete tempPtr;77 }78 }7980 cout << "All nodes destroyed\n\n";81 }8283 // Insert a node at the front of the list84 template< class NODETYPE >85 void List< NODETYPE >::insertAtFront( const NODETYPE &value )86 {87 ListNode< NODETYPE > *newPtr = getNewNode( value );8889 if ( isEmpty() ) // List is empty90 firstPtr = lastPtr = newPtr;91 else { // List is not empty92 newPtr->nextPtr = firstPtr;93 firstPtr = newPtr;94 }95 }
Destructor destroys the linked list and nodes
Sets the new node to point to what firstPtr points to, then sets firstPtr to the new node
2000 Deitel & Associates, Inc. All rights reserved. 2000 Deitel & Associates, Inc. All rights reserved.
Outline
1.6 insertAtBack
1.7 removeFromFront
9697 // Insert a node at the back of the list98 template< class NODETYPE >99 void List< NODETYPE >::insertAtBack( const NODETYPE &value )100{101 ListNode< NODETYPE > *newPtr = getNewNode( value );102103 if ( isEmpty() ) // List is empty104 firstPtr = lastPtr = newPtr;105 else { // List is not empty106 lastPtr->nextPtr = newPtr;107 lastPtr = newPtr;108 }109}110111// Delete a node from the front of the list112template< class NODETYPE >113bool List< NODETYPE >::removeFromFront( NODETYPE &value )114{115 if ( isEmpty() ) // List is empty116 return false; // delete unsuccessful117 else {118 ListNode< NODETYPE > *tempPtr = firstPtr;119120 if ( firstPtr == lastPtr )121 firstPtr = lastPtr = 0;122 else123 firstPtr = firstPtr->nextPtr;124125 value = tempPtr->data; // data being removed126 delete tempPtr;127 return true; // delete successful128 }129}
The last node points to the new node, then lastPtr points to the new node.
Move firstPtr to second node and delete first node.
2000 Deitel & Associates, Inc. All rights reserved. 2000 Deitel & Associates, Inc. All rights reserved.
Outline
1.7 removeFromBack
1.8 isEmpty
130131// Delete a node from the back of the list132template< class NODETYPE >133bool List< NODETYPE >::removeFromBack( NODETYPE &value )134{135 if ( isEmpty() )136 return false; // delete unsuccessful137 else {138 ListNode< NODETYPE > *tempPtr = lastPtr;139140 if ( firstPtr == lastPtr )141 firstPtr = lastPtr = 0;142 else {143 ListNode< NODETYPE > *currentPtr = firstPtr;144145 while ( currentPtr->nextPtr != lastPtr )146 currentPtr = currentPtr->nextPtr;147148 lastPtr = currentPtr;149 currentPtr->nextPtr = 0;150 }151152 value = tempPtr->data;153 delete tempPtr;154 return true; // delete successful155 }156}157158// Is the List empty?159template< class NODETYPE > 160bool List< NODETYPE >::isEmpty() const 161 { return firstPtr == 0; }162163// return a pointer to a newly allocated node
Change lastPtr to the second to last node and delete the last node
2000 Deitel & Associates, Inc. All rights reserved. 2000 Deitel & Associates, Inc. All rights reserved.
Outline
1.9 getNewNode
1.10 print
164template< class NODETYPE >165ListNode< NODETYPE > *List< NODETYPE >::getNewNode( 166 const NODETYPE &value )167{168 ListNode< NODETYPE > *ptr = 169 new ListNode< NODETYPE >( value );170 assert( ptr != 0 );171 return ptr;172}173174// Display the contents of the List175template< class NODETYPE >176void List< NODETYPE >::print() const177{178 if ( isEmpty() ) {179 cout << "The list is empty\n\n";180 return;181 }182183 ListNode< NODETYPE > *currentPtr = firstPtr;184185 cout << "The list is: ";186187 while ( currentPtr != 0 ) {188 cout << currentPtr->data << ' ';189 currentPtr = currentPtr->nextPtr;190 }191192 cout << "\n\n";193}194195#endif
Create a new node and return a pointer to it.
Walk through list and print node values.
2000 Deitel & Associates, Inc. All rights reserved. 2000 Deitel & Associates, Inc. All rights reserved.
Outline
1. Load header
1.1 Function definition
196// Fig. 15.3: fig15_03.cpp197// List class test198#include <iostream>199#include "list.h"200201using std::cin;202using std::endl;203204// Function to test an integer List205template< class T >206void testList( List< T > &listObject, const char *type )207{208 cout << "Testing a List of " << type << " values\n";209210 instructions();211 int choice;212 T value;213214 do {215 cout << "? ";216 cin >> choice;217218 switch ( choice ) {219 case 1:220 cout << "Enter " << type << ": ";221 cin >> value;222 listObject.insertAtFront( value );223 listObject.print();224 break;225 case 2:226 cout << "Enter " << type << ": ";227 cin >> value;
2000 Deitel & Associates, Inc. All rights reserved. 2000 Deitel & Associates, Inc. All rights reserved.
Outline
1.1 Function definition
228 listObject.insertAtBack( value );
229 listObject.print();
230 break;
231 case 3:
232 if ( listObject.removeFromFront( value ) )
233 cout << value << " removed from list\n";
234
235 listObject.print();
236 break;
237 case 4:
238 if ( listObject.removeFromBack( value ) )
239 cout << value << " removed from list\n";
240
241 listObject.print();
242 break;
243 }
244 } while ( choice != 5 );
245
246 cout << "End list test\n\n";
247}
248
249void instructions()
250{
251 cout << "Enter one of the following:\n"
252 << " 1 to insert at beginning of list\n"
253 << " 2 to insert at end of list\n"
254 << " 3 to delete from beginning of list\n"
255 << " 4 to delete from end of list\n"
256 << " 5 to end list processing\n";
257}
258
Choices correspond to the switch statement
2000 Deitel & Associates, Inc. All rights reserved. 2000 Deitel & Associates, Inc. All rights reserved.
Outline
1. Initialize objects
2. Function calls
259int main()
260{
261 List< int > integerList;
262 testList( integerList, "integer" ); // test integerList
263
264 List< double > doubleList;
265 testList( doubleList, "double" ); // test doubleList
266
267 return 0;
268}
Use templates to create an integer list and a double list.
2000 Deitel & Associates, Inc. All rights reserved. 2000 Deitel & Associates, Inc. All rights reserved.
Outline
Program Output
Testing a List of integer valuesEnter one of the following: 1 to insert at beginning of list 2 to insert at end of list 3 to delete from beginning of list 4 to delete from end of list 5 to end list processing? 1Enter integer: 1The list is: 1 ? 1Enter integer: 2The list is: 2 1 ? 2Enter integer: 3The list is: 2 1 3 ? 2Enter integer: 4The list is: 2 1 3 4 ? 32 removed from listThe list is: 1 3 4 ? 31 removed from listThe list is: 3 4
2000 Deitel & Associates, Inc. All rights reserved. 2000 Deitel & Associates, Inc. All rights reserved.
Outline
Program Output
? 44 removed from listThe list is: 3 ? 43 removed from listThe list is empty ? 5End list test
Testing a List of double valuesEnter one of the following: 1 to insert at beginning of list 2 to insert at end of list 3 to delete from beginning of list 4 to delete from end of list 5 to end list processing? 1Enter double: 1.1The list is: 1.1 ? 1Enter double: 2.2The list is: 2.2 1.1 ? 2Enter double: 3.3The list is: 2.2 1.1 3.3 ? 2Enter double: 4.4The list is: 2.2 1.1 3.3 4.4
2000 Deitel & Associates, Inc. All rights reserved. 2000 Deitel & Associates, Inc. All rights reserved.
Outline
Program Output
? 32.2 removed from listThe list is: 1.1 3.3 4.4 ? 31.1 removed from listThe list is: 3.3 4.4 ? 44.4 removed from listThe list is: 3.3 ? 43.3 removed from listThe list is empty ? 5End list test All nodes destroyed All nodes destroyed
2000 Deitel & Associates, Inc. All rights reserved. 2000 Deitel & Associates, Inc. All rights reserved.
15.5 Stacks
• stack – new nodes can be added and removed only at the top– similar to a pile of dishes
– last-in, first-out (LIFO)
– Bottom of stack indicated by a link member to null
– constrained version of a linked list
• push– adds a new node to the top of the stack
• pop– removes a node from the top – stores the popped value – returns true if pop was successful
2000 Deitel & Associates, Inc. All rights reserved. 2000 Deitel & Associates, Inc. All rights reserved.
2000 Deitel & Associates, Inc. All rights reserved. 2000 Deitel & Associates, Inc. All rights reserved.
Outline
Program Output
processing an integer StackThe list is: 0 The list is: 1 0 The list is: 2 1 0 The list is: 3 2 1 0 3 popped from stackThe list is: 2 1 0 2 popped from stackThe list is: 1 0 1 popped from stackThe list is: 0 0 popped from stackThe list is empty processing a double StackThe list is: 1.1 The list is: 2.2 1.1 The list is: 3.3 2.2 1.1 The list is: 4.4 3.3 2.2 1.1
2000 Deitel & Associates, Inc. All rights reserved. 2000 Deitel & Associates, Inc. All rights reserved.
Outline
Program Output
4.4 popped from stackThe list is: 3.3 2.2 1.1 3.3 popped from stackThe list is: 2.2 1.1 2.2 popped from stackThe list is: 1.1 1.1 popped from stackThe list is empty All nodes destroyed All nodes destroyed
2000 Deitel & Associates, Inc. All rights reserved. 2000 Deitel & Associates, Inc. All rights reserved.
15.6 Queues
• queue – similar to a supermarket checkout line– first-in, first-out (FIFO)
– nodes are removed only from the head
– nodes are inserted only at the tail
• The insert and remove operations are known as enqueue and dequeue
• Useful in computing– Print spooling, packets in networks, file server requests
2000 Deitel & Associates, Inc. All rights reserved. 2000 Deitel & Associates, Inc. All rights reserved.
Outline
1. Load header
1.1 Class definition
1.2 Function prototypes
----------------------
1. Load header
1.1 Initialize objects
2. Function calls
1 // Fig. 15.12: queue.h
2 // Queue class template definition3 // Derived from class List4 #ifndef QUEUE_H5 #define QUEUE_H67 #include "list.h"89 template< class QUEUETYPE >10 class Queue: private List< QUEUETYPE > {11 public:12 void enqueue( const QUEUETYPE &d ) { insertAtBack( d ); }13 bool dequeue( QUEUETYPE &d ) 14 { return removeFromFront( d ); }15 bool isQueueEmpty() const { return isEmpty(); }16 void printQueue() const { print(); }17 };1819 #endif20 // Fig. 15.12: fig15_12.cpp21 // Driver to test the template Queue class22 #include <iostream>23 #include "queue.h"2425 using std::endl;2627 int main()28 {29 Queue< int > intQueue;30 int dequeueInteger, i;31 cout << "processing an integer Queue" << endl;3233 for ( i = 0; i < 4; i++ ) {
queue only has limited linked-list operations (insertAtBack and removeFromFront)
processing an integer Queue
2000 Deitel & Associates, Inc. All rights reserved. 2000 Deitel & Associates, Inc. All rights reserved.
Outline
2. Function calls
3. Output
34 intQueue.enqueue( i );
35 intQueue.printQueue();
36 }
37
38 while ( !intQueue.isQueueEmpty() ) {
39 intQueue.dequeue( dequeueInteger );
40 cout << dequeueInteger << " dequeued" << endl;
41 intQueue.printQueue();
42 }
43
44 Queue< double > doubleQueue;
45 double val = 1.1, dequeuedouble;
46
47 cout << "processing a double Queue" << endl;
48
49 for ( i = 0; i < 4; i++ ) {
50 doubleQueue.enqueue( val );
51 doubleQueue.printQueue();
52 val += 1.1;
53 }
54
55 while ( !doubleQueue.isQueueEmpty() ) {
56 doubleQueue.dequeue( dequeuedouble );
57 cout << dequeuedouble << " dequeued" << endl;
58 doubleQueue.printQueue();
59 }
60
61 return 0;
62 }
The list is: 0
The list is: 0 1
The list is: 0 1 2
The list is: 0 1 2 3
0 dequeued
The list is: 1 2 3
1 dequeued
The list is: 2 3
2 dequeued
The list is: 3
3 dequeued
The list is empty
processing a double QueueThe list is: 1.1
The list is: 1.1 2.2
The list is: 1.1 2.2 3.3
The list is: 1.1 2.2 3.3 4.4
1.1 dequeued
The list is: 2.2 3.3 4.4
2.2 dequeued
The list is: 3.3 4.4
3.3 dequeuedThe list is: 4.4 4.4 dequeuedThe list is empty
All nodes destroyed
All nodes destroyed
2000 Deitel & Associates, Inc. All rights reserved. 2000 Deitel & Associates, Inc. All rights reserved.
Outline
Program Output
processing an integer QueueThe list is: 0 The list is: 0 1 The list is: 0 1 2 The list is: 0 1 2 3 0 dequeuedThe list is: 1 2 3 1 dequeuedThe list is: 2 3 2 dequeuedThe list is: 3 3 dequeuedThe list is empty processing a double QueueThe list is: 1.1 The list is: 1.1 2.2 The list is: 1.1 2.2 3.3 The list is: 1.1 2.2 3.3 4.4 1.1 dequeuedThe list is: 2.2 3.3 4.4 2.2 dequeuedThe list is: 3.3 4.4
2000 Deitel & Associates, Inc. All rights reserved. 2000 Deitel & Associates, Inc. All rights reserved.
Outline
Program Output
3.3 dequeuedThe list is: 4.4 4.4 dequeuedThe list is empty All nodes destroyed All nodes destroyed
2000 Deitel & Associates, Inc. All rights reserved. 2000 Deitel & Associates, Inc. All rights reserved.
15.7 Trees
• Tree nodes contain two or more links– all other data structures we have discussed only contain one
• Binary trees– all nodes contain two links
• none, one, or both of which may be NULL
– The root node is the first node in a tree.
– Each link in the root node refers to a child
– A node with no children is called a leaf node
B
A D
C
2000 Deitel & Associates, Inc. All rights reserved. 2000 Deitel & Associates, Inc. All rights reserved.
15.7 Trees (II)
• binary search tree – values in left subtree less than parent
– values in right subtree greater than parent
– facilitates duplicate elimination
– fast searches - for a balanced tree, maximum of log n comparisons
47
25 77
11 43 65 93
68 7 17 31 44
2
2000 Deitel & Associates, Inc. All rights reserved. 2000 Deitel & Associates, Inc. All rights reserved.
15.7 Trees (III)
• Tree traversals:– inorder traversal of a binary search tree prints the
node values in ascending order1. Traverse the left subtree with an inorder traversal.2. Process the value in the node (i.e., print the node value).3. Traverse the right subtree with an inorder traversal.
– preorder traversal:1. Process the value in the node.2. Traverse the left subtree with a preorder traversal. 3. Traverse the right subtree with a preorder traversal.
– postorder traversal:1. Traverse the left subtree with a postorder traversal.
2. Traverse the right subtree with a postorder traversal.3. Process the value in the node.
2000 Deitel & Associates, Inc. All rights reserved. 2000 Deitel & Associates, Inc. All rights reserved.
Outline
1. Class definition
1.1 Member functions
1.2 Member variables
-----------------------
1. Load header
1 // Fig. 15.16: treenode.h2 // Definition of class TreeNode3 #ifndef TREENODE_H4 #define TREENODE_H56 template< class NODETYPE > class Tree; // forward declaration78 template< class NODETYPE >9 class TreeNode {10 friend class Tree< NODETYPE >;11 public:12 TreeNode( const NODETYPE &d ) 13 : leftPtr( 0 ), data( d ), rightPtr( 0 ) { }14 NODETYPE getData() const { return data; }15 private:16 TreeNode< NODETYPE > *leftPtr; // pointer to left subtree17 NODETYPE data;18 TreeNode< NODETYPE > *rightPtr; // pointer to right subtree19 };2021 #endif22 // Fig. 15.16: tree.h
23 // Definition of template class Tree
24 #ifndef TREE_H
25 #define TREE_H
26
27 #include <iostream>
28 #include <cassert>
29 #include "treenode.h"
30
31 using std::endl;
32
33 template< class NODETYPE >
Trees contain two pointers per node.
2000 Deitel & Associates, Inc. All rights reserved. 2000 Deitel & Associates, Inc. All rights reserved.