List: a sequence of cells in which each cell contains a data item of type Object a reference to the next cell in the sequence (null if this

Transcription

1 Lists 1 Overview Arrays Random access:! Fixed size: cannot grow on demand after creation: " Characteristics of some alications: do not need random access require a data structure that can grow and shrink dynamically to accommodate different amounts of data! (Linked) Lists satisfy this requirement. We study list creation accessing elements in a list inserting elements into a list deleting elements from a list 2 List: a sequence of cells in which each cell contains a data item of tye Object a reference to the next cell in the sequence (null if this is last cell in the sequence) emty list: null List is a sequential-access data structure to access data in osition n of sequence, we must access cells 0..n-1 We will define a class ListCell from which we will build lists. a our symbol for null 1 a -7 a8 a0 lc a8 2 Array: List a2 a /** An instance is a cell of a list, with a value and a name of another cell */ ublic class ListCell { rotected Object datum; // value of cell rotected ListCell next; // name of next cell //(null if none) /** Constructor: cell with value ob and next cell n */ ublic ListCell(Object ob, ListCell n){ /** = the value in this cell */ ublic Object getdatum() {//sometimes called car /** = name of next cell (none if none)*/ ublic ListCell getnext() {// called cdr /** Set value to ob */ ublic void setdatum(object ob) {// called rlaca Class ListCell 24 /** Set next cell to n ublic void setnext(listcell n) {// called rlacd This is how we draw ListCells datum 24 next ListCell ListCell(Object, ListCell) getdatum() getnext() setdatum(object) setnext(listcell) 4 /** Instance: a cell of list, with a value and a name of a cell */ ublic class ListCell { rivate Object datum; // value of cell rivate ListCell next; // name of next cell (null if none) /** Constructor: cell with value ob and next cell n */ ublic ListCell(Object ob, ListCell n) { datum= ob; next= n; /** = the value in this cell */ ublic Object getdatum() { return datum; /** = name of next cell (none if none)*/ ublic ListCell getnext() { return next; /** Set value to ob */ ublic void setdatum(object ob) { datum= ob; /** Set next cell to n ublic void setnext(listcell n) { next= n; Class ListCell 5 // Store in a list 24, -7, Integer t= new Integer(24); Integer s= new Integer(-7); Integer e= new Integer(); ListCell = new ListCell(e,null); = new ListCell(s,); = new ListCell(t,); 24 Building a list Note: assignment of form = new ListCell(s,); does not create a circular list. 6

2 Integer t = new Integer(24); Integer s = new Integer(-7); Integer e = new Integer(); // Store in a list of 24, -7, Building a list Another way: ListCell = new ListCell(t, new ListCell(s, new ListCell(e,null))); 24-7 Accessing list elements Lists are sequential-access data structures. to access the contents of cell n in sequence, you must access cells 0..n-1 Accessing data in first cell:.getdatum() Accessing data in second cell:.getnext().getdatum() Accessing next field in second cell:.getnext().getnext() getDatum().getNext() 8 Accessing list elements Writing to fields in cells can be done the same way //udate data field of first cell.setdatum(new Integer(53)); )); //udate field of second cell.getnext().setdatum(new Integer(53)); //cho off third cell.getnext().setnext(null); 24-7 Access examle: linear search // = ob is in list ublic static boolean search(object ob, ListCell ) { // invariant: c is the name of a cell in list (or null) // ob does not occur before cell c in list for (ListCell c= ; ci!= null; c= c.getnext()) if (c.getdatum().equals(ob)) return true; // { ob is not in the list return false; Recursion on lists Recursion can be done on lists in a manner similar to recursion on integers. Almost always base case: emty list recursive case: assuming you can solve roblem on (smaller) list obtained by eliminating first cell, write down solution for list Many list roblems can be solved very simly by using this idea. Some roblems, though, are easier to solve iteratively. Recursion examle: linear search Base case: emty list return false Recursive case: non-emty list if data in first cell equals object ob, return true else return result of doing linear search on rest of list // = ob occurs in list */ ublic static boolean recsearch(object ob, ListCell ) { if ( == null) return false; return.getdatum().equals(ob) recsearch(ob,.getnext()); 11 12

3 Some refer to use a class List that is distinct from class ListCell. A List object is like a element that always exists even if list itself is emty. /** An instance is a list with a er */ class List { rivate ListCell ; /** Constructor: an instance is a list List with er ublic List (ListCell ) {= ; /** = the first value of list (0 if none) ublic ListCell gethead() { /** Set list to */ ublic void sethead(listcell ) { Variations of list with er Header can kee other info, e.g. reference to last cell of list number of elements in list search/insertion/ deletion as instance methods 2 b2 b2 tail 3 c3 c3 size 3 What you ut in a er deends on the alication. search(ob) Examle of use of class List We write code to insert object into unsorted list delete the first occurrence of an object in an unsorted list. We use the class List to show how to use this class. It is just as easy to write code without the er element. Methods for insertion/deletion will be instance methods in class List. // insert ob into front of this list ublic void inserthead(object ob); // insert ob into front of this list ublic void inserttail(object ob); // delete ob from this list (if it is there) ublic void delete(object ob); 15 Insertion into tail of list ublic class List{ rivate ListCell ; ublic void inserthead(object ob) { = new ListCell(ob,).insertHead(new Integer(6)); a8 a Insertion into Tail of list ublic class List{.insertTail(new Integer(6)); rivate ListCell ; ublic void inserttail(object ob) { if ( == null) = new ListCell(ob, null) else { // Store in c the name of the tail of the list ListCell= ; while (c.getnext()!= null) a9 c= c.getnext(); 6 c.setnext(new ListCell(ob, null)); 24-7 a9 17 List = new List(null); Examle of use of insert methods //List is emty.inserthead(new Integer(-7)); // contains -7.insertHead(new Integer(24)); // contains 24, -7.insertTail(new Integer()); // contains 24, -7,

4 Remove first item from list /** remove and return the first element of this list. Throw RuntimeExcetion if this list is emty. */ ublic Object deletefirst(){ if ( == null) { throw new RuntimeExcetion( List is emty ); Object t=.getdatum(); =.getnext(); return t; Cases: list is emty: throw an excetion Remove and return last item from list list contains one element: change list contains >2 elements: change next-to-last element null /** List size >= 2. Return name of enultimate element */ rivate Object getpenultimate() { ListCell c= ; ListCell scout=.getnext(); /** invariant: c is name of a cell of the list, c.getnext() is not null, scout is the next cell following c */ while (scout.getnext()!= null){ c= scout; scout= scout.getnext(); return c; 24-7 Finding enultimate element of list enultimate means next to last Remove and return last item from list /** remove and return last element of list. Throw RuntimeExcetion if list is emty */ ublic Object deletelast(){ if ( == null) throw new RuntimeExcetion( list is emty ); if (.getnext() == null) { Object t=.getdatum(); = null; return t; // { list contains at least two elements ListCell enultimate= getpenultimate; ListCell last= enultimate.getnext(); enultimate.setnext(null); return last.getdatum(); Delete object from list Delete first occurrence of an object ob from a list. Idea of recursive code: If list is emty, return null. If first element of is ob, return rest of list. Otherwise, return list consisting of first element of, and the list that results from deleting from the rest of list ublic class List{ Recursive code for delete rivate ListCell ; // Delete first occur. of ob from list (if it is there) ublic void delete(object ob) { = deleterec(ob, ); // = list lc but with first occur. of ob deleted (if there) rivate static ListCell deleterec(object ob, ListCell lc) { if (lc == null) return null; // handle emty list // { list lc is not emty if (l.getdatum().equals(ob)) return lc.getnext(); // { first element of lc is not ob lc.setnext(deleterec(ob, lc.getnext())); return l; 24

5 /** First element of list c is not ob. Return name of element that recedes ob (or null if none) */ rivate Object getob(listcell c, Object ob) { ListCell scout=.getnext(); /** invariant: c is name of a cell of the list, c.getdatum() is not ob. Finding elem element of list scout is name of next element (null if none) */ while (scout!= null &&!scout.getdatum().equals(ob)){ c= scout; scout= scout.getnext(); if (scout == null) return null; return c; 24-7 // Delete ob from list, if there ublic void delete(object ob) { if ( == null) return; // If first element is ob, remove it and return if (.getdatum().equals(o)) { =.getnext(); return; // { First element of list is not ob ListCell receding= getob(, ob); if (receding == null) return; //slice out cell containing ob receding.setnext(receding.getnext()); Iterative code for delete Insertion and deletion with sorted lists Assume that we have a list of Comarables sorted in increasing order. We want to slice a new Comarable into this list, keeing new list in sorted order as shown in figure. Code shows recursive code for insertion and deletion. We show code that uses class ListCell directly Use notation [f,n] to denote ListCell whose datum is f next is n Recursive insertion Pseudo-code: insert (Comarable c, ListCell l): if l is null return new ListCell(c,null); else suose l is [f,n] if (c < f) return new ListCell(c,l); else return new ListCell(f, insert(c,n)); Comactly: insert(c,null) = [c,null] insert(c,[f,n]) = [c,[f,n]] if c < f [f, insert(c,n)] if c >= f /** lc is a sorted list. Insert c into it */ ublic static ListCell insert(comarable c, ListCell lc) { if (lc == null) return new ListCell(c, lc); // { list has at least one element if (c.comareto(lc.getdatum()) < 0) return new ListCell(c, lc); // { first element of list is > c lc.setnext(insert(c,lc.getnext())); return lc; /** List lc is sorted. Delete first occ. of c from it (if there) */ ublic static ListCell delete(comarable c, ListCell lc) { if ((l == null) return null; if (c.comareto(lc.getdatum()) < 0) return lc; if (c.comareto(lc.getdatum()) == 0) return lc.getnext(); lc.setnext(delete(c,lc.getnext())); return lc; 29 30

6 Exercises 1. Write insert into a sorted list without recursion. 2. Write delete from a sorted list without recursion. Doubly-linked lists In some alications, it is convenient to have a ListCell that references both its redecessor and its successor in the list. ublic class DLLCell { rivate Object datum; rivate DLLCell next; rivate DLLCell revious; In general, it is easier to work with doubly-linked lists than with lists. For examle, reversing a DLL can be done simly by swaing the revious and next fields of each cell. Trade-off: DLLs require more sace than singly-linked lists. 33 Summary Lists are sequences of ListCell elements recursive data structure grow and shrink on demand not random-access but sequential access data structures List oerations: create a list access a list and udate data change structure of list by inserting/deleting cells cursors Recursion makes erfect sense on lists. Usually base case: emty list, erhas one-element list also recursive case: non-emty list Sub-secies of lists list with er doubly-linked lists 34