LAPORAN TUGAS 1

ALGORITMA PEMROGRAMAN 2

Laras Aristiani – 5212100022

1. Kelas DoublyListNode yang dimodifikasi dari kelas ListNode yang ada di buku

Data Structures

public class DoublyListNode { public Object element; public DoublyListNode next; public DoublyListNode prev; public DoublyListNode(Object theElement){ this(null, theElement, null); } public DoublyListNode(DoublyListNode prev,Object theElement, DoublyListNode next){ element = theElement; this.next = next; this.prev = prev; } }

Perbedaan pada kelas ListNode dengan DoublyListNode, Konstruktor pada

kelas DoublyListNode memiliki 3 parameter yaitu 2 ListNode dan satu

Object yang digunakan untuk mengisi elemen. Dua buah ListNode yang

menunjukkan ListNode sebelumnya(prev) dan ListNode yang satunya lagi

menunjukkan ListNode setelahnya (next).

Jika dibandingkan dengan ListNode yang ada di Singly Linked List, konstruktornya

hanya memiliki 2 parameter yaitu Object dan satu ListNode yang menunjukkan

header.

2. Kelas DoublyLinkedList yang dimodifikasi dari kelas LinkedList yang ada di

buku Data Structures. public class DoublyLinkedListIterator { DoublyListNode current; //constructor public DoublyLinkedListIterator(DoublyListNode theNode){ current = theNode; } //method isValid() public boolean isValid(){

return current != null; } //method retrieve() public Object retrieve(){ return isValid() ? current.element : null; } //method forward() public void forward(){ if(isValid()){ current = current.next; } } //method backward() public void backward(){ if(isValid()); current = current.prev; } }

a. Constructor

Constructor pada DoublyLinkedListIterator menunjukan bahwa sebuah objek

DoublyLinkedListIterator baru, merupakan sebuah ListNode current, yang

menunjukan posisi iterator berada di ListNode yang mana.

b. Method isValid()

Akan bernilai benar apabila jika posisi current iteratornya valid, tidak kosong.

c. Method retrieve()

Digunakan untuk mendapatkan nilai elemen yang ada di posisi iterator

menunjuk.

d. Method forward()

Digunakan untuk mengarahkan posisi iterator ke ListNode selanjutnya (next),

bergerak maju.

e. Method backward()

Digunakan untuk mengarahkan posisi iterator ke ListNode sebelumnya (prev).

Bergerak mundur.

Perbedaan yang ada antara DoublyLinkedListIterator dengan LinkedLisIterator, pada

method backward(), yang bisa menggerakan iterator ke ListNode sebelumnya. Hal ini

tidak bisa dilakukan dengan Singly Linked List

3. Kelas DoublyLinkedList yang dimodifikasi dari kelas LinkedList yang ada

di buku Data Structures public class DoublyLinkedList { DoublyListNode header;

//constructor public DoublyLinkedList(){ header = new DoublyListNode(null); header.next = header.prev = header; }

//method isEmpty public boolean isEmpty(){ return header.next == header; }

//method makeEmpty public void makeEmpty(){ header.next = header.prev = header; }

//method zeroth public DoublyLinkedListIterator zeroth(){ return new DoublyLinkedListIterator(header); }

//method first public DoublyLinkedListIterator first(){ return new DoublyLinkedListIterator(header.next); }

//method insertAfter public void insertAfter(Object x, DoublyLinkedListIterator p){ if( p != null && p.current != null){ p.current.next = new DoublyListNode(p.current, x , p.current.next.next); } }

//method insertBefore public void insertBefore(Object x, DoublyLinkedListIterator p){ if(p != null && p.current != null){ p.current.prev = new DoublyListNode(p.current.prev, x, p.current); } } public DoublyLinkedListIterator find(Object x){ DoublyListNode itr = header.next; while(itr != null && !itr.element.equals(x)){ itr = itr.next; } return new DoublyLinkedListIterator(itr); } public DoublyLinkedListIterator findPrevious(Object x){ DoublyListNode itr = header; while( itr.next != null && !itr.next.element.equals(x)){ itr = itr.next; } return new DoublyLinkedListIterator (itr); } public void remove(Object x){ DoublyLinkedListIterator p = findPrevious(x); if(isEmpty()){ System.out.println("DOUBLY LINKED LIST KOSONG"); } else if (p.current == header){ System.out.println("Tidak bisa menghapus header"); } else { p.current.prev.next = p.current.next; p.current.next.prev = p.current.prev; } } public static void printList(DoublyLinkedList theList){ if( theList.isEmpty()){

System.out.print("LIST NYA KOSONG"); } else { DoublyLinkedListIterator itr = theList.first(); for(; itr.isValid(); itr.forward()){ System.out.println(itr.retrieve() + ""); } } } }

Perbedaan yang siginifikan antara kelas DoublyLinkedList dan LinkedList, terletak

pada constructor, method isEmpty, method makeEmpty, method insert dan remove.

Berikut adalah penjelasannya :

a. Constructor

Constructor pada kelas LinkedList adalah sebagai berikut : public LinkedList(){ header = new ListNode(null); }

Hal ini menunjukkan bahwa pada saat objek kelas LinkedList dibentuk, objek

tersebut memiliki sebuah ListNode yang isinya kosong, dengan mengarah ke

ground.

Sedangkan constructor pada kelas DoubleLinkedList : public DoublyLinkedList(){ header = new DoublyListNode(null); header.next = header.prev = header; }

Header.next = header.prev = header, menunjukan bahwa ListNode header

mengarah ke header itu sendiri, tidak mengarah ke ground.

b. Method isEmpty

Method isEmpty digunakan untuk mengecek apakah LinkedList tersebut kosong

ata tidak. Pada kelas LinkedList method isEmpty nya adalah sebagai berikut : public boolean isEmpty(){ return header.next == null; }

Method isEmpty pada kelas LinkedList bernilai benar apabila tidak ada ListNode

setelah header. Sedangkan method isEmpty pada kelas DoublyLinkedList public boolean isEmpty(){ return header.next == header;

}

Hal ini menunjukkan bahwa isEmpty akan bernilai benar (DoublyLinkedList nya

kosong) apabila ListNode setelah header adalah header itu sendiri. Atau bisa

juga diganti dengan header.prev == header

c. Method makeEmpty

Method makeEmpty digunakan untuk menghapus isi Linked List kecuali header.

Pada kelas LinkedList, method makeEmpty adalah sebagai berikut public void makeEmpty(){ header.next = null; }

Ini menunjukkan bahwa ListNode yang ada setelah header, adalah kosong,

langsung mengarah ke ground. Secara otomatis, ListNode-ListNode selanjutnya

juga bernilai null.

Sedangkan method makeEmpty pada kelas DoublyLinkedList adalah sebagai

berikut : public void makeEmpty(){ header.next = header.prev = header; }

Jika diteliti, method makeEmpty pada kelas DoublyLinkedList isinya sama dengan

constructor DoublyLinkedList. Method makeEmpty ini mengembalikan List Node

kembali menjadi seperti semula.

d. Method insert

Method insert digunakan untuk memasukkan ListNode. Pada kelas LinkedList,

ListNode baru hanya bisa dimasukkan di lokasi setelah iterator, sehingga hanya

ada satu jenis insert yaitu : public void insert(Object x, LinkedListIterator p){ if( p!= null && p.current !=null){ p.current.next = new ListNode(x, p.current.next); } }

Proses insert terlihat pada p.current.next = new ListNode(x, p.current.next).

Yang berarti ListNode setelah posisi iterator (p.current) adalah ListNode baru

yang isinya Object x, dan lokasinya terletak di setelah posisi kursor

(p.current.next).

Sedangkan pada kelas DoublyLinkedList, proses insertion dapat dilakukan

setelah posisi iterator berada, dan sebelum posisi iterator berada. Jadi method

insert pada kelas DoublyLinkedList ada dua yaitu insertAfter dan insertBefore

//method insertAfter

public void insertAfter(Object x, DoublyLinkedListIterator p){ if( p != null && p.current != null){ p.current.next = new DoublyListNode(p.current, x , p.current.next.next); } }

//method insertBefore public void insertBefore(Object x, DoublyLinkedListIterator p){ if(p != null && p.current != null){ p.current.prev = new DoublyListNode(p.current.prev, x, p.current); } }

Pada method insertAfter terdapat baris kode yang isinya p.current.next = new DoublyListNode(p.current, x , p.current.next.next);

ini maksudnya, ada ListNode baru dengan elemen Object x, yang terletak setelah

posisi iterator (p.current). ListNode baru tersebut memiliki ListNode

sebelumnya(prev) berupa p.current (ListNode yang ditunjuk oleh iterator),

dengan ListNode selanjutnya(next) berupa p.current.next.next (p.current.next

adalah ListNode baru yang ingin di insert, maka posisi dari kelanjutan ListNode

yang baru tersebut adalah p.current.next.next)

Pada method insertBefore terdapat baris kode yang isinya :

p.current.prev = new DoublyListNode(p.current.prev, x, p.current);

Pada dasarnya insertBefore sama dengan insertAfter, hanya saja yang

membedakan adalah posisi meletakkan ListNode yang baru, dan nilai prev dan

next nya.

e. Method remove(Object x)

Method remove digunakan untuk menghapus Object x, yang dicari oleh method

find(Object x). Proses penghapusan pada kelas LinkedList, dilakukan dengan

membentuk iterator yang menunjuk pada ListNode sebelum objek yang ingin

dihapus. public void remove(Object x){ LinkedListIterator p = findPrevious(x); if(p.current.next != null){ p.current.next = p.current.next.next; } }

Baris kode p.current.next = p.current.next.next;

Bertujuan untuk merubah ListNode yang berada setelah posisi iterator

(p.current.next) dengan dua ListNode setelah posisi iterator.

Pada DoublyLinkedList, method remove adalah sebagai berikut public void remove(Object x){ DoublyLinkedListIterator p = findPrevious(x); if(isEmpty()){ System.out.println("DOUBLY LINKED LIST KOSONG"); } else if (p.current == header){ System.out.println("Tidak bisa menghapus header"); } else { p.current.prev.next = p.current.next; p.current.next.prev = p.current.prev; }

}

Pada proses penghapusan perbedaannya terletak pada baris kode : p.current.prev.next = p.current.next; p.current.next.prev = p.current.prev;

Maksud dari baris kode tersebut adalha merubah nilai prev dan next dari

ListNode sehingga ListNode dengan Object x, dilepas dari tautan LinkedList