l A data structure representing a list l A series of dynamically allocated nodes l A separate pointer (the head) points to the first

Transcription

1 Liked Lists Week 8 Gaddis: Chater 17 CS 5301 Srig 2018 Itroductio to Liked Lists l A data structure reresetig a list l A series of dyamically allocated odes chaied together i sequece - Each ode oits to oe other ode. l A searate oiter (the ) oits to the first item i the list. l The last elemet oits to othig () Jill Seama 1 2 l Each ode cotais: Node Orgaizatio - data field may be a structure, a object, etc. - a oiter that ca oit to aother ode data oiter l We use a struct to defie the ode tye: struct ListNode { double value; ListNode *ext; ; l ext ca hold the address of a ListNode. 3 - it ca also be Defiig the Liked List variable l Defie a oiter for the of the list: ListNode * = ; l Now we have a emty liked list: l is equivalet to address 0 // secifies ed of list l to test a oiter for (these are equivalet): while ()... <==> while (!= ) if (!)... <==> if ( == )... Note: If you try to dereferece a oiter whose value is, you will get a rutime error. For examle: ->ext Check before you do this. 4 static it getobjectcout();

2 Liked List oeratios l Basic oeratios: - create a ew, emty list - aed a ode to the ed of the list - isert a ode withi the list - delete a ode - dislay the liked list - delete/destroy the list 5 l Liked List class declaratio #iclude <cstddef> // for usig amesace std; class NumberList { rivate: struct ListNode // the ode data tye { double value; // data ListNode *ext; // tr to ext ode ; ListNode *; // the list ; ublic: NumberList() = { = ; //create emty list ~NumberList(); void aednode(double); void isertnode(double); void deletenode(double); void dislaylist(); 6 static it getobjectcout(); Oeratio: aed ode to ed of list aednode: fid last elem l aednode: adds ew ode to ed of list l Algorithm: Create a ew ode ad store the data i it If the list has o odes (it s emty) Make oit to the ew ode. Else Fid the last ode i the list Make the last ode oit to the ew ode Whe defiig list oeratios, always cosider secial cases: Emty list First elemet, frot of the list (whe oiter is ivolved) 7 l How to fid the last ode i the list? l Algorithm: Make a oiter oit to the first elemet while the ode oits to has a NEXT ode make oit to that ode (the NEXT ode of the ode curretly oits to) l I C++: ListNode * = ; while ((*).ext!= ) = (*).ext; <==> ListNode * = ; while (->ext) = ->ext; =->ext is like i++ 8 ListNode * = ;

3 void NumberList::aedNode(double um) { ListNode *ewnode; // To oit to the ew ode // Create a ew ode ad store the data i it ewnode = ew ListNode; ewnode->value = um; ewnode->ext = ; // If emty, make oit to ew ode if (==) = ewnode; Traversig a Liked List l Visit each ode i a liked list, to - dislay cotets, sum data, test data, etc. l Basic rocess: else { ListNode *; // To move through the list = ; // iitialize to start of list // traverse list to fid last ode while (->ext) //it s ot last = ->ext; //make it t to ext // ow ts to last ode // make last ode oit to ewnode ->ext = ewnode; set a oiter to oit to what oits to while oiter is ot rocess data of curret ode go to the ext ode by settig the oiter to the ext field of the curret ode ed while 9 10 void NumberList::dislayList() { ListNode *; //tr to traverse the list Oeratio: dislay the list // start at the of the list = ; // while ts to somethig (ot ), cotiue while () { //Dislay the value i the curret ode cout << ->value << ; //Move to the ext ode = ->ext; cout << edl; Or the short versio: void NumberList::dislayList() { for (ListNode * = ; ; = ->ext) cout << ->value << ; cout << edl; 11 Destroyig a Liked List: destructor l The destructor must delete (deallocate) all odes used i the list l To do this, use list traversal to visit each ode: - save the address of the ext ode i a oiter - delete the ode NumberList::~NumberList() { ListNode *; // traversal tr ListNode *; // saves the ext ode = ; //start at of list while () { = ->ext; // save the ext delete ; // delete curret = ; // advace tr 12

4 Oeratio: delete a ode from the list l deletenode: removes ode from list, ad deletes (deallocates) the removed ode. l Requires two extra oiters: - oe to oit to the ode to be deleted - oe to oit to the ode before the ode to be deleted. Deletig a ode l Chage the oiter of the revious ode to oit to the ode after the oe to be deleted. l The just delete the ode ->ext = ->ext; delete ; 5 19 Deletig 13 from the list Delete Node Algorithm Liked List fuctios: deletenode l Delete the ode cotaiig um use to traverse the list, util it oits to um or --as is advacig, make oit to the ode before it if ( is ot ) //foud! if (==) //it s the first ode, ad is garbage make oit to the secod elemet delete s ode (the first ode) else make s ode oit to what s ode oits to delete s ode void NumberList::deleteNode(double um) { ListNode * = ; ListNode *; // to traverse the list // trailig ode oiter (revious) // ski odes ot equal to um, sto at last while ( && ->value!=um) { = ; // save it! = ->ext; // advace it // ot ull: um is foud, set liks + delete if () { if (==) { // oits to the first elem, is garb = ->ext; delete ; else { // oits to the redecessor ->ext = ->ext; delete ; else:... is, ot foud do othig 15 16

5 Oeratio: isert a ode ito a liked list l Iserts a ew ode ito the middle of a list. l Uses two extra oiters: - oe to oit to ode before the isertio oit - oe to oit to the ode after the isertio oit [this oe is otioal] Isertig a Node ito a Liked List l Isertio comleted: ->ext = ewnode; ewnode->ext = ; 17 ewnode ewnode Isert Node Algorithm l Isert ode i a certai ositio Create the ew ode, store the data i it Use oiter to traverse the list, util it oits to: ode after isertio oit or --as is advacig, make oit to the ode before if oits to first ode ( is, was ot set) make oit to ew ode make ew ode oit to s ode else make s ode oit to ew ode make ew ode oit to s ode isertnode code void NumberList::isertNode(double um) { ListNode *ewnode; // tr to ew ode ListNode *; // tr to traverse list ListNode *; // ode revious to //allocate ew ode ewnode = ew ListNode; ewnode->value = um; // ski all odes less tha um = ; while ( && ->value < um) { = ; // save = ->ext; // advace What if um is bigger tha all items i the list? if ( == ) { //isert before first, or emty list = ewnode; ewnode->ext = ; else { //isert after ->ext = ewnode; Note: we will assume our list is sorted, so the isertio oit is immediately before the first ode that is larger tha the umber beig iserted. 19 ewnode->ext = ; 20

6 l Doubly liked list Liked List variatios - each ode has two oiters, oe to the ext ode ad oe to the revious ode - oits to first elemet, tail oits to last. rivate: // Structure for odes struct Node { it value; // Value i the ode Node *rev; // Poiter to the revious ode Node *ext; // Poiter to the ext ode ; Node *; // Poiter to the first elemet Node *tail; // Poiter to the last elemet l Circular liked list Liked List variatios - last cell s ext oiter oits to the first elemet. - o ull oiters - every ode has a successor list tail Liked lists vs Arrays (ros ad cos) l A liked list ca easily grow or shrik i size. - No maximum caacity required - No eed to resize+coy whe list reaches max size. l Whe a value is iserted ito or deleted from a liked list, o other odes have to be moved. l Arrays allow radom access to elemets: array[i] (liked lists require traversal to get i th elemet). l Arrays do ot require extra storage for liks (liked lists are imractical whe the oiter value is bigger tha data value). 23