> For the complete documentation index, see [llms.txt](https://polinema.gitbook.io/jti-modul-praktikum-algoritma-dan-struktur-data/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://polinema.gitbook.io/jti-modul-praktikum-algoritma-dan-struktur-data/struktur-data-linier/job-sheet-8-doubly-linked-list/praktikum-1.md).
# Praktikum 1
## Deksripsi
Pada praktikum 1 ini akan dibuat class `Node` dan class `DoublyLinkedList` yang didalamnya terdapat operasi-operasi untuk menambahkan data dengan beberapa cara (dari bagian depan linked list, belakang ataupun indeks tertentu pada linked list).
Class diagram berikut merupakan acuan utama untuk class `Node` dan `DoublyLinkedList`
## Langkah Percobaan
* Buatlah projek baru.
* Buat kelas `Node`.
* Tambahkan atribut berikut pada kelas `Node`.
{% code overflow="wrap" lineNumbers="true" %}
```java
int data;
Node next, prev;
```
{% endcode %}
* Tambahkan konstruktor untuk kelas `Node`.
{% code overflow="wrap" lineNumbers="true" %}
```java
public Node(Node prev, int data, Node next) {
this.prev = prev;
this.data = data;
this.next = next;
}
```
{% endcode %}
* Buat kelas `DoublyLinkedList`.
* Pada kelas tersebut, tambahkan atribut berikut,
{% code overflow="wrap" lineNumbers="true" %}
```java
Node head;
int size;
```
{% endcode %}
* Selanjutnya, buatlah konstruktor untuk kelas `DoublyLinkedList`.
{% code overflow="wrap" lineNumbers="true" %}
```java
public DoublyLinkedList() {
head = null;
size = 0;
}
```
{% endcode %}
* Tambahkan method `isEmpty()`.
{% code overflow="wrap" lineNumbers="true" %}
```java
public boolean isEmpty() {
return head == null;
}
```
{% endcode %}
* Kemudian, buat method `addFirst()`. Method ini akan menjalankan penambahan data di bagian depan linked list.
{% code overflow="wrap" lineNumbers="true" %}
```java
public void addFirst(int data) {
if (isEmpty()) {
head = new Node(null, data, null);
} else {
Node newNode = new Node(null, data, head);
head.prev = newNode;
head = newNode;
}
size++;
}
```
{% endcode %}
* Selain itu pembuatan method `addLast()` akan menambahkan data pada bagian belakang linked list.
{% code overflow="wrap" lineNumbers="true" %}
```java
public void addLast(int data) {
if (isEmpty()) {
addFirst(data);
} else {
Node current = head;
while (current.next != null) {
current = current.next;
}
Node newNode = new Node(current, data, null);
current.next = newNode;
size++;
}
}
```
{% endcode %}
* Untuk menambahkan data pada posisi yang telah ditentukan dengan indeks, dapat dibuat dengan method `add(int item, int index)`.
{% code overflow="wrap" lineNumbers="true" %}
```java
public void add(int data, int index) throws Exception {
if (isEmpty()) {
addFirst(data);
} else if (index < 0 || index > size) {
throw new Exception("Nilai index di luar batas");
} else {
Node current = head;
int i = 0;
while (i < index) {
current = current.next;
i++;
}
if (current.prev == null) {
Node newNode = new Node(null, data, current);
current.prev = newNode;
head = newNode;
} else {
Node newNode = new Node(current.prev, data, current);
newNode.prev = current.prev;
newNode.next = current;
newNode.prev.next = newNode;
current.prev = newNode;
}
}
size++;
}
```
{% endcode %}
* Jumlah data yang ada di dalam linked lists akan diperbarui secara otomatis, sehingga dapat dibuat method `size()` untuk mendapatkan nilai dari size.
{% code overflow="wrap" lineNumbers="true" %}
```java
public int size() {
return size;
}
```
{% endcode %}
* Selanjutnya dibuat method `clear()` untuk menghapus semua isi linked lists, sehingga linked lists dalam kondisi kosong.
public void clear() {
head = null;
size = 0;
}
* Untuk mencetak isi dari linked lists dibuat method `print()`. Method ini akan mencetak isi linked lists berapapun size-nya. Jika kosong akan dimunculkan suatu pemberitahuan bahwa linked lists dalam kondisi kosong.
{% code overflow="wrap" lineNumbers="true" %}
```java
public void print() {
if (!isEmpty()) {
Node tmp = head;
while (tmp != null) {
System.out.print(tmp.data + "\t");
tmp = tmp.next;
}
System.out.println("\nBerhasil diisi");
} else {
System.out.println("Linked Lists Kosong");
}
}
```
{% endcode %}
* Selanjutya dibuat class `DoublyLinkedListMain` untuk mengeksekusi semua method yang ada pada class `DoublyLinkedList`.
* Isikan kode berikut pada method main.
```java
DoublyLinkedList dll = new DoublyLinkedList();
dll.print();
System.out.println("Size : " + dll.size());
System.out.println("==========================");
dll.addFirst(3);
dll.addLast(4);
dll.addFirst(7);
dll.print();
System.out.println("Size : " + dll.size());
System.out.println("==========================");
dll.add(40, 1);
dll.print();
System.out.println("Size : " + dll.size());
System.out.println("==========================");
dll.clear();
dll.print();
System.out.println("Size : " + dll.size());
System.out.println("==========================");
```
## Verifiaksi Hasil Praktikum
Verifikasi hasil kompilasi kode program Anda dengan gambar berikut ini.
## Pertanyaan
* Jelaskan perbedaan antara single linked list dengan doubly linked lists!
* Perhatikan class Node, di dalamnya terdapat atribut `next` dan `prev`. Untuk apakah atribut
tersebut?
* Perhatikan konstruktor pada class `DoublyLinkedList`. Apa kegunaan inisialisasi atribut `head` dan `size`?
* Pada method `addFirst()`, mengapa dalam pembuatan objek dari konstruktor class Node prev dianggap sama dengan null?\
\
`head = new Node(null, data, null);`
* Perhatikan pada method `addFirst()`. Apakah arti statement `head.prev = newNode`?
* Perhatikan isi method `addLast()`, apa arti dari pembuatan objek Node dengan mengisikan parameter `prev` dengan `current`, dan `next` dengan `null`?\
\
`Node newNode = new Node(current, data, null);`
* Pada method add(), terdapat potongan kode program sebagai berikut. Jelaskan maksud dari potongan kode tersebut.
```java
if (current.prev == null) {
Node newNode = new Node(null, data, current);
current.prev = newNode;
head = newNode;
}
```