! A data structure representing a list. ! A series of nodes chained together in sequence. ! A separate pointer (the head) points to the first

Transcription

1 Ch. 17: Linked Lists 17.1 Introduction to Linked Lists! A data structure reresenting a list! A series of nodes chained together in sequence CS 2308 Sring 2015 Jill Seaman - Each node oints to one other node.! A searate ointer (the ) oints to the first item in the list.! The last element oints to nothing () list 1 2 Introduction to Linked Lists! The nodes are dynamically allocated - The list grows and shrinks as nodes are added/ removed. Linked lists can easily insert a node between other nodes Linked lists can easily delete a node from between other nodes Node Organization! The node is usually imlemented as a struct! Each node contains: - a data field may be organized as a structure, an object, etc. - a ointer that can oint to another node data ointer list 3 4

2 Emty List! An emty list contains 0 nodes.! The list oints to (address 0)! (There are no nodes, it s emty) list Declaring the Linked List data tye! We will be defining a class to reresent a linked list data tye that can store values of tye double.! This data tye will describe the values (the lists) and oerations over those values.! In order to define the values we must: - define a (nested) data tye for the nodes - define a ointer variable () that oints to the first node in the list. 5 6 Declaring the Node data tye! Use a struct for the node tye struct ListNode { double value; ListNode *next; ;! (this is just a data tye, no variables declared)! next can hold the address of a ListNode. Defining the Linked List member variable! Define a ointer for the of the list: ListNode *;! It must be initialized to to signify the end of the list.! Now we have an emty linked list: - it can also be - self-referential data structure 7 8

3 Using 17.2 Linked List oerations! Equivalent to address 0! Used to secify end of the list! In C++11, you can use nulltr instead of! is defined in the cstddef er: #include <cstddef>! to test a ointer for (these are equivalent): while ()... <==> while (!= )...! Basic oerations: - create a new, emty list - aend a node to the end of the list - insert a node within the list - delete a node - dislay the linked list - delete/destroy the list if (!)... <==> if ( == ) ! Linked List class declaration #include <cstddef> // for using namesace std; class NumberList { rivate: struct ListNode // the node data tye { double value; // data ListNode *next; // tr to next node ; ListNode *; // the list ublic: NumberList(); ~NumberList(); NumberList.h // creates an emty list Oeration: Create the emty list! Constructor: sets u emty list #include "NumberList.h" NumberList::NumberList() { = ; NumberList.c ; void aendnode(double); void insertnode(double); void deletenode(double); void dislaylist(); 11 12

4 Oeration: aend node to end of list! aendnode: adds new node to end of list! Algorithm: Create a new node and store the data in it If the list has no nodes (it s emty) Make oint to the new node. Else Find the last node in the list Make the last node oint to the new node aendnode: find last elem! How to find the last node in the list?! Algorithm: Make a ointer oint to the first element while (the node oints to) is not ointing to make oint to (the node oints to) is ointing to! In C++: ListNode * = ; while ((*).next!= ) = (*).next; <==> ListNode * = ; while (->next) = ->next; 13 =->next is like i++ 14 void NumberList::aendNode(double num) { ListNode *newnode; // To oint to the new node in NumberList.c Driver to demo NumberList // Create a new node and store the data in it newnode = new ListNode; newnode->value = num; newnode->next = ;! ListDriver.c version 1 (no outut) // If emty, make oint to new node if (==) = newnode; else { ListNode *; // To move through the list = ; // initialize to start of list #include "NumberList.h" int main() { // Define the list NumberList list; ListDriver.c // traverse list to find last node while (->next) //it s not last = ->next; //make it t to next // now ts to last node // make last node oint to newnode ->next = newnode; 15 // Aend some values to the list list.aendnode(2.5); list.aendnode(7.9); list.aendnode(12.6); 16

5 Traversing a Linked List Oeration: dislay the list! Visit each node in a linked list, to - dislay contents, sum data, test data, etc.! Basic rocess: set a ointer to oint to what oints to while ointer is not rocess data of current node go to the next node by setting the ointer to the ointer field of the current node end while 17 void NumberList::dislayList() { ListNode *; //tr to traverse the list // start at the of the list = ; // while ts to something (not ), continue while () { //Dislay the value in the current node cout << ->value << ; //Move to the next node = ->next; cout << endl; in NumberList.c 18 Driver to demo NumberList Oeration: destroy a List! ListDriver.c version 2 #include "NumberList.h" int main() { ListDriver.c! The destructor must delete (deallocate) all nodes used in the list! To do this, use list traversal to visit each node! ~NumberList: what s wrong with this definition? // Define the list NumberList list; NumberList::~NumberList() { // Aend some values to the list list.aendnode(2.5); list.aendnode(7.9); list.aendnode(12.6); // Dislay the values in the list. Outut: ListNode *; // traversal tr = ; //start at of list while () { delete ; // delete current = ->next; // advance tr 20

6 destructor! You need to save ->next before deleting : in NumberList.c NumberList::~NumberList() { ListNode *; // traversal tr ListNode *n; // saves the next node = ; //start at of list while () { Oeration: delete a node from the list! deletenode: removes node from list, and deletes (deallocates) the removed node.! Requires two extra ointers: - one to oint to the node before the node to be deleted. (n) [why?] - one to oint to the node to be deleted () [why?] n n = ->next; // save the next delete ; // delete current = n; // advance tr Deleting 13 from the list 22 Deleting a node! Change the ointer of the revious node to oint to the node after the one to be deleted. n n->next = ->next; Deleting a node! After the node is deleted: delete ; n ! Now just delete the node 23 24

7 deletenode code Driver to demo NumberList void NumberList::deleteNode(double num) { ListNode * = ; ListNode *n; // to traverse the list // trailing node ointer // ski nodes not equal to num, sto at last while ( && ->value!=num) { n = ; // save it! = ->next; // advance it in NumberList.c // not null: num was found, set links + delete if () { if (==) { // oints to the first elem. = ->next; delete ; else { // n oints to the redecessor n->next = ->next; delete ; 25 // set u the list NumberList list; list.aendnode(2.5); list.aendnode(7.9); list.aendnode(12.6); cout << endl << "remove 7.9:" << endl; list.deletenode(7.9); cout << endl << "remove 8.9: " << endl; list.deletenode(8.9); cout << endl << "remove 2.5: " << endl; list.deletenode(2.5); in ListDriver.c Outut: remove 7.9: remove 8.9: remove 2.5: Oeration: insert a node into a linked list! Inserts a new node into the middle of a list.! Uses two extra ointers: - one to oint to node before the insertion oint [why?] - one to oint to the node after the insertion oint [why?] [this one is otional] n Inserting a Node into a Linked List! Insertion comleted: n->next = newnode; newnode->next = ; n newnode newnode

8 Insert Node Algorithm How do you determine the insertion oint?! Maintain sorted list: the insertion oint is immediately before the first node in the list that has a value greater than the value being inserted. We do this.! Insert by osition: InsertNode takes a second argument that is the index of a node. Insert new value before (or after) that node.! Use a cursor: The list class has a member variable that is a ointer to a current node, insert insertnode code void NumberList::insertNode(double num) { in NumberList.c ListNode *newnode; // tr to new node ListNode *; // tr to traverse list ListNode *n; // node revious to //allocate new node newnode = new ListNode; newnode->value = num; // ski all nodes less than num = ; while ( && ->value < num) { n = ; // save = ->next; // advance if ( == ) { = newnode; newnode->next = ; else { n->next = newnode; //insert before first //insert after n new value before (or after) the current node. 29 newnode->next = ; 30 Driver to demo NumberList int main() { in ListDriver.c // set u the list NumberList list; list.aendnode(2.5); list.aendnode(7.9); list.aendnode(12.6); list.insertnode (8.5); list.insertnode (1.5); list.insertnode (21.5); Outut: Advantages of linked lists over arrays! A linked list can easily grow or shrink in size. - Nodes are created in memory as they are needed. - The rogrammer doesn t need to redict how many elements will be in the list.! The amount of memory used to store the list is always roortional to the number of elements in the list. - For arrays, the amount of memory used is often much more than is required by the actual elements in the list.! When a node is inserted into or deleted from a linked list, none of the other nodes have to be 32 moved.

9 Advantages of arrays over linked lists! Arrays allow random access to elements: array[i] - linked lists allow only sequential access to elements (must traverse list to get to i th element).! Exercise: find four errors int main() { struct node { int data; node * next; // create emty list node * list;! Arrays do not require extra storage for links - linked lists are imractical for lists of characters or booleans (ointer value is bigger than data value). // insert six nodes at front of list node *n; for (int i=0;i<=5;i++) { n = new node; n->data = i; n->next = list; 33 // rint list n = list; while (!n) { cout << n->data << " "; n = n->next; cout << endl; 34