Link-Based Implementations. Chapter 4

Transcription

1 Link-Based Implementations Chapter 4

2 Overview Assignment-2 Slack code puzzle Negative time durations Both -1:59:59 and -0:00:01 are OK to represent -1 seconds Slack no assignment code posting Code Puzzle ADT Array-based implementation Link-based implementation 2

3 Usage: Pointers vs Objects Pointers use -> Objects use. someptr->dosomething() someobj.dosomething() this is a pointer this->dosomething() *this is an object, * dereferences a pointer and gets us to the object, so (*this).dosomething() 3

4 Stack vs Heap When we use new, memory allocated on the Heap We must delete it Square* s = new Square(25); delete s; s = nullptr; // not always needed, // but good practice 4

5 Dynamic Arrays int size; cout << "How big: "; cin >> size; Square* manysquares = new Square[size]; // Square objects in array manysquares[0].setsize(15); delete[] manysquares; manysquares = nullptr; 5

6 * and & // sqptr is a pointer to a Square object Square *sqptr = new Square(); // sq is a copy of the object sqptr points to // * dereferences an object // goes from memory address to value of object Square sq = (*sqptr); // sqptr2 is pointing at existing object Square *sqptr2 = (&sq); What needs to be deleted? 6

7 Pointer to a Pointer Square sq; Square *sqptr = &sq; Square **sqptr2ptr = &sqptr; cout cout cout cout cout << << << << << sq.getsize(); sqptr->getsize(); (*sqptr).getsize(); (*sqptr2ptr)->getsize(); (**sqptr2ptr).getsize(); What needs to be deleted? 7

8 Calling a function void display(square *somesquare) { cout << somesquare->getsize(); } Square sq; Square *sqptr = &sq; Square **sqptr2ptr = &sqptr; display(&sq); display(sqptr); // pass the address of sq // data types match // derefence from pointer to a pointer to just a pointer display(*sqptr2ptr); 8

9 Preliminaries Another way to organize data items Place them within objects usually called nodes Linked together into a chain, one after the other Figure 4-1 A freight train 9

10 Preliminaries FIGURE 4-2 A node FIGURE 4-3 Several nodes linked together 10

11 Preliminaries FIGURE 4-4 A head pointer to the first of several linked nodes 11

12 Class Exercise: Node Write the.h for Node Assume the data will be int (no need for templates) A Node only knows about itself and what comes after it 12

13 Preliminaries FIGURE 4-5 A lost node 13

14 The Class Node LISTING 4-1 The header file for the template class Node 14

15 A Link-Based Implementation of the ADT Bag Class Exercise: Write the.h for List that uses Node Assume the ItemType will be int (no templates) Bag operations, given in UML notation 15

16 The Header File LISTING 4-3 The header file for the class LinkedBag 16

17 The Header File ~ LISTING 4-3 The header file for the class LinkedBag 17

18 Defining the Core Methods FIGURE 4-7 Inserting at the beginning of a linked chain 18

19 Class Exercise: add Write the implementation for List::add bool List::add(int data) { return true; } 19

20 Defining the Core Methods Default Constructor Inserting at the beginning of a linked chain 20

21 Defining the Core Methods Traverse operation visits each node in linked chain Must move from node to node High-level pseudocode for this loop 21

22 Defining the Core Methods FIGURE 4-8 The effect of the assignment curptr = curptr->getnext( ) 22

23 Defining the Core Methods Methods isempty and getcurrentsize 23

24 Class Exercise: getfrequencyof template<class ItemType> int LinkedBag<ItemType>::getFrequencyOf(const ItemType& anentry) const { return frequency; } // end getfrequencyof 24

25 Implementing More Methods Search for a specific entry. To avoid duplicate code, we perform this search in a private method 25

26 Implementing More Methods Note: definition of the method contains calls getpointerto 26

27 remove Multiple ways to remove a node 1. Set the first item to be the data of the new node and then remove the first node 2. Find the node to be removed and the node before it to remove the node Make sure to use delete on the node 27

28 Implementing More Methods Method remove also calls getpointerto 28

29 Implementing More Methods Method clear deallocates all nodes in the chain. 29

30 Implementing More Methods Destructor calls clear, destroys instance of a class 30

31 Copying objects Copy constructor Square (const Square &other) { // body } Square s2(s1); Assignment operator Square& operator=(const Square &other) { // body } s2 = s1 Check for self-assignment in operator= if(&other == this) return *this; 31

32 Implementing More Methods FIGURE 4-9 (a) A linked chain and its shallow copy; (b) a linked chain and its deep copy 32

33 Implementing More Methods Copy constructor to accomplish deep copy. 33

34 Implementing More Methods Copy constructor to accomplish deep copy. 34

35 Recursive getpointerto Private method getpointerto Locates given entry within linked chain Traversal stops if it locates node that contains given entry 35

36 Comparing Array-Based and Link-Based Implementations Arrays easy to use, but have fixed size Not always easy to predict number of items in ADT Array could waste space Increasing size of dynamically allocated array can waste storage and time Can access array items directly with equal access time An array-based implementation is a good choice for a small bag 36

37 Comparing Array-Based and Link-Based Implementations Linked chains do not have fixed size In a chain of linked nodes, an item points explicitly to the next item Link-based implementation requires more memory Must traverse a linked chain to access its ith node Time to access ith node in a linked chain depends on i 37