LINKED LIST Double Linked List Double artinya field

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. first. Node last. Node 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 Node 2 P { int data; // data Node 2 P next; Node 2 P prev; } // pointer next // pointer prev Ilustrasi : next data prev Penjelasan: • Pembuatan class bernama Node 2 P, yang berisi variabel data bertipe Object dan 2 variabel pointer bertipe Node 2 P 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 Node 2 P { int data; Node 2 P next; Node 2 P previous; Constructor 1 null Constructor 2 } Node 2 P() {} null Node 2 P(int the. Data) { data = the. Data; } data null Node 2 P(int the. Data, Node 2 P the. Previous, Node 2 P the. Next) Constructor 3 { next data= the. Data; previous = the. Previous; data next = the. Next; } prev

Alokasi Simpul Node 2 P baru = new Node 2 P(10); 9

Operasi Linked List 1. 2. 3. 4. 5. 6. 7. 8. inisialisasi is. Empty size Penambahan Penghapusan Penyisipan Pencarian Pengaksesan

(1) Inisialisasi Awal Pointer Head & Tail Node 2 P head = null; Node 2 P tail= null; head NULL tail 11

(2)is. Empty • Digunakan untuk mengetahui linked dalam kondisi kosong. • Kondisi kosong : jika size = 0 atau jika head=tail=null. boolean is. Empty() { 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 add. First(Node 2 P input){ if (is. Empty()){ 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 add. Last(Node 2 P input){ if (is. Empty()){ 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 insert. After(int key, Node 2 P input){ Node 2 P 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 insert. Before(Object key, Node 2 P input){ Node 2 P temp = head; while (temp != null){ if (temp. data == key) { if(temp == head) { this. add. First(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 remove. First(){ Node 2 P temp = head; if (!is. Empty()){ 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 remove. Last(){ Node 2 P temp = tail; if (!is. Empty()){ 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){ Node 2 P temp = head; if (!is. Empty()){ while (temp != null){ if (temp. data == key){ if (temp == head){ this. remove. First(); 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