Johdanto

1. Johdanto • Dynaamiset tietorakenteet • Rakenteiden tilavaraus laajenee/pienenee ajonaikaisesti. • Rakenteita on useita tyyppejä • Linkitetty lista • Pino • Jono • Binääripuu • Näistä käsitellään tänään teoriana linkitetyn listan toiminta. Vastaava käytännön toteutus on Javan ArrayList-luokka. Kalvot käännetty & muokattu kirjan Deitel & Deitel: Java How to Program 5th edition kalvoista. ict02d

2. Itseensä viittaavat (Self-Referential) luokat • Itseensä viittaava luokka • Sisältää attribuutin, joka on viittausmuuttuja saman luokan toiseen olioon. class Solmu {private int data;private Solmu seuraavaSolmu; // viittaa seuraavaan solmuun} • Attribuutti seuraavaSolmu on linkki • seuraavaSolmu “linkittää” Solmu–olion toiseen Solmu –olioon. ict02d

3. Itseensä viittaavat (Self-Referential) luokat 15 10 Kuva 1. Itseensä viittaavan luokan kaksi toisiinsa linkitettyä oliota. ict02d

4. Dynaaminen muistin varaaminen • Dynaaminen muistin varaaminen • Hankitaan ajonaikaisesti lisää muistia ohjelman käyttöön uusien olioiden varastoimiseen. • Tapahtuu määrittelemällä viittausmuuttuja ja luomalla uusi olio: Solmu uusiSolmu = new Solmu ( 10 ); ict02d

5. Linkitetyt listat • Linkitetty lista on lineaarinen kokoelma itseensä viittaavan luokan olioita, solmuja (nodes) • Oliot liittyvät toisiinsa viittausmuuttujien (“linkkien”) kautta • Solmuja voidaan lisätä mihin tahansa kohtaa linkitettyä listaa • Solmuja voidaan poistaa mistä tahansa linkitetyn listan kohdasta • Viimeisen solmun linkin arvo on null listan päättymisen merkkinä ict02d

6. Linkitetyt listat viimeinenSolmu ekaSolmu ... Q H D Kuva 2. Linkitetty lista. ict02d

7. Linkitetyt listat (a) firstNode 7 11 new Listnode 12 (b) firstNode 7 11 new Listnode 12 Kuva 6. insertAtFront-metodi graafisesti esitettynä ict02d

8. Linkitetyt listat (a) firstNode lastNode new Listnode 12 7 11 5 (b) firstNode lastNode new Listnode 12 7 11 5 Kuva 7. insertAtBack-metodi graafisesti esitettynä. ict02d

9. 12 7 11 5 Linkitetyt listat (a) firstNode lastNode (b) firstNode lastNode 12 7 11 5 removeItem Kuva 8. removeFromFront-metodi graafisesti esitettynä. ict02d

10. 12 7 11 5 Linkitetyt listat (a) firstNode lastNode (b) firstNode current lastNode 12 7 11 5 removeItem Kuva 9. removeFromBack.-metodi graafisesti esitettynä. ict02d

11. Itseensä viittaava luokka ListNode sisältää attribuutit data (olio-viittaus) ja nextNode (linkki seuraavaan solmuun) 1 // Fig. 20.3: List.java 2 // ListNode and List class declarations. 3 package com.deitel.jhtp5.ch20; 4 5 // class to represent one node in a list 6 class ListNode { 7 8 // package access members; List can access these directly 9 Object data; 10 ListNode nextNode; 11 12 // create a ListNode that refers to object 13 ListNode( Object object ) 14 { 15 this( object, null ); 16 } 17 18 // create ListNode that refers to Object and to next ListNode 19 ListNode( Object object, ListNode node ) 20 { 21 data = object; 22 nextNode = node; 23 } 24 25 // return reference to data in node 26 Object getObject() 27 { 28 return data; // return Object in this node 29 } 30 List.java

12. Attribuutti, joka on viittaus listan ensimmäiseen solmuun. Attribuutti, joka on viittaus listan viimeiseen solmuun. Tyhjän listan ensimmäisen ja viimeisen solmun viittaukset saavat arvon null 31 // return reference to next node in list 32 ListNode getNext() 33 { 34 return nextNode; // get next node 35 } 36 37 } // end class ListNode 38 39 // class List declaration 40 publicclass List { 41 private ListNode firstNode; 42 private ListNode lastNode; 43 private String name; // string like "list" used in printing 44 45 // construct empty List with "list" as the name 46 public List() 47 { 48 this( "list" ); 49 } 50 51 // construct an empty List with a name 52 public List( String listName ) 53 { 54 name = listName; 55 firstNode = lastNode = null; 56 } 57 58 // insert Object at front of List 59 publicvoid insertAtFront( Object insertItem ) 60 { List.java

13. Jos tyhjän listan alkuun lisätään solmu, viittaavat molemmat attribuutit lisättyyn solmuun. Jos lista ei ollut tyhjä, asetetaan firstNode viittaamaan lisättyyn solmuun. Jos tyhjän listan loppuun lisätään solmu, viittaavat molemmat attribuutit lisättyyn solmuun. Jos lista ei ollut tyhjä, asetetaan lastNode viittaamaan lisättyyn solmuun. Solmun poistoyritys tyhjästä listasta aiheuttaa poikkeuksen. 61 if ( isEmpty() ) // firstNode and lastNode refer to same object 62 firstNode = lastNode = new ListNode( insertItem ); 63 64 else// firstNode refers to new node 65 firstNode = new ListNode( insertItem, firstNode ); 66 } 67 68 // insert Object at end of List 69 publicvoid insertAtBack( Object insertItem ) 70 { 71 if ( isEmpty() ) // firstNode and lastNode refer to same Object 72 firstNode = lastNode = new ListNode( insertItem ); 73 74 else// lastNode's nextNode refers to new node 75 lastNode = lastNode.nextNode = new ListNode( insertItem ); 76 } 77 78 // remove first node from List 79 public Object removeFromFront() throws EmptyListException 80 { 81 if ( isEmpty() ) // throw exception if List is empty 82 thrownew EmptyListException( name ); 83 84 Object removedItem = firstNode.data; // retrieve data being removed 85 86 // update references firstNode and lastNode 87 if ( firstNode == lastNode ) 88 firstNode = lastNode = null; 89 else 90 firstNode = firstNode.nextNode; List.javaLines 61-62Line 65Lines 71-72Line 74Lines 81-82

14. Solmun poistoyritys tyhjästä listasta aiheuttaa poikkeuksen. Jos lista ei ollut tyhjä tai yhden solmun mittainen, tulee toiseksi viimeisestä solmusta viimeinen solmu. 91 92 return removedItem; // return removed node data 93 94 } // end method removeFromFront 95 96 // remove last node from List 97 public Object removeFromBack() throws EmptyListException 98 { 99 if ( isEmpty() ) // throw exception if List is empty 100 thrownew EmptyListException( name ); 101 102 Object removedItem = lastNode.data; // retrieve data being removed 103 104 // update references firstNode and lastNode 105 if ( firstNode == lastNode ) 106 firstNode = lastNode = null; 107 108 else { // locate new last node 109 ListNode current = firstNode; 110 111 // loop while current node does not refer to lastNode 112 while ( current.nextNode != lastNode ) 113 current = current.nextNode; 114 115 lastNode = current; // current is new lastNode 116 current.nextNode = null; 117 } 118 119 return removedItem; // return removed node data 120 121 } // end method removeFromBack List.java

15. Läpikäydään lista ja tulostetaan solmujen arvot 122 123 // determine whether list is empty 124 publicboolean isEmpty() 125 { 126 return firstNode == null; // return true if List is empty 127 } 128 129 // output List contents 130 publicvoid print() 131 { 132 if ( isEmpty() ) { 133 System.out.println( "Empty " + name ); 134 return; 135 } 136 137 System.out.print( "The " + name + " is: " ); 138 ListNode current = firstNode; 139 140 // while not at end of list, output current node's data 141 while ( current != null ) { 142 System.out.print( current.data.toString() + " " ); 143 current = current.nextNode; 144 } 145 146 System.out.println( "\n" ); 147 } 148 149 } // end class List List.java

16. Poikkeus, joka syntyy jos tyhjästä listasta yritetään poistaa solmu. 1 // Fig. 20.4: EmptyListException.java 2 // Class EmptyListException declaration. 3 package com.deitel.jhtp5.ch20; 4 5 public class EmptyListException extends RuntimeException { 6 7 // no-argument constructor 8 public EmptyListException() 9 { 10 this( "List" ); // call other EmptyListException constructor 11 } 12 13 // constructor 14 public EmptyListException( String name ) 15 { 16 super( name + " is empty" ); // call superclass constructor 17 } 18 19 } // end class EmptyListException EmptyListException.java

17. Luodaan linkitetty lista. Luodaan arvot (oliot), jotka talletetaan solmuihin. Lisätään listaan solmut edellä luoduin arvoin. 1 // Fig. 20.5: ListTest.java 2 // ListTest class to demonstrate List capabilities. 3 import com.deitel.jhtp5.ch20.List; 4 import com.deitel.jhtp5.ch20.EmptyListException; 5 6 publicclass ListTest { 7 8 publicstaticvoid main( String args[] ) 9 { 10 List list = new List(); // create the List container 11 12 // objects to store in list 13 Boolean bool = Boolean.TRUE; 14 Character character = new Character( '$' ); 15 Integer integer = new Integer( 34567 ); 16 String string = "hello"; 17 18 // insert references to objects in list 19 list.insertAtFront( bool ); 20 list.print(); 21 list.insertAtFront( character ); 22 list.print(); 23 list.insertAtBack( integer ); 24 list.print(); 25 list.insertAtBack( string ); 26 list.print(); 27 ListTest.java

18. Poistetaan solmuja. 28 // remove objects from list; print after each removal 29 try { 30 Object removedObject = list.removeFromFront(); 31 System.out.println( removedObject.toString() + " removed" ); 32 list.print(); 33 34 removedObject = list.removeFromFront(); 35 System.out.println( removedObject.toString() + " removed" ); 36 list.print(); 37 38 removedObject = list.removeFromBack(); 39 System.out.println( removedObject.toString() + " removed" ); 40 list.print(); 41 42 removedObject = list.removeFromBack(); 43 System.out.println( removedObject.toString() + " removed" ); 44 list.print(); 45 46 } // end try block 47 48 // catch exception if remove is attempted on an empty List 49 catch ( EmptyListException emptyListException ) { 50 emptyListException.printStackTrace(); 51 } 52 } 53 54 } // end class ListTest

19. The list is: true The list is: $ true The list is: $ true 34567 The list is: $ true 34567 hello $ removed The list is: true 34567 hello true removed The list is: 34567 hello hello removed The list is: 34567 34567 removed Empty list ListTest.javaOhjelman tuloste.