NAMA : AULIA NURHUDA
NIM : 047960114
MATA KULIAH : TUGAS 3 STURKTUR DATA
1. Program Sequential Search dengan Java
Berikut adalah implementasi program pencarian menggunakan algoritma Sequential Search
dalam bahasa Java:
```java
Public class SequentialSearch {
Public static void main(String[] args) {
Int[] data = {15, 23, 7, 9, 31}; // Data yang akan
dicari
Int n = 9; // Nilai yang akan dicari
Int index = sequentialSearch(data, n);
If (index != -1) {
System.out.println(“Nilai “ + n + “ ditemukan pada
indeks: “ + index);
} else {
System.out.println(“Nilai “ + n + “ tidak
ditemukan dalam array.”);
}
}
Public static int sequentialSearch(int[] arr, int x) {
For (int i = 0; i < arr.length; i++) {
If (arr[i] == x) {
Return i; // Mengembalikan indeks jika
ditemukan
}
}
Return -1; // Mengembalikan -1 jika tidak ditemukan
}
}
```
Penjelasan Proses Sequential Search
1. Inisialisasi Data:
- Data array diinisialisasi dengan nilai `[15, 23, 7, 9, 31]`.
- Nilai `n` yang akan dicari adalah `9`.
2. Looping Melalui Array:
- Fungsi `sequentialSearch` menerima array dan nilai `n`.
- Looping melalui setiap elemen array menggunakan indeks `i`.
- Pada setiap iterasi, memeriksa apakah elemen array pada indeks `i` sama dengan `n`.
3. Pemeriksaan Kondisi:
- Jika elemen sama dengan `n`, mengembalikan indeks `i`.
- Jika setelah loop selesai nilai tidak ditemukan, mengembalikan `-1`.
4. Output:
- Jika `index` bukan `-1`, menampilkan pesan bahwa nilai ditemukan pada indeks tersebut.
- Jika `index` adalah `-1`, menampilkan pesan bahwa nilai tidak ditemukan.
Program Binary Search dengan Java
Berikut adalah implementasi program pencarian menggunakan algoritma Binary Search
dalam bahasa Java:
```java
Import java.util.Arrays;
Public class BinarySearch {
Public static void main(String[] args) {
Int[] data = {7, 9, 15, 23, 31}; // Data yang akan
dicari, harus dalam urutan yang terurut
Int n = 23; // Nilai yang akan dicari
Int index = binarySearch(data, n);
If (index != -1) {
System.out.println(“Nilai “ + n + “ ditemukan pada
indeks: “ + index);
} else {
System.out.println(“Nilai “ + n + “ tidak
ditemukan dalam array.”);
}
}
Public static int binarySearch(int[] arr, int x) {
Int left = 0;
Int right = arr.length – 1;
While (left <= right) {
Int mid = left + (right – left) / 2;
// Cek apakah x ada di tengah
If (arr[mid] == x) {
Return mid;
}
// Jika x lebih besar, abaikan bagian kiri
If (arr[mid] < x) {
Left = mid + 1;
}
// Jika x lebih kecil, abaikan bagian kanan
Else {
Right = mid – 1;
}
}
Return -1; // Mengembalikan -1 jika tidak ditemukan
}
}
```
2. Penjelasan Proses Binary Search
1. Inisialisasi Data:
- Data array diinisialisasi dengan nilai `[7, 9, 15, 23, 31]` (data harus diurutkan).
- Nilai `n` yang akan dicari adalah `23`.
2. Inisialisasi Variabel:
- Variabel `left` diatur ke `0` dan `right` diatur ke panjang array minus satu (`4`).
3. Looping dan Pembagian Array:
- Fungsi `binarySearch` menggunakan loop `while` untuk membagi array menjadi dua
bagian.
- Menentukan indeks tengah (`mid`) sebagai `left + (right – left) / 2`.
- Memeriksa apakah elemen pada `mid` sama dengan `x`.
4. Pemeriksaan Kondisi:
- Jika elemen sama dengan `x`, mengembalikan indeks `mid`.
- Jika elemen lebih kecil dari `x`, mengabaikan bagian kiri dengan mengatur `left` ke `mid
+ 1`.
- Jika elemen lebih besar dari `x`, mengabaikan bagian kanan dengan mengatur `right` ke
`mid – 1`.
5. Output:
- Jika `index` bukan `-1`, menampilkan pesan bahwa nilai ditemukan pada indeks tersebut.
- Jika `index` adalah `-1`, menampilkan pesan bahwa nilai tidak ditemukan.
Analisis Kinerja
Sequential Search:
- Kompleksitas Waktu: O(n)
- Sequential search memeriksa setiap elemen satu per satu sehingga lebih lambat pada dataset
yang besar.
- Keuntungan: Tidak memerlukan data yang terurut.
Binary Search:
- Kompleksitas Waktu: O(log n)
- Binary search lebih cepat karena terus membagi array menjadi dua, mengurangi jumlah
elemen yang harus diperiksa setiap kali.
- Keterbatasan: Membutuhkan data yang sudah terurut.
Dari analisis di atas, Binary Search lebih efisien dalam hal waktu eksekusi jika data sudah
diurutkan, sementara Sequential Search lebih fleksibel tetapi kurang efisien untuk dataset
yang besar.
