index.pdf March 17,

Transcription

1 index.pdf March 17, ITI Introduction to omputing II Marce Turcotte Schoo of Eectrica Engineering and omputer Science Linked List (Part 2) Tai pointer ouby inked ist ummy node Version of March 17, 2013 bstract Time efficiency ompare the time efficiency of the dynamic array (rraylist) and inked ist (LinkedList) impementations of the interface List (both aow to store an unimited number of objects). Let say that execution time of a method is variabe (sow) if the number of operations depends on the number of eements currenty stored in the data structure, and constant (fast) otherwise. These ecture notes are meant to be ooked at on a computer screen. o not print them uness it is necessary. Time efficiency an you predict an overa winner beforehand? rraylist LinkedList void addfirst( E o ) sow fast void addlast( E o ) sow sow void add( E o, int pos ) sow sow E get( int pos ) fast sow void removefirst() sow fast void removelast() fast sow ased on the above tabe, when woud you use an array? ppications that need a direct (random) access to the eements. ased on the above tabe, when woud you use a singy-inked ist? ppications that add or remove eements at the start of the ist ony. Which impementation is more memory efficient? Speeding up addlast for SingyLinkedList There is a simpe impementation technique that makes adding an eement at the end of a ist fast. The probem with the singy inked ist impementation is that one needs to traverse the data structure to access the ast eement. What if we coud aways access the ast eement efficienty as we do for the first eement. Got the idea? Yes, adding an instance variabe pointing to the tai eement wi sove our probem. Representing an empty ist: tai Genera case: tai pubic cass SingyLinkedList<E> impements List<E> { private static cass Node<T> { private T ; private Node<T> ; private Node( T, Node<T> ) { this. = ; this. = ; private Node<E> ; private Node<E> tai; //... This invoves adding a new instance variabe, tai.

2 index.pdf March 17, pubic void addlast( E t ) { pubic E removefirst() { Node<E> newnode = new Node<E>( t, nu ); if ( == nu ) { = newnode; tai = ; ese { tai. = newnode; tai = tai.; Node<E> nodetoeete = ; E resut = nodetoeete.; =.; nodetoeete. = nu; // scrubbing nodetoeete. = nu; if ( == nu ) { tai = nu; return resut; The methods need to be modified accordingy! Time efficiency (revision 1) rraylist LinkedList void addfirst( E o ) sow fast void addlast( E o ) sow fast void add( E o, int pos ) sow sow E get( int pos ) fast sow void removefirst() sow fast void removelast() fast sow How about removing the ast eement of the ist? It s sti sow. Speeding up removelast() Maintaining a reference to the ast eement of the ist does not make the remova of the ast eement any faster, we sti have to traverse the ist: tai nodeeforethelast What s needed then? How about a new instance variabe ious? Speeding up removelast() Speeding up removelast() ious ious tai tai What do you think? Moving the reference tai one position to eft is now easy and fast! ut moving the reference ious one position to the eft is now tedious and costy.

3 We d need to access the ious eement, the one before the ast: ut aso to a its predecessors! 10:10:00 tai tai Empty ist: tai Singeton: tai Genera case: pubic cass oubylinkedlist<e> impements List<E> { private static cass Node<T> { private T ; private Node<T> ious; // <--- private Node<T> ; private Node( T, Node<T> ious, Node<T> ) { this. = ; this.ious = ious; // <--- this. = ; private Node<E> ; private Node<E> tai; pubic oubylinkedlist() { = nu; tai = nu; //... removelast() (specia case: singeton) removelast() (genera case) pubic E removelast() { // pre-condition:? Node<E> toeete = tai; E savedvaue = toeete.; if (. == nu ) { = nu; tai = nu; ese { tai = tai.ious; tai. = nu; toeete. = nu; toeete. = nu; return savedvaue; removelast() does not invove traversing the ist anymore. index.pdf March 17,

4 index.pdf March 17, Time efficiency (revision 2) Simpe? Not so simpe? rraylist LinkedList void addfirst( E o ) sow fast void addlast( E o ) sow fast void add( E o, int pos ) sow sow E get( int pos ) fast sow void removefirst() sow fast void removelast() fast fast Whenever an operation changes the pointer, a specia case has to be made. Pre-conditions? Specia case(s)? if ( o == nu ) { throw new IegargumentException( "nu" ); if ( pos < 0 ) { throw new IndexOutOfoundsException( Integer.toString( pos ) ); tai dding an eement a position 0. Specia case: = new Node<E>( o, nu, ) Specia case:..ious = tai tai What is missing?

5 index.pdf March 17, Specia case: if ( pos == 0 ) { Specia case: if (pos == 0) { = new Node<E>( o, nu, );..ious = ; oes cover a the cases? What if the ist was empty. = new Node<E>( o, nu, ); if ( tai == nu ) { tai = ; ese {..ious = ; Genera case: adding an eement at position 2. Genera case: traverse the ist up to pos-1. tai tai p Genera case: q = p. Genera case: p. = new Node<E>( o, p, q ) tai tai p q p q

6 index.pdf March 17, Genera case: q.ious = p. Genera case: Node<E> p = ; tai for (int i = 0; i < (pos-1); i++) { p = p.; Node<E> q = p.; p q p. = new Node<E>( o, p, q ); q.ious = p.; Handes a the cases? What if pos was too arge? Genera case: Node<E> p = ; for (int i = 0; i < (pos-1); i++) { if ( p == nu ) { throw new IndexOutOfoundsException( Integer.toString( pos ) ); ese { p = p.; Node<E> q = p.; p. = new Node<E>( o, p, q ); q.ious = p.; Handes a the cases? What about adding at the end of the ist? Node<E> p = ; for (int i = 0; i < (pos-1); i++) { if ( p == nu ) { throw new IndexOutOfoundsException( Integer.toString( pos ) ); ese { p = p.; Node<E> q = p.; p. = new Node<E>( o, p, q ); if ( p == tai ) { tai = p.; ese { q.ious = p.; ummy node The empty ist consists of the dummy node pointing to itsef. The foowing impementation techniques simpifies those cases. It consists in 1) using a dummy node (a node that contains no data) as the first eement of the ist and 2) creating a circuar ist. Genera case: F

7 index.pdf March 17, pubic cass SingyLinkedList<E> impements List<E> { private static cass Node<T> { private T ; private Node<T> ; private Node( T, Node<T> ) { this. = ; this. = ; private Node<E> ; pubic SingyLinkedList() { = new Node<E>( nu, nu );. = ; //... // assic singy inked-ist impementation pubic void add( E t ) { Node<E> newnode = new Node<E>(t, nu); if ( == nu ) = newnode; ese { Node<E> p = ; whie ( p.!= nu ) { p = p.; p. = newnode; ummy node (addlast) The new eement wi be added after a node such that... // ummy node impementation pubic void add( E t ) { Node<E> p = ; whie ( p.!= ) { p = p.; p. = new Node<E>( t, ); F Remarks (dummy node) What makes the impementation of the methods more compex in the case of a inked ist without dummy node? Modifications of the of the ist are specia cases (remove, addfirst, addlast,... ). In the genera case, the variabe of the ious node is changed, except if the modification occurs at the first position, then the variabe must be changed. 0 1 With the dummy node, it is aways the variabe of the ious node that is changed. The nodes coud aso be douby inked, and there coud be a counter in the er of the ist. 3 F

8 index.pdf March 17, oection Framework In Java the casses that are used to store objects are regrouped into a hierarchy of casses caed oection. There are four broad categories of coections: unordered. inear, hierarchica, graph and tai Linear coections comprise the ists, the stacks and the queues. Eements of a inear coection a have a specific predecessor and successor(except for the first and ast eement). Hierarchica coections aow to represent various kinds of trees: e.g.: geneaogica information. The graph coections are used to store directed, undirected, weighted and unweighted graphs: e.g.: a graph that represents a the cities in anada and their distances. Unordered coections incude sets, bags and maps. 0 1 F 3