ALGORITMA DAN

STRUKTUR DATA
Linked List
Outline
¨ Linked Lists vs. Array
¨ Linked Lists dan Iterators
¨ Variasi Linked Lists:
¤ Doubly Linked Lists
¤ Circular Linked Lists
¤ Sorted Linked Lists
Tujuan
¨ Memahami struktur data linked-list
¨ Memahami kompleksitas dari operasi-operasi pada
ADT linked-list antara lain insert, delete, read
¨ Dapat mengimplementasikan linked-list
Apakah Linked List itu ?

¨ Elemen (disebut dengan CELL, atau SEL dalam

bahasa Indonesia) yang mungkin terletak terpisah-
pisah di memory, disambungkan dengan pointer.
¨ Tiap sel berisi dua informasi : nilai dan pointer ke
sel berikutnya
nilai Pointer to next CELL

nilai Pointer to next CELL

nilai Pointer to next CELL

ＣＥＬＬ
Linked Lists
A0 A1 A2 A3

¨ Menyimpan koleksi elemen secara non-contiguously.

¤ Elemen dapat terletak pada lokasi memory yang saling
berjauhan. Bandingkan dengan array dimana tiap-tiap
elemen akan terletak pada lokasi memory yang
berurutan.
¨ Mengizinkan operasi penambahan atau
penghapusan elemen ditengah-tengah koleksi
dengan hanya membutuhkan jumlah perpindahan
elemen yang konstan.
¤ Bandingkan dengan array. Berapa banyak elemen
yang harus dipindahkan bila akan menyisipi elemen
ditengah-tengah array?
Iterate the Linked List
¨ Items are stored in a contiguous array:

¨ Items are stored in a linked list non-contiguously :

Mengapa memakai Linked List ?

1. Mudah untuk menambahkan dan menghapus elemen

（pada array tidak mungkin menambahkan elemen,
karena banyaknya elemen sudah ditentukan dari
awal）
2. Panjang list bisa diubah dengan bebas (panjang
array fixed)
3. Mudah untuk menyambungkan beberapa list,
maupun memutuskannya (array tidak bisa)
4. Memungkinkan user mendesain struktur data yang
kompleks
Implementasi : Linked List
¨ Sebuah list merupakan rantai dari object bertipe ListNode yang
berisikan data dan referensi (pointer) kepada ListNode selanjutnya
dalam list
¨ Harus diketahui dimana letak elemen pertama!
List Node : Definisi
Note
¨ Yang disimpan dalam ListNode adalah reference dari object-nya,
BUKAN object-nya itu sendiri atau salinan dari object-nya !
 Array vs linked list

Ø Banyaknya anggota
§ Banyaknya elemen array ditentukan di awal & jumlahnya tetap
§ Elemen linked list dibuat di memori ketika dibutuhkan (ingat Alokasi
memory dinamis). Jumlahnya dinamis, dapat bertambah dan
berkurang sesuai keperluan

Ø Cara mengakses elemen

§ Elemen array diakses lewat indeks
§ Untuk mengakses elemen linked list, harus dilakukan
penelusuran elemen list
Array vs Linked List

Array Linked List

Penambahan dan Tidak mungkin Mungkin

penghapusan
elemen
Panjang list Fixed Bisa diubah

Akses ke elemen cepat (harus mengikuti pointer satu

demi satu)
lambat
Array vs Linked List

Array Linked List

Penambahan dan Tidak mungkin Mungkin

penghapusan
elemen
Panjang list Fixed Bisa diubah

Akses ke elemen cepat (harus mengikuti pointer satu

demi satu)
lambat
 Array vs Linked List
header
1 a[0] 13
2 a[1]
address 13 address 18 address 24
3 a[2]
18 24
1 2 3
value value next value next
Pointer ke sel berikutnya
(next)
（NULL）
int a[3];
int n;

Array Linked List

Address tiap sel berurutan Address tidak berurutan

Akses ke tiap sel dimulai dari header
Cara menampilkan isi sel tertentu

¨ Pada array (misalnya nama array: a), isi sel tertentu

dapat ditampilkan dengan cara a[nomer urut sel
keberapa]. Misalnya a[5] akan menampilkan isi sel ke-6.
Hal ini karena satu sel dengan sel yang lain terletak
pada posisi yang berurutan di memory.
¨ Pada linked list, kita tidak tahu secara langsung, sel itu
terletak dimana dalam memory.

Akses harus dilakukan satu persatu, urut mulai dari sel terdepan
 Cara menampilkan isi sel tertentu

Tampilkan isi (value) sel ke-3 !

address

header 37 38 40 52
37 4 38 2 40 13 52 40 NULL
Sel ke-1

pointer

Sel ke-1→ isi： value=4

address sel berikutnya=38
Operasi dasar linked list

1. Menambah sebuah node.

2. Menghapus sebuah node.
3. Mencari sebuah node.
4. List tranversal
 Menambahkan node ke list kosong
Before:
pNew 39
pNew -> next = pHead; // set link to NULL
pHead
pHead = pNew;// point list to first node

pPre

After:
pNew 39

pHead

pPre
Menambahkan node ke awal list
Before:
pNew -> next = pHead; // set link to NULL
pNew 39
pHead = pNew;// point list to first node
pHead 75 124

pPre

After:
pNew 39

pHead
75 124

pPre
 Menambahkan node di tengah list

Before
pNew -> next = pPre -> next;
pNew 64
pPre -> next = pNew;

55 124

pPre

After:
pNew 64

55 124

pPre
Ilustrasi Insertion

a b c d

current

n Menyisipkan X pada lokasi setelah current.

a x b c d

current x
Langkah-langkah menyisipkan
Sisip efisien
Menambahkan node akhir list

Before:
pNew -> next = NULL;
pNew 144
pPre -> next = pNew;
55 124

pPre

After:
pNew 144

55 124

pPre
 Menambahkan node pada linked list
Terdapat empat tahap untuk menambah node linked list:
¨ Membuat node baru.
¨ Mendapatkan node yang terletak sebelum node baru disisipkan (pPre)
¨ Atur next node baru agar menunjuk node sesudah posisi penyisipan.
¨ Atur next pPre agar menunjuk node baru.
Menghapus node dari linked list

¨ Untuk menghapus sebuah node:

¤ Cari node yang akan dihapus (pCur) dan node
pendahulunya (pPre).
¤ Ubah pPre->next agar menunjuk pCur->next.
¤ Hapus pCur menggunakan fungsi free
 Menghapus node pertama dari linked list

Before: Code:
pHead 75 124 pHead = pCur -> next;
free(pCur);
pPre pCur

After:
pHead Recycled 124

pPre pCur
Langkah menghapus elemen di tengah
¨ Proses menghapus dilakukan dengan mengabaikan
elemen yang hendak dihapus dengan cara melewati
pointer (reference) dari elemen tersebut langsung
pada elemen selanjutnya.
¨ Elemen x dihapus dengan meng-assign field next
pada elemen a dengan alamat b.
a x b

current

a b

current
Langkah-langkah menghapus elemen
di tengah
¨ Butuh menyimpan alamat node yang terletak
sebelum node yang akan dihapus. (pada gambar
node current, berisi elemen a)
current.next = current.next.next;

a x b

current

Kapan node x dihapus? Oleh siapa?

Langkah-langkah menghapus elemen

a x b

current

¨ Tidak ada elemen lain yang menyimpan alamat node

x.
¨ Node x tidak bisa diakses lagi.
¨ Program akan membersihkan alokasi memory yang
tidak dipakai lagi atau tidak bisa diakses.
¨ Dengan kata lain, menghapus node x.
Menghapus node dari linked list – kasus umum

Before:
pPre -> next = pour -> next;
75 96 124 free(pCur);

pPre pCur

After:
Recycled
75 124

pPre pCur
Traversing a Linked List

¨ mengunjungi semua node yang ada pada list dari head sampai node
terakhir
Header Node
¨ Menghapus dan menambahkan elemen pertama menjadi kasus
khusus.
¨ Dapat dihindari dengan menggunakan header node;
n Tidak berisikan data, digunakan untuk menjamin bahwa
selalu ada elemen sebelum elemen pertama yang sebenarnya
pada linked list.
n Elemen pertama diperoleh dengan:
current=header.next;
n Empty list jika: header.next == null;
¨ Proses pencarian dan pembacaan mengabaikan header node.
List Interface
List Implementation
List Implementation
Iterator Class
¨ Untuk melakukan sebagian besar operasi-operasi
pada List, kita perlu menyimpan informasi posisi saat
ini. (current position).
¨ Kelas List menyediakan method yang tidak bergantung
pada posisi. Method tersebut antara lain: isEmpty,
dan makeEmpty.
¨ List iterator (ListItr) menyediakan method-method
yang umum digunakan untuk melakukan operasi pada
list antara lain: advance, retrieve, first.
¨ Internal struktur dari List di encapsulasi oleh List
iterator.
¨ Informasi posisi current disimpan dalam object iterator.
Iterator Class
// Insert x after current position
void insert (x);
// Remove x
void remove (x);
// Remove item after current position
void removeNext( );
// Set current position to view x
boolean find( x );
// Set current position to prior to first
void zeroth ();
// Set current position to first
void first( );
// Set current to the next node
void advance ();
// True if at valid position in list
boolean isInList ();
// Return item in current position
Object retrieve()

¨ Exceptions thrown for illegal access, insert, or remove.

Contoh
¨ Sebuah method static untuk menghitung jumlah
elemen dalam sebuah list.

public static int listSize (List theList)

{
int size = 0;
ListItr itr = new ListItr (theList);

for (itr.first(); itr.isInList(); itr.advance())

{
size++;
}
return size;
}
Java Implementations
¨ Sebagian besar cukup mudah; seluruh method relatif pendek.
¨ ListItr menyimpan reference dari object list sebagai private data.
¨ Karena ListItr is berada dalam package yang sama dengan List,
sehingga jika field dalam List adalah (package) friendly, maka
dapat di akses oleh ListItr.
LinkedListItr implementation
public class LinkedListItr implements ListItr

/** contains List header. */

protected LinkedList theList;
/** stores current position. */
protected ListNode current;

/**
Construct the list.
As a result of the construction, the current position is
the first item, unless the list is empty, in which case
the current position is the zeroth item.
@param anyList a LinkedList object to which this iterator is
permanently bound.
*/
public LinkedListItr( LinkedList anyList )
{
theList = anyList;
current = theList.isEmpty( ) ? theList.header :
theList.header.next;
}
/**
Construct the list.
@param anyList a LinkedList object to which this iterator is
permanently bound. This constructor is provided for
convenience. If anyList is not a LinkedList object, a
ClassCastException will result.
*/
public LinkedListItr( List anyList ) throws ClassCastException{
this( ( LinkedList ) anyList );
}

/**
* Advance the current position to the next node in the list.
* If the current position is null, then do nothing.
* No exceptions are thrown by this routine because in the
* most common use (inside a for loop), this would require the
* programmer to add an unnecessary try/catch block.
*/
public void advance( ){
if( current != null )
current = current.next;
}
/**
* Return the item stored in the current position.
* @return the stored item or null if the current position
* is not in the list.
*/
public Object retrieve( ){
return isInList( ) ? current.element : null;
}

/**
* Set the current position to the header node.
*/
public void zeroth( ){
current = theList.header;
}

/**
* Set the current position to the first node in the list.
* This operation is valid for empty lists.
*/
public void first( ){
current = theList.header.next;
}
/**
* Insert after the current position.
* current is set to the inserted node on success.
* @param x the item to insert.
* @exception ItemNotFound if the current position is null.
*/
public void insert( Object x ) throws ItemNotFound
{
if( current == null )
throw new ItemNotFound( "Insertion error" );

ListNode newNode = new ListNode( x, current.next );

current = current.next = newNode;
}
/**
* Set the current position to the first node containing an item.
* current is unchanged if x is not found.
* @param x the item to search for.
* @return true if the item is found, false otherwise.
*/
public boolean find( Object x )
{
ListNode itr = theList.header.next;

while( itr != null && !itr.element.equals( x ) )

itr = itr.next;

if( itr == null )

return false;

current = itr;
return true;
}
/**
* Remove the first occurrence of an item.
* current is set to the first node on success;
* remains unchanged otherwise.
* @param x the item to remove.
* @exception ItemNotFound if the item is not found.
*/
public void remove( Object x ) throws ItemNotFound
{
ListNode itr = theList.header;

while( itr.next != null && !itr.next.element.equals( x ) )

itr = itr.next;

if( itr.next == null )

throw new ItemNotFound( "Remove fails" );

itr.next = itr.next.next; // Bypass deleted node

current = theList.header; // Reset current
}
/**
* Remove the item after the current position.
* current is unchanged.
* @return true if successful false otherwise.
*/
public boolean removeNext( )
{
if( current == null || current.next == null )
return false;
current.next = current.next.next;
return true;
}

/**
* Test if the current position references a valid list item.
* @return true if the current position is not null and is
* not referencing the header node.
*/
public boolean isInList( )
{
return current != null && current != theList.header;
}
Exceptions
¨ Beberapa method dapat menthrow ItemNotFound exceptions.
¨ Namun, jangan menggunakan exceptions secara berlebihan karena
setiap exception harus di tangkap (caught) atau di teruskan
(propagate). Sehingga menuntut program harus selalu
membungkusnya dengan blok try/catch
¨ Contoh: method advance tidak men-throw exception, walaupun
sudah berada pada akhir elemen.
¨ Bayangkan bagaimana implementasi method listSize bila method
advance men-throw exception!
Linked List Properties
¨ Analisa Kompleksitas Running Time
¤ insert next, prepend - O(1)
¤ delete next, delete first - O(1)
¤ find - O(n)
¤ retrieve current position - O(1)
¨ Keuntungan
¤ Growable (bandingkan dengan array)
¤ Mudah (quick) dalam read/insert/delete elemen
pertama dan terakhir (jika kita juga menyimpan
referensi ke posisi terakhir, tidak hanya posisi
head/current)
¨ Kerugian
¤ Pemanggilan operator new untuk membuat node baru.
(bandingkan dengan array)
¤ Ada overhead satu reference untuk tiap node
Mencetak seluruh elemen Linked List
¨ Cara 1: Tanpa Iterator, loop
public class LinkedList {

public void print ()

{
// step through list, outputting each item
ListNode p = header.next;
while (p != null) {
System.out.println (p.data);
p = p.next;
}
}
}
Mencetak seluruh elemen Linked List(2)
¨ Cara 2: Tanpa Iterator, Recursion
public class LinkedList {
...
private static void printRec (ListNode node)
{
if (node != null) {
System.out.println (node.data);
printRec (node.next);
}
}

public void print ()

{
printRec (header.next);
}
}
Mencetak seluruh elemen Linked List(3)
¨ Cara 3: Recursion
class ListNode{
...
public void print () {
System.out.println (data);
if (next != null) {
next.print ();
}
}
} // end of class ListNode

class LinkedList {
public void print () {
if (header.next != null) {
header.next.print ();
}
}
}
Mencetak seluruh elemen Linked List(4)
¨ Cara 4: Menggunakan iterator
class LinkedList
{
...
public void print (List theList)
{
ListItr itr = new ListItr (theList);

for (itr.first(); itr.isInList();

itr.advance())
{
System.out.println (itr.retrieve ());
}
}

}
Sorted Linked Lists

¨ Menjaga elemen selalu disimpan terurut.

¨ Hampir seluruh operasi sama dengan linked list
kecuali insert (menambahkan data).
¨ Pada dasarnya sebuah sorted linked list adalah
sebuah linked list. Dengan demikian inheritance bisa
diterapkan. Kelas SortListItr dapat diturunkan
dari kelas ListItr.
¨ Perlu diingat, elemen pada sorted linked list haruslah
mengimplement Comparable.
Implementasi
¨ Terapkan inheritance,
¨ Buat method Insert yang akan mengoveride method milik kelas
LinkedList.
public void insert( Comparable X
Note
• ListItr menggunakan method equals pada implementasi find
dan remove.
• Harus dipastikan Class yang digunakan sebagai element (mis:
MyInteger) memiliki method equals
• Signature: (harus sama persis )
public boolean equals( Object Rhs )
• Signature berikut ini salah!
public boolean equals( Comparable Rhs )
• method equals dari class Object dapat diturunkan dan
digunakan:
public boolean equals (Object obj){
return (this == obj);
}
Variasi Linked Lists
n Doubly-linked lists: Tiap list node menyimpan referensi
node sebelum dan sesudahnya. Berguna bila perlu
melakukan pembacaan linkedlist dari dua arah.

prev
A

next
head tail
Variasi Linked Lists
¨ Circular-linked lists: Node terakhir menyimpan
referensi node pertama. Dapat diterapkan dengan
atau tanpa header node.

prev
A B C

next
first
Doubly-linked lists: InsertNext

newNode = new DoublyLinkedListNode(x);

1 newNode.prev = current;
2 newNode.prev.next = newNode;
…
…

a 2 b
?
1 x
current
Doubly-linked lists: insertNext
A B
4
prev 3
2 X 5
current 1 next
6
newNode

1 newNode = new
DoublyLinkedListNode(x);
2 newNode.prev = current;
3 newNode.next = current.next;
4 newNode.prev.next = newNode;
5 newNode.next.prev = newNode;
6 current = newNode;
Doubly-linked lists: DeleteCurrent
1. current.prev.next = current.next;
2. current.next.prev = current.prev;
3. current = current.prev;

1
a b
2
3
current
x
Rangkuman

¨ ListNode
¨ List, LinkedList dan variasinya
¨ Iterator class
¨ Kelebihan & kekurangan dari linked list
¤ Growable
¤ Overhead a pointer, new operator untuk membuat
node.
¤ Hanya bisa diakses secara sequential.
Next…
Stack and Queue
source
¨ Slide fasilkom UI
¨ Slide tambahan lain