Think Different Materi ASD 2014 pertemuan_9

LINKED LIST

Double Linked List
• Double : artinya field pointer-nya dua buah dan
dua arah, yang menunjuk ke node sebelum dan
sesudahnya.
• Berguna bila perlu melakukan pembacaan
linkedlist dari dua arah.
• Double linked list memiliki 2 buah pointer yaitu
pointer next dan prev.
• Pointer next : mengarah ke node belakang (tail).
• Pointer prev : mengarah ke node depan (head).
2

Ilustrasi Node “Double”
prev

DATA

nex
t

• Ketika masih ada satu node maka kedua pointer
(next dan prev) akan menunjuk ke NULL)
• Double linked list dapat diakses dari dua arah :
1. Dari depan ke belakang (head ke tail)
2. Dari belakang ke depan (tail ke head)

Double Linked List
• Ketika double linked list memiliki banyak
node maka node yang paling depan pointer
prev-nya menunjuk ke NULL. Sedangkan
node yang paling belakang pointer next-nya
yang menunjuk ke NULL.

firstNode

lastNode

null
null

a

b

c

d

e

Pointer Head dan Tail
• Sama seperti single linked list, pada double
linked dibutuhkan pointer bantu yaitu head
dan tail.
• Head : menunjuk pada node yang paling
depan.
• Tail : menunjuk pada node yang paling
belakang.

Double Linked List
• Contoh ilustrasi double linked list yang
memiliki 4 node :
previous

next

“Double” Representation
class Node2P
{
int data; // data
Node2P next;
// pointer next
Node2P prev;
// pointer prev
}

Ilustrasi :
next
data

prev

Penjelasan:
• Pembuatan class bernama Node2P, yang berisi
variabel data bertipe Object dan 2 variabel
pointer bertipe Node2P yaitu : next dan prev.
• Field data : digunakan untuk menyimpan
data/nilai pada linked list. Field pointer :
digunakan untuk menyimpan alamat node
berikutnya.

Class Node
public class Node2P {
int data;
Node2P next;
Node2P previous;

Constructor 1
null
null

null
Constructor 2

}

Node2P() {}

null

Node2P(int theData)
{ data = theData;}

data
null

Node2P(int theData, Node2P thePrevious, Node2P theNext)
Constructor 3
{
next
data= theData;

previous = thePrevious;
data
next = theNext;
}
prev

Alokasi Simpul
Node2P baru = new
Node2P(10);

9

Operasi Linked List
1.
2.
3.
4.
5.
6.
7.

8.

inisialisasi
isEmpty
size
Penambahan
Penghapusan
Penyisipan
Pencarian
Pengaksesan

(1) Inisialisasi Awal Pointer Head & Tail
Node2P head = null;
Node2P tail= null;

head

NULL

tail

11

(2)isEmpty
• Digunakan untuk mengetahui linked
dalam kondisi kosong.
• Kondisi kosong : jika size = 0 atau
jika head=tail=null.
boolean isEmpty()
{
return size==0;
}

(3) size
• Digunakan untuk mengetahui banyak
node pada linked list.
• Size akan bertambah 1 setiap ada
node baru yang ditambahkan pada
linked list.
• Size akan berkurang 1 setiap ada

penghapusan node.
int size()
{
return size;
}

(4) Penambahan
• Dibedakan menjadi :
1. Penambahan dari depan
2. Penambahan dari belakang
3. Penambahan setelah node tertentu
4. Penambahan sebelum node tertentu

Membentuk Simpul Awal
• Jika kondisi awal linked list kosong, maka
head dan tail sama-sama menunjuk node
baru.
• head = tail= Baru

15

Penambahan dari Depan
• Jika linked list terdapat node, maka :
– Penambahan node baru diletakkan di
depan node yang ditunjuk oleh head.
– Pointer prev dari node depan diarahkan ke
node baru.
– Terjadi pergeseran pointer head kearah
node baru.

Penambahan dari Depan
void addFirst(Node2P input){
if (isEmpty()){
head=input;
tail=input;
}
else
{
input.next = head;
head.previous = input;

head = input;
} size++;
}

Insert First
1. Baru.next = head

18

Insert First
2. head.prev = Baru

19

Insert First
3. head = baru

20

Penambahan dari Belakang
• Jika linked list terdapat node, maka :
– Penambahan node baru diletakkan di
belakang node yang ditunjuk oleh tail.
– Pointer next dari node belakang diarahkan
ke node baru.
– Terjadi pergeseran pointer tail kearah
node baru.

Penambahan dari Belakang
void addLast(Node2P input){
if (isEmpty()){
head = input;
tail = input;
}
else
{
input.previous = tail;
tail.next = input;
tail = input;
} size++;
}

Insert Last
Kondisi awal linked list :
Terdapat 2 node

23

Insert Last
1. Baru.prev = tail

24

Insert Last
2. tail.next = Baru

25

Insert Last
3. tail= Baru

26

Penambahan Setelah Node x
• Penambahan node baru dilakukan
dibelakang node x (node tertentu).
• Node x adalah node yang memiliki
data yang sama dengan key.
• Jika tidak ditemukan node yang
dimaksud maka penambahan tidak
terjadi.

Penambahan setelah Node x
void insertAfter(int key,Node2P input){
Node2P temp = head;
do{
if(temp.data==key){
input.previous = temp;
input.next = temp.next;
temp.next.previous = input;
temp.next = input;
size++;
System.out.println("Insert data is
succeed.");
break;
}
temp = temp.next;
}while (temp!=null);
}

Insert After Node x
Kondisi awal linked list :
Terdapat 3 node pada linked list
misalkan key = 10

Insert After Node x
Dibutuhkan pointer bantu untuk mencari node x.
Misalkan pointer bantu tersebut adalah after.
1. Node after = head;

Pointer after akan bergeser mencari node yang
sesuai.

Insert After Node x
2. Baru.prev = after

Insert After Node x
3. Baru.next = after.next

32

Insert After Node x
4. after.next.prev = Baru

33

Insert After Node x
5. after.next = Baru

34

Insert After Node x
Hasil akhir :

35

Penambahan Sebelum Node x
• Penambahan node baru dilakukan
didepan node x (node tertentu).
• Node x adalah node yang memiliki
data yang sama dengan key.
• Jika tidak ditemukan node yang
dimaksud maka penambahan tidak
terjadi.

Penambahan sebelum Node
tertentu
void insertBefore(Object key,Node2P input){
Node2P temp = head;
while (temp != null){
if (temp.data == key)
{
if(temp == head)
{
this.addFirst(input);
System.out.println("Insert data is succeed.");
size++;
break;
}
else
{
input.previous = temp.previous;
input.next = temp;
temp.previous.next = input;
temp.previous = input;
System.out.println("Insert data is succeed.");
size++;
break;
}
}
temp = temp.next;
}

Insert Before Node x
Kondisi awal linked list :
Terdapat 4 node pada linked list
misalkan key = 5

38

Insert Before Node x
1. Node before = head;
pointer before mencari node yang sesuai.

39

Insert Before Node x
2. Baru.prev = before.prev

40

Insert Before Node x
3. Baru.next = before

41

Insert Before Node x
4. before.prev.next = Baru

42

Insert Before Node x
5. before.prev = Baru

43

Insert Before Node x
Hasil akhir :

44

(5) Penghapusan
• Dibedakan menjadi :
1. Hapus node depan
2. Hapus node belakang
3. Hapus node tertentu

Penghapusan
• Jika linked list dalam keadaan
kosong maka tidak dapat dilakukan
penghapusan.
• Jika pada linked list hanya terdapat 1
node, maka head dan tail menunjuk
ke NULL.

Hapus Node Depan
• Penghapusan dilakukan pada node
paling depan, yaitu node yang ditunjuk
oleh head.
• Terjadi pergeseran head ke belakang.

Hapus node depan
void removeFirst(){
Node2P temp = head;
if (!isEmpty()){
if (head == tail)
head = tail = null;
else
{
head.next.previous = null;
head = temp.next;
} size--;
}
else
System.out.println("Data is empty!");
}

Delete First
kondisi awal linked list:
Terdiri dari 5 node

49

Delete First
1. Node hapus = head;

50

Delete First
2. head.next.prev = null

51

Delete First
3. head = hapus.next

52

Delete First
Node 8 sudah terhapus

53

Delete First
Hasil akhir :

54

Hapus Node Belakang
• Penghapusan dilakukan pada node
paling belakang, yaitu node yang
ditunjuk oleh tail.
• Terjadi pergeseran tail ke depan.

Hapus node belakang
void removeLast(){
Node2P temp = tail;
if (!isEmpty()){
if (tail == head){
head = tail = null;
}
else {
tail.previous.next = null;
tail=temp.previous;
} size--;
}
else System.out.println("Data is
empty!");
}

Delete Last
Kondisi awal linked list :
Linked list terdiri dari 4 node

57

Delete Last
1. Node hapus=tail;

58

Delete Last
2. tail.prev.next = null

59

Delete Last
3. tail= hapus.prev

60

Delete Last
Node 6 sudah terhapus

61

Delete Last
Hasil akhir :

62

Hapus Node x
• Penghapusan dilakukan pada node x
(node tertentu).
• Node x adalah node yang memiliki data
sama dengan key.
• Jika tidak ditemukan node yang sesuai
maka penghapusan tidak dapat
dilakukan.

Hapus node tertentu

void remove(int key){
Node2P temp = head;
if (!isEmpty()){
while (temp != null){
if (temp.data == key){
if (temp == head){
this.removeFirst();
size--;
break;
}
else
{
if(temp.next == null){
tail=temp.previous;
tail.next=null;
}
else{
temp.previous.next = temp.next;
temp.next.previous = temp.previous;
}
size--;
break;
}
}
temp = temp.next;
}
}
else
System.out.println("Data is empty!");
size--;
}

Delete Node x
Kondisi awal linked list :
Linked list memiliki 3 node. Misalkan key = 3

65

Delete Node x
1. Node hapus=head;
hapus adalah pointer bantu yang akan
mencari node yang dimaksud (node x).

66

Delete Node x
2. hapus.prev.next = hapus.next;

67

Delete Node x
3. hapus.next.prev = hapus.prev;

68

Delete Node x
Node 3 sudah terhapus

69