Linked Lists. Gaddis Ch. 17. CS 2308 :: Spring 2016 Molly O'Neil

Transcription

1 Linked Lists Gaddis Ch. 17 CS 2308 :: Spring 2016 Molly O'Neil

2 List ADT A list is an abstract data type representing an ordered sequence of values For example, both MP3 Player assignments have used lists: sequences of Songs, ordered by title and artist So far, when we've needed a list, we've used an array as the data structure implementing the list There are some disadvantages to using arrays for lists: Difficult to grow in size (allocate new array, then copy over elements) Allocated memory often exceeds actual # of elements in list When an element has to be added or removed to/from the middle of the list, other elements have to be moved (either shifted over, or swapped and re-sorted) 2

3 Linked List A linked list is another data structure that represents a list A series of nodes chained together in sequence Each node in the list points to the next node in the list A separate pointer points to the first node in the list (the head of the list) The last node points to nothing () head 3

4 Linked Lists The nodes are dynamically allocated The list grows and shrinks as nodes are added/deleted Easy to insert a node between other nodes head Easy to delete a node from between other nodes head 4

5 Linked Lists The nodes are dynamically allocated The list grows and shrinks as nodes are added/deleted Easy to insert a node between other nodes head Easy to delete a node from between other nodes head 5

6 Nodes The node is usually implemented as a nested struct or a class (defined inside the linked list definition) Each node contains: A data field This can be an int, a double, a struct, an object, etc. A pointer The link to the next node in the list data pointer 6

7 Empty List An empty list is a list that contains zero nodes The list head points to (address 0) head (All linked lists start with a head pointer and end in ; in an empty list, there are no nodes between the two) 7

8 Some Reminders About Equivalent to address zero In C++11, you can use nullptr is a #define for 0, defined in the <cstddef> header: #include <cstddef> To test a pointer for non- value: while(ptr) {... } // equivalent to: while(p!= ) To test a pointer for : while(!ptr) {... } // equivalent to: while(p == ) 8

9 Defining a Linked List Data Type We will define a class to represent a linked list data type that can store values of type double (But we could design a linked list that stores ints, or Student structs, or Time objects...) When we define a new abstract data type, we describe the values it can store (in this case, doubles) and the operations over those values Before defining the list values, we must: Define a (nested) data type for the nodes Define a head pointer variable to point to the first node in the list Then we define the operations/actions the list supports 9

10 Defining the Node Data Type We could use a class or a struct for the node type It's not obvious that the node type will need actions (functions), but let's use a class to keep our options open... class ListNode { public: double value; ListNode *next; }; value next (This just defines the data type; no variable declared) Why public? Lets us access value and next without getter/setter next holds the address of another ListNode (or ) This is a self-referential data structure 10

11 Defining the List Head Pointer Define a pointer for the head of the list: ListNode *head; It must be initialized to to signify that the list is empty (Initialized in the Linked List class constructor) This is the only member variable of our Linked List class As we add nodes, we retain just a pointer to the first node. Then we can follow pointers to each successive next node to access the others. 11

12 Linked List Operations Operations for our linked list to store a list of doubles: construct a new, empty list append a number (a new node) to the end of the list insert a number (a new node) within the list (in its ordered position) remove a number from the list display the linked list delete/destroy the list 12

13 Linked List Class Declaration using namespace std; class NumberList { private: class ListNode { public: double value; ListNode *next; }; NumberList.h ListNode *head; public: NumberList(); ~NumberList(); }; void append(double); void insert(double); void remove(double); void display(); ListNode is a private class internal to NumberList: cannot refer to ListNode or instantiate a ListNode object outside of NumberList. This is why we can get away with declaring ListNode's member variables as public; they're still entirely hidden from outside NumberList! 13

14 Operation: Construct the Empty List The NumberList constructor initializes the list to empty (points the head pointer at ) #include <cstddef> // for #include "NumberList.h" using namespace std; NumberList.cpp NumberList::NumberList() { head = ; } 14

15 Operation: Append Number to List Append: add a new number (a new node) to the end of the list Algorithm: Create a new node and store the data in it Set the new node's next pointer to point to If the list is empty: Make the head pointer point to the new node Else: Make the last node's next pointer point to the new node head 15

16 Operation: Append Number to List Append: add a new number (a new node) to the end of the list Algorithm: Create a new node and store the data in it Set the new node's next pointer to point to If the list is empty: Make the head pointer point to the new node Else: Make the last node's next pointer point to the new node head 16

17 Append: Find Last Element To append a new node after the last node, we have to find the last node. How? (We only have a pointer to the first/ head node) Key insight: Starting at the head node, we can always find other nodes by traversing the list (by following next pointers) The last node is the node whose next pointer points to Algorithm: Make a pointer curr and point it at the first node Check the next pointer of the node curr points to, and while it's not... Move curr to the next node by assigning curr pointer the value of (the node it points to)'s next pointer ListNode *curr = head; while(curr->next) // loop terminates when curr = last node curr = curr->next; 17

18 Traversing to Last Node curr head Set curr to head Is curr node's next pointer ==? Move curr to next node: curr = (curr node's next pointer) [ curr = curr->next ] 18

19 Traversing to Last Node curr head Set curr to head Is curr node's next pointer ==? Move curr to next node: curr = (curr node's next pointer) [ curr = curr->next ] Is curr node's next pointer ==? Move curr to next node 19

20 Traversing to Last Node curr head Set curr to head Is curr node's next pointer ==? Move curr to next node: curr = (curr node's next pointer) [ curr = curr->next ] Is curr node's next pointer ==? Move curr to next node Is curr node's next pointer ==? 20

21 append() in C++ void NumberList::append(double num) { // create the new node, store the data in it ListNode *newnode = new ListNode; newnode->value = num; newnode->next = ; NumberList.cpp // list is empty, make head point to new node if(head == ) head = newnode; else { ListNode *curr = head; // find the last node while(curr->next) curr = curr->next; moves curr to point to last node } } // set last node's next pointer to new node curr->next = newnode; 21

22 Traversing a Linked List Visit each node in a linked list to... Display the contents, sum data, delete each node, etc. Basic algorithm: Make a pointer and point it at first node (where head currently points) While pointer is not : Process data of node currently pointed at Advance to the next node by setting the pointer to the current node's next pointer 22

23 Operation: Display the List Displaying each node in succession requires traversing the list void NumberList::display() { NumberList.cpp ListNode *curr; // ptr to traverse the list curr = head; // start curr at head of list // until we encounter the at the end of the list... while(curr) { // print the value in the current node cout << curr->value << " "; } // move to the next node curr = curr->next; } cout << endl; 23

24 Demo Driver for NumberList #include "NumberList.h" using namespace std; ListDriver.cpp int main() { // Declare an instance (object) of the list class NumberList list; // Append some values (in ascending order) list.append(2.5); list.append(5.1); list.append(7.9); } // Display the values in the list list.display(); Output:

25 Operation: Delete (Destroy) the List The destructor must delete (de-allocate) all the nodes allocated for the list Use list traversal to visit each node, call delete on it Careful... What's wrong with the below definition? NumberList::~NumberList() { // BROKEN!!! ListNode *curr = head; // start traversal ptr at list head } while(curr) { delete curr; curr = curr->next; } 25

26 Destructor You have to save a copy of the pointer to the next node (curr->next) before you delete the node NumberList::~NumberList() { ListNode *curr; // traversal pointer ListNode *next; // pointer to next node NumberList.cpp curr = head; } while(curr) { next = curr->next; // save pointer to next delete curr; // delete current node curr = next; // advance pointer } 26

27 Operation: Remove Number from List Find number to remove, un-link the node from the list, and delete (de-allocate) the removed node Requires two pointers: One [curr] to find and point to the node to be removed One [prev] to point to the node before the node to be removed prev curr head Remove 6.4 from list 27

28 Removing a Node To re-link the list around the node we're removing, we change the next pointer of the previous node to point to the node after the one we're removing prev->next = curr->next; prev curr head Now delete the curr node 28

29 Removing a Node To re-link the list around the node we're removing, we change the next pointer of the previous node to point to the node after the one we're removing prev->next = curr->next; head Now delete the curr node 29

30 Finding the Node to Remove Remove function takes a number to remove, not a node (the existence of the ListNode class is hidden/ private) Must first find the associated node Traverse the list looking for a match prev curr prev = curr; curr = curr->next; head Remove 6.4 from list 30

31 Finding the Node to Remove Remove function takes a number to remove, not a node (the existence of the ListNode class is hidden/ private) Must first find the associated node Traverse the list looking for a match prev curr prev = curr; curr = curr->next; head Remove 6.4 from list 31

32 Finding the Node to Remove Remove function takes a number to remove, not a node (the existence of the ListNode class is hidden/ private) Must first find the associated node Traverse the list looking for a match prev curr prev = curr; curr = curr->next; head What if the remove target is 8.2? Remove 6.4 from list 32

33 remove() in C++ void NumberList::remove(double num) { ListNode *curr = head; // traversal pointer ListNode *prev = ; // trailing pointer NumberList.cpp // traverse the list to find the node to remove while(curr && curr->value!= num) { prev = curr; curr = curr->next; } } // if curr is, num was not in the list: nothing to do if(curr) { // if we're removing the first node... if(curr == head) // or: if(!prev) } head = head->next; // advance head pointer // otherwise, remove from list middle or end else prev->next = curr->next; // re-link around node delete curr; // delete the node What if the remove target is the last node? 33

34 remove() Variations if(curr) { if(curr == head) head = head->next; else prev->next = curr->next; delete curr; } if(curr) { if(curr == head) head = curr->next; else prev->next = curr->next; delete curr; } if(curr) { if(prev) prev->next = curr->next; else head = head->next; delete curr; } if(curr) { if(curr == head) { head = head->next; delete curr; } else { prev->next = curr->next; delete curr; } } Lots of minor variations in how we can code linked list operations All of them involve the same cases: removing the head node, or removing a middle/last node. Takeaway: Learn the algorithm; you can always re-derive the code! 34

35 Demo Driver for NumberList #include "NumberList.h" using namespace std; ListDriver.cpp int main() { // Set up the list NumberList list; list.append(2.5); list.append(5.1); list.append(7.9); list.display(); cout << endl << "remove 5.1:" << endl; list.remove(5.1); list.display(); cout << endl << "remove 8.2:" << endl; list.remove(8.2); list.display(); Output: remove 5.1: remove 8.2: remove 2.5: 7.9 } cout << endl << "remove 2.5:" << endl; list.remove(2.5); list.display(); 35

36 Operation: Insert Number Into List Create a new node with the number to insert, find its position in the list, link the node into the list Requires two pointers: One [curr] to find and point to the node after the insertion point (This one is optional - why?) One [prev] to point to the node before the insertion point prev curr head newnode

37 Determining the Insertion Point Depending on our particular linked list implementation, we can determine the insertion point... By position: insert() could take a second argument specifying an index to insert after (or before) By cursor: the NumberList class could have a member variable that is a pointer to the "current node", always insert new value after (or before) the current node By maintaining a sorted list: the insertion point is always immediately before the first node in the list with a value greater than the value being inserted If this one, we may want to re-consider having an append() function as well, since it allows building an out-of-order list We assume the list is sorted! 37

38 Insert Node Into List First step: Move prev/curr to either side of insertion point. (With curr, skip all nodes less than new node's value) prev curr head newnode

39 Insert Node Into List First step: Move prev/curr to either side of insertion point. (With curr, skip all nodes less than new node's value) prev curr head newnode

40 Insert Node Into List First step: Move prev/curr to either side of insertion point. (With curr, skip all nodes less than new node's value) prev curr head newnode

41 Insert Node Into List First step: Move prev/curr to either side of insertion point. (With curr, skip all nodes less than new node's value) Then: link new node into list between prev and curr prev curr head newnode

42 Insert Node Into List First step: Move prev/curr to either side of insertion point. (With curr, skip all nodes less than new node's value) Then: link new node into list between prev and curr prev->next = newnode; newnode->next = curr; prev curr head newnode

43 Insert Node Into List First step: Move prev/curr to either side of insertion point. (With curr, skip all nodes less than new node's value) Then: link new node into list between prev and curr prev->next = newnode; newnode->next = curr; prev curr head newnode

44 Insert Node Into List First step: Move prev/curr to either side of insertion point. (With curr, skip all nodes less than new node's value) Then: link new node into list between prev and curr prev->next = newnode; newnode->next = curr; prev curr head newnode

45 Insert Node Into List First step: Move prev/curr to either side of insertion point. (With curr, skip all nodes less than new node's value) Then: link new node into list between prev and curr prev->next = newnode; newnode->next = curr; prev curr head

46 insert() in C++ void NumberList::insert(double num) { ListNode *curr = head; // traversal pointer ListNode *prev = ; // trailing pointer // create new node ListNode *newnode = new ListNode; newnode->value = num; // find the insertion point (curr points at node after) while(curr && curr->value < num) { prev = curr; curr = curr->next; } } // new node should be new head of list if(curr == head) head = newnode; // new node in middle/end of list else prev->next = newnode; newnode->next = curr; What if the new node should be the new last node? 46

47 insert() Variations if(curr == head) head = newnode; else prev->next = newnode; newnode->next = curr; if(!prev) head = newnode; else prev->next = newnode; newnode->next = curr; if(curr == head) { newnode->next = curr; head = newnode; } else { newnode->next = curr; prev->next = newnode; } newnode->next = curr; if(curr == head) head = newnode; else prev->next = newnode; Once again, there are lots of minor variations in how we can code this. We could also get rid of the curr pointer entirely, because we can always get to the node after prev using prev->next Learn the algorithm; you can always re-derive the code! 47

48 Demo Driver for NumberList #include "NumberList.h" using namespace std; ListDriver.cpp int main() { // Set up the list NumberList list; list.append(2.5); list.append(5.1); list.append(7.9); list.display(); list.insert(3.7); list.display(); list.insert(1.2); list.display(); Output: } list.insert(9.6); list.display(); 48

49 Why An Array Instead of a Linked List? Arrays allow random access to elements, i.e. array[i] Linked lists allow only sequential access to elements (you must traverse the list to get to the i'th element) Arrays do not require extra storage for the next link Linked lists are impractical for lists of chars or bools (pointer value is bigger than the data value!) 49

50 Why a Linked List Instead of An Array? A linked list can easily grow or shrink in size Nodes are created in memory as they are needed The programmer doesn't have to know or guess up front how many elements will ultimately be in the list The amount of memory to store a linked list is always proportional to the number of elements in the list For arrays, the amount of memory allocated is often much more than required by the actual count of elements in the list (partial arrays) When a node is inserted into or deleted from a linked list, none of the other nodes have to be moved in memory 50

51 Linked List Variations Circular Linked List The last node in the list points to the head node rather than to head Doubly Linked List Each node keeps a pointer to the previous node in the list as well as to the next node head Double-Ended Linked List Two pointers, head and tail, allow constant-time insertion to both ends of list 51

52 Ideas for More Linked List Practice Similar to NumberList... Create a linked list class for Student structs (sorted by ID) Create a linked list class for Time objects (sorted by time) Add to NumberList... int count() Return the number of nodes in the list double findmaximum() or double findminimum() Return the maximum/minimum value in the list double findnumberatindex(int index) Return the value in the index'th node in the list All of these are fair game void prepend(double num) Add num to the front of the list for an exam, double popfront() and they tend to show up Remove the first node from the list and return its value in coding interviews, too! double popback() Remove the last node from the list and return its value void insertatindex(double num, int index) Insert num into the index'th position in the list void reverse() Reverse the order of the list, in place void removeduplicates() Remove all duplicate values from the list (without re-ordering the remaining elements of the list) NumberList mergewithsortedlist(numberlist other) Return a new list containing the values in the list the function is called on (*this) and the other list, both of which are assumed to be sorted, and preserving the sorted order of the output list 52