Transcript Johdanto - HAAGA

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
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
Itseensä viittaavat
(Self-Referential) luokat
15
10
Kuva 1. Itseensä viittaavan luokan kaksi toisiinsa linkitettyä oliota.
ict02d
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
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
Linkitetyt listat
viimeinenSolmu
ekaSolmu
H
D
Kuva 2. Linkitetty lista.
ict02d
...
Q
Linkitetyt listat
(a)
firstNode
7
11
new Listnode
12
(b)
firstNode
7
11
new Listnode
12
Kuva 6. insertAtFront-metodi graafisesti esitettynä
ict02d
Linkitetyt listat
(a)
firstNode
12
(b)
lastNode
7
firstNode
12
11
lastNode
7
11
new Listnode
5
new Listnode
5
Kuva 7. insertAtBack-metodi graafisesti esitettynä.
ict02d
Linkitetyt listat
(a)
firstNode
12
(b)
lastNode
7
11
firstNode
12
5
lastNode
7
11
5
removeItem
Kuva 8. removeFromFront-metodi graafisesti esitettynä.
ict02d
Linkitetyt listat
(a)
firstNode
12
(b)
lastNode
7
firstNode
12
11
current
7
5
lastNode
11
5
removeItem
Kuva 9. removeFromBack.-metodi graafisesti esitettynä.
ict02d
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// Fig. 20.3: List.java
// ListNode and List class declarations.
package com.deitel.jhtp5.ch20;
// class to represent one node in a list
class ListNode {
// package access members; List can access these directly
Object data;
ListNode nextNode;
// create a ListNode that refers to object
ListNode( Object object )
{
this( object, null );
}
// create ListNode that refers to Object and to next ListNode
ListNode( Object object, ListNode node )
{
data = object;
nextNode = node;
}
// return reference to data in node
Object getObject()
{
return data; // return Object in this node
}
List.java
Itseensä viittaava luokka
ListNode sisältää
attribuutit data (olioviittaus) ja nextNode
(linkki seuraavaan solmuun)
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
// return reference to next node in list
ListNode getNext()
{
return nextNode; // get next node
}
} // end class ListNode
// class List declaration
public class List {
private ListNode firstNode;
private ListNode lastNode;
private String name; // string like "list" used in printing
// construct empty List with "list" as the name
public List()
{
this( "list" );
}
// construct an empty List with a name
public List( String listName )
{
name = listName;
firstNode = lastNode = null;
}
// insert Object at front of List
public void insertAtFront( Object insertItem )
{
List.java
Attribuutti, joka on
viittaus listan
ensimmäiseen
Attribuutti, joka on
solmuun.
viittaus listan
viimeiseen
solmuun.
Tyhjän listan
ensimmäisen ja
viimeisen solmun
viittaukset saavat arvon
null
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
Jos tyhjän listan alkuun
lisätään solmu, viittaavat
molemmat attribuutit lisättyyn
List.java
solmuun.
if ( isEmpty() ) // firstNode and lastNode refer to same object
firstNode = lastNode = new ListNode( insertItem );
else // firstNode refers to new node
firstNode = new ListNode( insertItem, firstNode );
}
Jos lista ei ollut
Linestyhjä,
61-62asetetaan
firstNode viittaamaan lisättyyn
solmuun.
Line 65
// insert Object at end of List
public void insertAtBack( Object insertItem )
{
if ( isEmpty() ) // firstNode and lastNode refer to same Object
Jos
firstNode = lastNode = new ListNode( insertItem );
else // lastNode's nextNode refers to new node
lastNode = lastNode.nextNode = new ListNode( insertItem );
}
// remove first node from List
public Object removeFromFront() throws EmptyListException
{
if ( isEmpty() ) // throw exception if List is empty
throw new EmptyListException( name );
tyhjän listan
Linesloppuun
71-72 lisätään
solmu, viittaavat molemmat
attribuutitLine
lisättyyn
74 solmuun.
Jos lista eiLines
ollut81-82
tyhjä, asetetaan
lastNode viittaamaan
lisättyyn solmuun.
Solmun poistoyritys tyhjästä
listasta aiheuttaa poikkeuksen.
Object removedItem = firstNode.data; // retrieve data being removed
// update references firstNode and lastNode
if ( firstNode == lastNode )
firstNode = lastNode = null;
else
firstNode = firstNode.nextNode;
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
return removedItem; // return removed node data
} // end method removeFromFront
// remove last node from List
public Object removeFromBack() throws EmptyListException
{
if ( isEmpty() ) // throw exception if List is empty
throw new EmptyListException( name );
Object removedItem = lastNode.data; // retrieve data being
List.java
Solmun poistoyritys
tyhjästä listasta aiheuttaa
removedpoikkeuksen.
// update references firstNode and lastNode
if ( firstNode == lastNode )
firstNode = lastNode = null;
else { // locate new last node
ListNode current = firstNode;
// loop while current node does not refer to lastNode
while ( current.nextNode != lastNode )
current = current.nextNode;
lastNode = current; // current is new lastNode
current.nextNode = null;
}
return removedItem; // return removed node data
} // end method removeFromBack
Jos lista ei ollut tyhjä tai yhden
solmun mittainen, tulee toiseksi
viimeisestä solmusta viimeinen
solmu.
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
// determine whether list is empty
public boolean isEmpty()
{
return firstNode == null; // return true if List is empty
}
// output List contents
public void print()
{
if ( isEmpty() ) {
System.out.println( "Empty " + name );
return;
}
System.out.print( "The " + name + " is: " );
ListNode current = firstNode;
Läpikäydään lista ja tulostetaan
solmujen arvot
// while not at end of list, output current node's data
while ( current != null ) {
System.out.print( current.data.toString() + " " );
current = current.nextNode;
}
System.out.println( "\n" );
}
} // end class List
List.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// Fig. 20.4: EmptyListException.java
// Class EmptyListException declaration.
package com.deitel.jhtp5.ch20;
public class EmptyListException extends RuntimeException {
EmptyListExcept
ion.java
// no-argument constructor
public EmptyListException()
Poikkeus, joka syntyy jos
{
this( "List" );
// call other EmptyListException constructortyhjästä listasta yritetään
poistaa solmu.
}
// constructor
public EmptyListException( String name )
{
super( name + " is empty" ); // call superclass constructor
}
} // end class EmptyListException
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// Fig. 20.5: ListTest.java
// ListTest class to demonstrate List capabilities.
import com.deitel.jhtp5.ch20.List;
import com.deitel.jhtp5.ch20.EmptyListException;
ListTest.java
public class ListTest {
public static void main( String args[] )
{
List list = new List(); // create the List container
// objects to store in list
Boolean bool = Boolean.TRUE;
Character character = new Character( '$' );
Integer integer = new Integer( 34567 );
String string = "hello";
// insert references to objects in list
list.insertAtFront( bool );
list.print();
list.insertAtFront( character );
list.print();
list.insertAtBack( integer );
list.print();
list.insertAtBack( string );
list.print();
Luodaan linkitetty
lista.
Luodaan arvot
(oliot), jotka
talletetaan
solmuihin.
Lisätään listaan solmut
edellä luoduin arvoin.
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
// remove objects from list; print after each removal
try {
Object removedObject = list.removeFromFront();
System.out.println( removedObject.toString() + " removed" );
list.print();
removedObject = list.removeFromFront();
System.out.println( removedObject.toString() + " removed" );
list.print();
removedObject = list.removeFromBack();
System.out.println( removedObject.toString() + " removed" );
list.print();
removedObject = list.removeFromBack();
System.out.println( removedObject.toString() + " removed" );
list.print();
} // end try block
// catch exception if remove is attempted on an empty List
catch ( EmptyListException emptyListException ) {
emptyListException.printStackTrace();
}
}
} // end class ListTest
Poistetaan
solmuja.
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.java
Ohjelman tuloste.