STUKTUR DATA

PENGERTIAN STRUKTUR DATA

 Struktur data : cara menyimpan atau merepresentasikan data didalam komputer agar bisa
dipakai secara efisien.
 Data : representasi dari fakta dunia nyata
 Fakta atau keterangan tentang kenyataan yang disimpan, direkam atau direpresentasikan
dalam bentuk tulisan, suara, gambar, sinyal atau simbol.

TIPE DATA PRIMITIVE

STRUKTUR DATA

ADT(Abstract Data Type)

KOMPLEKSITAS ALGORITMA

 Sebuah masalah dapat mempunyai banyak algoritma penyelesaian. Contoh: masalah

pengurutan (sort), ada puluhan algoritma pengurutan
 Sebuah algoritma tidak saja harus benar, tetapi jugA harus mangkus (efisien).
 Algoritma yang bagus adalah algoritma yang mangkus (efficient).
 Kemangkusan algoritma diukur dari waktu (time) eksekusi algoritma dan kebutuhan ruang
(space) memori.
 Algoritma yang mangkus ialah algoritma yang meminimumkan kebutuhan waktu dan ruang.
 Kebutuhan waktu dan ruang suatu algoritma bergantung pada ukuran masukan (n), yang
menyatakan jumlah data yang diproses.

 Model abstrak pengukuran waktu/ruang harus independen dari pertimbangan mesin dan
compiler apapun.
 Besaran yang dipakai untuk menerangkan model abstrak pengukuran waktu/ruang ini
adalah kompleksitas algoritma
 Ada dua jenis kompleksitas algoritma, antara lain
*kompleksitas waktu (Tn) dan
* kompleksitas ruang (Sn)
 Ukuran masukan (n): jumlah data yang diproses oleh sebuah algoritma.
Contoh
 Algoritma pengurutan 1000 elemen larik,maka n = 1000.
 Algoritma perkalian 2 buah matriks berukuran 50 x 50, maka n = 50.
 Dalam praktek perhitungan kompleksitas, ukuran
 masukan dinyatakan sebagai variabel n saja
 Contoh : Tinjau algoritma menghitung rerata sebuah larik (array), dengan algoritma sebagai
berikut:
sum  0
for i  1 to n do
sum  sum + a[i]
endfor
rata_rata  sum/n
 Operasi yang mendasar pada algoritma adalah operasi penjumlahan elemen-elemen ai (yaitu
sumsum+a[i]) yang dilakukan sebanyak n kali.
 Kompleksitas waktu: T(n) = n
 LARIK (ARRAY)

 Larik (Array)
*Jenis struktur data statis
*Kumpulan data tunggal dalam satu variable (homogen)
*Akses setiap data melalui nomor index (0 – n)
 Jenis Larik (Array)
*1Dimensi
*2 Dimensi/Multidimensi

Defenition
 Array (Larik) : bentuk struktur Data yang menampung data yang sejenis atau bertipe sama
Contoh :
 Nilai 5 orang mahasiswa
100, 80, 78, 90, 75 ->> tipe integer
 Harga 4 jenis barang
1000,00; 2500,00; 3000,00; 1200,00 ->> tipe
double atau real
Nilai mahasiswa dan daftar harga barang di atas dapat disimpan dalam satu variabel yaitu array
Nilai 5 orang mahasiswa
100, 80, 78, 90, 75
Nama variabel : Nilai
Banyak elemen : 5
Tipe : integer

LARIK (ARRAY) 1 DIMENSI

DEKLARASI LARIK :
typedata [] varname;
varname = new type data[n]
int []ages;
ages = new int[100];
atau
typedata [] varname = new varname[n]
int [] ages = new int[100];
atau
int [] varname = {n1,n2,..nx};
int [] ages= {n1,n2,..n100}
1. Deklarasi
Sebelum digunakan, array harus terlebih dahulu di deklarasikan
Bentuk Umum :
Tipe_Data Nama_Variabel [ukuran]
Contoh :
int nilai [5];

2. Inisialisasi
 Inisialisasi adalah Memberikan nilai awal pada array
 2 cara :
 Pada saat deklarasi
Int Nilai [5]={100, 80, 78, 90, 75};
 Memberikan nilai satu persatu berdasarkan indeks array
Nilai[5]=100;
Nilai[6]=80;
Nilai[7]=78;
Nilai[8]=90;
Nilai[9]=75;

CONTOH LARIK (ARRAY) – 1

public class Larik01 {
public static void main(String[] args) {
int[] data;
data = new int[5];
data[0] = 10;
data[1] = 20;
data[2] = 30;
data[3] = 40;
data[4] = 50;
// Mencetak isi Larik
System.out.println("Isi Larik Pertama " + data[0]);
 System.out.println("Isi Larik Kedua " + data[1]);
System.out.println("Isi Larik Ketiga " + data[2]);
System.out.println("Isi Larik Keempat " + data[3]);
System.out.println("Isi Larik Kelima " + data[4]);
}
}
CONTOH LARIK (ARRAY) - 2
public class Larik02 {
public static void main(String[] args) {
int[] data={10,20,30,40,40};
System.out.println("Isi Larik Pertama " + data[0]);
System.out.println("Isi Larik Kedua " + data[1]);
System.out.println("Isi Larik Ketiga " + data[2]);
System.out.println("Isi Larik Keempat " + data[3]);
System.out.println("Isi Larik Kelima " + data[4]);
}
}
CONTOH LARIK DENGAN PERULANGAN
public class Larik03 {
public static void main(String[] args) {
int[] data={10,20,30,40,40};
for (int i = 0; i < 5; i++) {
System.out.println("Element at index " + i + " : "+ data[i]);
}
}
}
CONTOH DUPLIKASI LARIK
public class Larik04 {
public static void main(String[] args) {
int [] numbers = {1, 2, 3, 4, 5, 6};
int [] positiveNumbers = numbers;
for (int number: positiveNumbers) {
System.out.print(number + ", ");
}
}
}
CONTOH DUPLIKASI LARIK + PERULANGAN
import java.util.Arrays;
public class Larik05 {
public static void main(String[] args) {
int [] source = {1, 2, 3, 4, 5, 6};
int [] destination = new int[6];
for (int i = 0; i < source.length; ++i) {
destination[i] = source[i];
}
 System.out.println(Arrays.toString(destination));
}
}
CONTOH DUPLIKASI LARIK + ARRAYCOPY
import java.util.Arrays;
public class Larik06 {
public static void main(String[] args) {
int[] n1 = {2, 3, 12, 4, 12, -2};
int[] n3 = new int[5];
int[] n2 = new int[n1.length];
System.arraycopy(n1, 0, n2, 0, n1.length);
System.out.println("n2 = " + Arrays.toString(n2));
System.arraycopy(n1, 2, n3, 1, 2);
System.out.println("n3 = " + Arrays.toString(n3));
}
}
LARIK (ARRAY) 2/MULTI DIMENSI
DEKLARASI LARIK :
typedata [][] varname = new typedata [n][m]
contoh :
int [][] Matriks A = new int [2][2];
atau
typedata [][] varname = {{n1,n2..nx},{m1,m2,my}}
int []Matriks A ={{2,3,1},{3,2,5}};

Array 2 Dimensi
 Array satu dimensi adalah array yang terdiri dari baris dan kolom
 Array 2 dimensi disebut juga matriks
 Penerapan
Menyimpan nilai 5 orang mahasiswa yang terdiri dari nilai Tugas, UTS, UAS, berdasarkan no abesnsi

Data awal :
Matriks :

Data Matriks:

1. Deklarasi array 2D
Sebelum digunakan, array harus terlebih dahulu di deklarasikan
Bentuk Umum :
Tipe_Data Nama_Variabel [Jlh baris] [Jlh kol]
Contoh :
int nilai [3] [5];
2. Inisialisasi array 2D
 Inisialisasi adalah Memberikan nilai awal pada array
 2 cara :
 Pada saat deklarasi
Int Nilai [3] [5]={
{100,80,70,90,100},
{75, 87,98,89, 65},
{99, 97,96,95, 99}
};
 Inisialisasi adalah Memberikan nilai awal pada array
 2 cara :
 Memberikan nilai satu persatu berdasarkan indeks array
Nilai[0][0]=100;
Nilai[0][1]=80;
Nilai[0][2]=70;
Nilai[0][3]=90;
Nilai[0][4]=100;
........................
Nilai[2][4]=99;
 CONTOH LARIK 2 DIMENSI - 1
public class Larik07 {
public static void main(String[] args) {
int array[][]= {{1,3,5},{2,4,6}};
System.out.println("Informasi Mengenai Array");
System.out.println("Jumlah Baris= " + array.length);
System.out.println("Jumlah Kolom = " + array[1].length);
System.out.println("Mencetak Isi Larik");
System.out.println(array[0][0]);
System.out.println(array[0][1]);
System.out.println(array[0][2]);
System.out.println(array[0][2]);
System.out.println(array[1][0]);
System.out.println(array[1][1]);
System.out.println(array[1][2]);
}
}
CONTOH LARIK 2 DIMENSI - 2
public class Larik08 {
public static void main(String[] args) {
int array[][]= {{1,3,5},{2,4,6}};
System.out.println("Informasi Mengenai Array");
System.out.println("Jumlah Baris= " + array.length);
System.out.println("Jumlah Kolom= " + array[1].length);
System.out.println("Mencetak Isi Larik");
for (int i=0; i<2 ;i++){
for (int j=0; j<3; j++){
System.out.println(array[i][j]);
}
}
}
}
CONTOH DUPLIKASI LARIK 2 DIMENSI
import java.util.Arrays;
public class Larik09 {
public static void main(String[] args) {
int[][] source = { {1, 2, 3, 4}, {5, 6}, {0, 2, 42, -4, 5}};
int[][] destination = new int[source.length][];
for (int i = 0; i < destination.length; ++i) {
destination[i] = new int[source[i].length];
for (int j = 0; j < destination[i].length; ++j) {
destination[i][j] = source[i][j];
}
}
System.out.println(Arrays.deepToString(destination));
 }
}
CONTOH DUPLIKASI LARIK + ARRAYCOPY
import java.util.Arrays;
public class Larik10 {
public static void main(String[] args) {
int[][] source = { {1, 2, 3, 4}, {5, 6}, {0, 2, 42, -4, 5}};
int[][] destination = new int[source.length][];
for (int i = 0; i < source.length; ++i) {
destination[i] = new int[source[i].length];
System.arraycopy(source[i], 0, destination[i], 0, destination[i].length);
}
System.out.println(Arrays.deepToString(destination));
}
}
IMPLEMENTASI : PENJUMLAHAN MATRIKS
public class Larik02 {
public static void main(String[] args) {
int i, j;
int hasil[][] = new int[2][2];
int [][]matriks1 = { {2, 3}, {4, 5} };
int [][]matriks2 = { {4, 3}, {2, 7} };
System.out.println("Menampilkan elemen matriks pertama: ");
for (i = 0; i < 2; i++) {
for (j = 0; j < 2; j++) {
System.out.println(matriks1[i][j]);
}
}
System.out.println("Menampilkan elemen matriks kedua: ");
for (i = 0; i < 2; i++) {
for (j = 0; j < 2; j++) {
System.out.println(matriks2[i][j]);
}
}
System.out.println("Hasil penjumlahan matriks: ");
for (i = 0; i < 2; i++) {
for (j = 0; j < 2; j++) {
hasil[i][j] = matriks1[i][j] + matriks2[i][j];
System.out.println(hasil[i][j]);
//System.out.print(hasil[i][j] + "\t");
}
System.out.println();
}
}
}
Operasi Matriks
• Penjumlahan Matriks
Penjumlahan dua matriks A + B bisa dilakukan asalkan kedua matriks tersebut berukuran
sama, yaitu

• Pengurangan Matriks
Penguragan matriks memiliki konsep yang sama dengan penjumlahan. Dua buah matriks
dapat dikurangkan apabila keduanya memiliki ordo yang sama.
Hasil operasi pengurangannya adalah matriks baru yang memiliki ordo sama dengan matriks
semula, dengan elemen-elemennya terdiri dari hasil pengurangan dengan elemen-elemen pada
matriks.

• Perkalian Matriks
Diberikan dua matriks A berukuran m × n dan matriks B berukuran n × k (Baris dikali
Kolom). Perkalian matriks A dengan B adalah matriks C berukuran m × k di mana:

• Contoh
Diberikan matriks A berukuran 3 × 2 (yaitu 3 baris 2 kolom) dengan matriks B berukuran 2 ×
3 (yaitu 2 baris dan 3 kolom) beserta matriks C = A × B sebagai berikut:

• Perkalian Matriks dengan Skalar (bilangan ril)

Diberikan matriks A dan U masing-masing dengan ukuran 3 × 4 dan 4 × 1; hasilnya adalah
vektor V yang tentu saja berukuran 3 × 1, seperti terlihat di bawah ini:
Operasi Matriks
package matriks;
import java.util.Scanner;
public class Matriks {
public static void main(String[] args) {
// Operasi pada matriks
Scanner input = new Scanner(System.in);
String pilih;
int m,n,p,o,k;
System.out.println(“Matriks A dan B”);
//matriks A
System.out.println(“Ukuran matriks A”);
System.out.println(“Masukkan ukuran baris : “);
m = input.nextInt();
System.out.println(“Masukkan ukuran kolom : “);
n = input.nextInt();
int A [][] = new int [m][n];
System.out.println();
System.out.println(“Inputkan nilai-nilai untuk matriks A”);
for (int i = 0; i < A.length; i++){
for (int j = 0; j < A[0].length; j++){
System.out.print(“Nilai A[” +i+ “][” +j+ “]\t:”);
A[i][j]= input.nextInt();
}}
System.out.println(” “);
//matriks B
System.out.println(“Ukuran matriks B”);
{System.out.println(“Masukkan ukuran baris : “);
p = input.nextInt();
System.out.println(“Masukkan ukuran kolom : “);
o = input.nextInt();
int B [][] = new int [p][o];
System.out.println();
System.out.println(“Inputkan nilai-nilai untuk matriks B”);
for (int i = 0; i < B.length; i++){
for (int j = 0; j < B[0].length; j++){
System.out.print(“Nilai B[” +i+ “][” +j+ “]\t:”);
B[i][j]= input.nextInt();}}
//tampil matriks A
System.out.println(“Matriks A = “);
for (int i = 0; i < A.length; i++){
for (int j = 0; j < A[0].length; j++){
System.out.print(” ” + A[i][j]);
}
System.out.println(” “);}
//tampil matriks B
System.out.println(“Matriks B = “);
for (int i = 0; i < B.length; i++){
for (int j = 0; j < B[0].length; j++){
System.out.print(” ” + B[i][j]);
}
System.out.println(” “);}
int[][]jumlah = new int[m][n];
int[][]kurang = new int [m][n];
int[][]kali = new int [m][n];
int [][]bagi = new int [m][n];
System.out.println(“Pilihan operasi:\n1. Penjumlahan\n2. Pengurangan\n3. Perkalian\n4.
Pembagian”);
int Pilih;
System.out.println(“Pilih operasi matriks yang anda inginkan : “);
Pilih = input.nextInt();
//Penjumlahan
if (Pilih==1){
if (m==p&&n==o){
for (int i = 0; i < m; i++){
for (int j = 0; j <n; j++){
jumlah[i][j] = A[i][j]+B[i][j];}}
System.out.println(“Jumlah matriks A dan B adalah “);
for (int i = 0; i < m; i++){
for (int j = 0; j <n; j++){
System.out.print(” ” + jumlah[i][j]);}
System.out.println(” “);
}}else {
System.out.println(“Ordo matriks A dan B berbeda”);}}
//Pengurangan
else if (Pilih==2){
if (m==p&&n==o){
for (int i = 0; i < m; i++){
for (int j = 0; j <n; j++){
kurang[i][j]= A[i][j]-B[i][j];} }
System.out.println(“Pengurangan matriks A dan B adalah “);
for (int i = 0; i < m; i++){
for (int j = 0; j <n; j++){
System.out.print(” ” + kurang[i][j]);}
System.out.println(” “);}}
else {
System.out.println(“Ordo matriks A dan B berbeda”);}}
//Perkalian
else if (Pilih==3){
System.out.println(“Masukkan Nilai k : “);
k = input.nextInt();
for (int i = 0; i < m; i++){
for (int j = 0; j <n; j++){
kali[i][j]=A[i][j]*k;
}}
System.out.println(“Perkalian k dengan matriks A adalah”);
for (int i = 0; i < m; i++){
for (int j = 0; j < n; j++){
System.out.print(” ” + kali[i][j]);
}
System.out.println(” “);}
for (int i = 0; i < p; i++){
for (int j = 0; j <o; j++){
kali[i][j]=B[i][j]*k;
}}
System.out.println(“Perkalian k dengan matriks B adalah”);
for (int i = 0; i < p; i++){
for (int j = 0; j < o; j++){
System.out.print(” ” + kali[i][j]);
}
System.out.println(” “);}}
//Pembagian
else if (Pilih==4){
System.out.println(“Masukkan Nilai k : “);
k = input.nextInt();
for (int i = 0; i < m; i++){
for (int j = 0; j <n; j++){
bagi[i][j]=A[i][j]/k;
}}
System.out.println(“Pembagian k dengan matriks A adalah”);
for (int i = 0; i < m; i++){
for (int j = 0; j < n; j++){
System.out.print(” ” + bagi[i][j]);
}
System.out.println(” “);}
for (int i = 0; i < p; i++){
for (int j = 0; j <o; j++){
bagi[i][j]=B[i][j]/k;
}}
System.out.println(“Pembagian k dengan matriks B adalah”);
for (int i = 0; i < p; i++){
for (int j = 0; j < o; j++){
System.out.print(” ” + bagi[i][j]);
}
System.out.println(” “);}}}}}
TUGAS !
 Dengan mengimplementasikan larik (array), tentukan daftar mahasiswa yang lulus di Kelas
Anda. Data yang dimasukkan adalah Nama dan Nilai. Bila Nilai >50, maka Lulus. Tampilan
sebagai berikut:

FUNGSI(METHOD)

 Fungsi (function) adalah kode program yang dirancang untuk menyelesaikan sebuah tugas
tertentu, dan bagian dari program utama.
 Bahasa Java sebenarnya tidak dikenal istilah function, akan tetapi disebut dengan method
 Fungsi dibedakan atas :
 Built-In Function
Fungsi yang bawaan bahasa pemrograman. Sebagai contoh, perintah
System.out.println()
 User Defined Function
Fungsi yang dibuat sendiri (sesuai kebutuhan)
KESEPAHAMAN MODULARITAS

 Prosedur adalah sebutan untuk fungsi yang tidak mengembalikan nilai. Fungsi ini biasanya
ditandai dengan kata kunci void.
 Fungsi adalah sebutan untuk fungsi yang mengembalikan nilai.
 Method adalah fungsi yang berada di dalam Class. Sebutan ini, biasanya digunakan pada
OOP.
FORMAT FUNGSI

static tipeDataKembalian namaFunction( ) {

// Isi function disini...
// Isi function disini...
return nilai;
}
PENJELASAN FORMAT FUNGSI

 Kata kunci static, artinya kita membuat fungsi yang dapat dipanggil tanpa harus membuat
instansiasi objek.
 TypeDataKembalian adalah tipe data dari nilai yang dikembalikan setelah fungsi dieksekusi.
 namaFungsi() adalah nama fungsinya. Biasanya ditulis dengan huruf kecil di awalnya. Lalu,
kalau terdapat lebih dari satu suku kata, huruf awal di kata kedua ditulis kapital
 MEMANGGIL FUNGSI
public static void main(String[] args){
namaFungsi();
}
CONTOH FUNGSI
class BelajarJava {
static void sapaan() {
System.out.println(“Fikom UMI");
}
public static void main(String args[]){
sapaan();
sapaan();
sapaan();
}
}
FORMAT FUNGSI DALAM CLASS (METHOD)
class NamaClass {
static tipeDataKembalian namaFunction() {
// Isi function disini...
return nilai;
}
public static void main(String args[]){
// Jalankan function
namaFunction()
}
}
CONTOH FUNGSI DALAM CLASS (METHOD)

class BelajarJava {
static void hitungLuasSegitiga() {
double alas = 5;
double tinggi = 7;
double luas = (alas * tinggi) / 2;
System.out.println("Luas segitiga adalah: "+luas);
}
public static void main(String args[]){
hitungLuasSegitiga();
}
}
FUNGSI DENGAN PARAMETER

class NamaClass {
static tipeDataKembalian namaFunction(tipeData param1, tipeData param2) {
// Isi fungsi disini...
// Isi fungsi disini...
return nilai;
 }
public static void main(String args[]){
// Jalankan fungsi
namaFunction(arg1, arg2)=
}
}
PENJELASAN FUNGSI DENGAN PARAMETER
 Parameter ditulis di antara tanda kurung (...)
 Parameter harus diberikan tipe data
 Bila terdapat lebih dari satu parameter, maka dipisah dengan tanda koma.
CONTOH FUNGSI DENGAN PARAMETER

class BelajarJava {
static void sapaTeman(String nama) {
System.out.println("Hai, "+nama);
}

public static void main(String args[]){

sapaTeman(“Andra");
}
}
CONTOH FUNGSI DENGAN PARAMETER

class BelajarJava {
static void sapaTeman(String nama1, String nama2, String nama3) {
System.out.println("Hai, "+nama1+", "+nama2+", "+nama3);
}
public static void main(String args[]){
sapaTeman("Lisa", "Nova", "Putri");
}
}
CONTOH FUNGSI DENGAN PARAMETER
class BelajarJava {
static void hitungLuasSegitiga(int alas, int tinggi) {
double luas = (alas * tinggi) / 2;
System.out.println("Luas segitiga adalah: "+luas);
}
public static void main(String args[]){
hitungLuasSegitiga(5, 7);
hitungLuasSegitiga(2, 10);
hitungLuasSegitiga(191, 357);
}
}
CONTOH FUNGSI DENGAN PARAMETER - 02
class BelajarJava {
 static int hargaSetelahPajak(int hargaDasar) {
return hargaDasar + (hargaDasar * 10/100);
}
public static void main(String args[]){
int hargaPulpen = 5000;
int hargaFinalPulpen = hargaSetelahPajak(hargaPulpen);
System.out.println("Harga Pulpen 1 buah Rp."+hargaFinalPulpen);
}
}
CONTOH FUNGSI DENGAN RETURN
public class BangunRuang {
public static void main(String[] args) {
int s = 12;
int luas = luasKubus(s);
System.out.println(luas);
}
// membuat fungsi luasPersegi()
static int luasPersegi(int sisi){
return sisi * sisi;
}
// membuat fungsi luasKubus()
static int luasKubus(int sisi){
// memanggil fungsi luasPersegi
return 6 * luasPersegi(sisi);
}
}
}
CONTOH FUNGSI STATIC DAN NON STATIC
public class FungsiStatic {
// Fungsi non-static
void makan(String makanan){
System.out.println("Hi!");
System.out.println("Saya sedang makan " + makanan);
}
// Fungsi static
static void minum(String minuman){
System.out.println("Saya sedang minum " + minuman);
}
// fungsi main
public static void main(String[] args) {
// pemanggilan fungsi static
minum("Kopi");
// mambuat instansiasi objek saya dari class FungsiStatic
FungsiStatic saya = new FungsiStatic();
// pemanggilan fungsi non-static
 saya.makan("Nasi Goreng");
}
}
CONTOH FUNGSI VARIABEL GLOBAL DAN LOKAL
class ProgramKu{
// ini variabel global
static String nama = "Program Pertamaku";
static String version = "1.0.0";
static void help(){
// ini variabel lokal
String nama = “Fikom UMI";
// mengakses variabel global di dalam fungsi help()
System.out.println("Nama: " + nama);
System.out.println("Versi: " + version);
}
public static void main(String args[]){
// panggil fungsi help()
help();
System.out.println("Nama: " + nama);
System.out.println("Versi: " + version);
}
}
TRANSFER PARAMETER BY VALUE
 Ketika pass-by-values terjadi, method membuat sebuah salinan dari nilai variable yang
dikirimkan ke method.
 Walaupun demikian, method t idak dapat secara langsung memodifikasi nilai variabel
pengirimnya meskipun parameter salinannya sudah dimodifikasi nilainya di dalam method
CONTOH TRANSFER PARAMETER BY VALUE

public class SD_0412 {

public static void fungsiTukar(int a, int b) {
System.out.println("Sebelum Pertukaran , a = " + a + " b = " + b);
int c = a;
a = b;
b = c;
System.out.println("Setelah Pertukaran, a = " + a + " b = " + b);
}
CONTOH TRANSFER PARAMETER BY VALUE
public static void main(String[] args) {
int a = 30;
int b = 45;
System.out.println("Sebelum Pertukaran, a = " + a + " dan b = " + b);
fungsiTukar(a, b);
System.out.println("Setelah Pertukaran, a = " + a + " dan b adalah " + b);
 }
}
TRANSFER PARAMETER BY REFERENCE
 Ketika sebuah pass-by-reference terjadi, alamat memori dari nilai pada sebuah variabel
dilewatkan pada saat pemanggilan method.
 Hal ini berarti bahwa method menyalin alamat memori dari variabel yang dilewatkan pada
method.
 Method dapat memodifikasi variabel asli dengan menggunakan alamat memori tersebut,
meskipun berbeda nama variabel yang digunakan dalam method dengan variabel aslinya,
kedua variabel ini menunjukkan lokasi dari data yang sama.
 Di Java, pass by reference bisa digunakan pada obyek
 Kesalahan konsep mengenai pass-by-reference pada Java adalah pada saat membuat
method untuk menukar nilai variabel menggunakan pengalamatan java.
 Perlu diingat bahwa java memanipulasi obyek-obyek dengan cara ‘by reference’, akan tetapi
java mengirimkan alamat obyek ke dalam method dengan cara ‘by value’.
CONTOH TRANSFER PARAMETER BY REFENCE

public class SD_0413 {

public static void fungsiTukar(intWrap a, intWrap b) {
System.out.println("Sebelum Pertukaran, a = " + a.a + " b = " + b.a);
intWrap c = new intWrap(a.a);
a.a = b.a;
b.a = c.a;
System.out.println("Setelah Pertukaran, a = " + a.a + " b = " + b.a);
}
CONTOH TRANSFER PARAMETER BY REFENCE
public static void main(String[] args) {
intWrap a = new intWrap(30);
intWrap b = new intWrap(45);
System.out.println("Sebelum Pertukaran, a = " + a.a + " dan b = " + b.a);
fungsiTukar(a, b);
System.out.println("Setelah Pertukaran, a = " + a.a + " dan b adalah " + b.a);
}
}
FUNGSI REKURSIF
 Fungsi yang berisi definisi dirinya sendiri atau pada matematika rekursif adalah sebuah
fungsi yang didalamnya ada fungsi itu sendiri.
 Prosesnya terjadi secara berulang-ulang (tapi tidak menggunakan perintah perulangan hanya
dengan jika maka
 Yang perlu diperhatikan adalah “stopping role”(membuat fungsi itu berhenti menghitung
atau memproses)
KELEBIHAN DAN KELEMAHAN REKURSIF

 Karena program lebih singkat dan ada beberapa kasus yang lebih mudah menggunakan
fungsi yang rekursif
  Memakan memori yang lebih besar, karena setiap kali bagian dirinya dipanggil, dibutuhkan
sejumlah ruang memori tambahan.
 Mengorbankan efisiensi dan kecepatan
 Problem: rekursi seringkali tidak bisa “berhenti” sehingga memori akan terpakai habis dan
program bisa hang.
 Saran: jika memang bisa diselesaikan dengan iterative gunakanlah iteratif!
CONTOH REKURSIF

 Faktorial Bilangan

 Deret Fibonacci

CONTOH FAKTORIAL REKURSIF

public class Factorial{
public static void main(String[] args) {
int hasil = rekursif(5);
System.out.print(hasil);
}
public static Integer rekursif(int n){
if(n == 0 || n == 1){
return 1;
}else{
return n * rekursif(n-1);
}
}
}
CONTOH FIBONACCI REKURSIF
public class Fibo{
public static void main(String[] args) {
for (int i = 0; i < 5; i++) {
int hasil = fiboRekursif(i);
System.out.print(hasil + " ");
}
}
public static Integer fiboRekursif(int n) {
if (n == 0) {
return 0;
}
if (n == 1) {
return 1;
}
 return fiboRekursif(n - 1) + fiboRekursif(n - 2);
}
}
TUGAS
 Buat rancangan program dan program dengan menggunakan fungsi return tanpa rekursi dan
fungsi rekursif (jadi satu program untuk 1 kasus ) untuk :
 Menghitung x pangkat y
 Mencari jumlah suku (Sn) deret Aritmatika dengan inputan a,b,dan n
 Mencari jumlah suku (Sn) dari deret geometri dengan inputan a,r dan n
 Menentukan deret ke-n dari deret Fibonacci (1,1,2,3,5,8,13,…)
TUGAS
Dengan menerapkan Fungsi (Method), buatlah program untuk menentukan apakah String yang
diiskan adalah PALINDROME
Masukkan:
Isikan sebuah Teks : Kasur Rusak
Output
Kasur Rusak adalah PALINDROME
TUGAS
Dengan menerapkan Fungsi (Method), buatlah program untuk menentukan apakah TAHUN yang
diinput pengguna adalah TAHUN KABISAT
Masukkan:
Tahun : ……
Output
Aadalah Tahun ….

SENARAI TUNGGAL
(SINGLE LINKED LIST)

 Struktur data yang berisi kumpulan data yang tersusun secara sekuensial, saling
bersambungan, dinamis dan terbatas adalah senarai berkait (linked list).
 Suatu senarai berkait (linked list) adalah suatu simpul (node) yang dikaitkan dengan simpul
yang lain dalam suatu urutan tertentu.
 Suatu simpul dapat berbentuk suatu struktur (structure) atau kelas (class)
 Simpul harus mempunyai satu atau lebih elemen struktur atau class yang berisi data.
 Secara teori, linked list adalah sejumlah node yang dihubungkan secara linier.
 Senarai berkait lebih efisien di dalam melaksanakan penyisipan-penyisipan dan
penghapusan-penghapusan.
 Senarai berkait juga menggunakan alokasi penyimpanan secara dinamis, yang merupakan
penyimpanan yang dialokasikan pada runtime
 JENIS SENARAI

 Senarai Tunggal (Single Linked List)

 Bila hanya ada satu pointer yang menghubungkan setiap node (satu arah “next”).
 Senarai Ganda (Double Linked List)
 Bila hanya ada dua pointer yang menghubungkan setiap node (dua arah “next” dan
”prev”).
 Senarai Melingkar (Circular Linked List)

OPERASI DASAR SENARAI

 INSERT
 Insert First : Elemen yang disisip di depan list
 Insert Last : Elemen yang disisip di belakang list
 Insert After/Before : Elemen yang disisip diposisi tertentu
 DELETE
 Delete First : Elemen yang dihapus di depan list
 Delete Last : Elemen yang dihapus di belakang list
 Delete After/Before : Elemen yang dihapus diposisi tertentu

PEMBUATAN SENARAI

 Sebuah node pada linked list mempunyai dua instance variabel :

 nodeValue dengan tipe generics T.
 next dengan tipe Node yang merupakan link ke node berikutnya.
 Class Node memiliki dua constructor yaitu:
 Default constructor : menginisialisasi variable nodeValue dan next dengan null
 Constructor dengan parameter : memberikan nilai pada variabel nodeValue dan
memberikan nilai pada variabel next dengan null.
Menyimpan data dan menghubungkan ke note berikutnya
public class Listnode<E> {
private E data;
private Listnode<E> next;
public Listnode(E d) {
this(d, null);
}
PEMBUATAN SENARAI - CLASS NOTE
Menginisialisasi nodevalue dan memberikan nilia next dengan null
public Listnode(E d, Listnode n) {
data = d;
next = n;
}
 Memerlukan variabel reference front untuk menandai node pertama pada list.
 Pada saat kita di node pertama, maka kita dapat menggunakan variabel next untuk
menghubungkan dengan node ke dua, node ke tiga dan node berikutnya
 MEMBUAT NODE

MENGAKSES NODE

INSERT FIRST
 Insert element P into List L so that P become the first element of L

TAHAPAN INSERT FIRST

 Bila list kosong, maka front bernilai null

 Menambah Node di Depan

 TAHAPAN INSERT FIRST

INSERT LAST
 Insert element P into List L so that P become the last element of L

TAHAPAN INSERT LAST

 Menambah Node di Akhir

TAHAPAN INSERT LAST

INSERT AFTER
 Insert element P into List L so that P become the next element of Prec
 TAHAPAN INSERT AFTER

DELETE FIRST
 Remove the first element of L

TAHAPAN DELETE FIRST

DELETE LAST
 Remove the last element of L

TAHAPAN DELETE LAST

DELETE AFTER
 Remove element after the element pointed by Prec

TAHAPAN DELETE AFTER

METHOD DALAM SINGLE LINKED LIST

IMPLEMENTASI SENARAI – JAVA COLLECTION

import java.util.LinkedList;
public class SD_1000 {
public static void main(String[] args) {
LinkedList<String> buah = new LinkedList<String>();
buah.add("Jeruk");
buah.add("Nenas");
buah.add("Semangka");
buah.add("Melon");
System.out.println("Isi Senarai saat ini :" + buah);
//Menambah data diawal senarai
buah.addFirst("Rambutan");
System.out.println("Isi senarai setelah ditambah diawal : " + buah);
//Menambah data diakhir senarai
buah.addLast("Apel");
System.out.println("Isis senarai setelah ditambah diakhir : " + buah);
//Menambah di Posisi tertentu ketiga
buah.add(2, "Pisang");
System.out.println("Isi Senarai setelah ditambahkan di posisi tertentu : "+ buah);
//Menampilkan data Awal
System.out.println("Isi Data awal pada senarai :" + buah.getFirst());
//Menampilkan data terakhir
System.out.println("Isi Data terakhir pada senari :" + buah.getLast());
}
}
PEMBUATAN SENARAI - CLASS NOTE
public class SD_1001 {
Node head;
//Membuat constructor
class Node {
int data;
Node next;
Node(int d) {
data = d;
next = null;
}
}
PEMBUATAN SENARAI - CLASS NOTE
public void insertAtBeginning(int new_data) {
Node new_node = new Node(new_data);
new_node.next = head;
head = new_node;
}
public void insertAfter(Node prev_node, int new_data) {
if (prev_node == null) {
System.out.println("Previous not tidak kosong");
return;
}
PEMBUATAN SENARAI - CLASS NOTE
Node new_node = new Node(new_data);
new_node.next = prev_node.next;
prev_node.next = new_node;
}
public void insertAtEnd(int new_data) {
Node new_node = new Node(new_data);
if (head == null) {
head = new Node(new_data);
return;
}
PEMBUATAN SENARAI - CLASS NOTE
new_node.next = null;
Node last = head;
while (last.next != null)
last = last.next;
last.next = new_node;
return;
 }
PEMBUATAN SENARAI - CLASS NOTE
void deleteNode(int position) {
if (head == null)
return;
Node temp = head;
if (position == 0) {
head = temp.next;
return;
}
PEMBUATAN SENARAI - CLASS NOTE
for (int i = 0; temp != null && i < position - 1; i++)
temp = temp.next;
if (temp == null || temp.next == null)
return;
Node next = temp.next.next;
temp.next = next;
}
PEMBUATAN SENARAI - CLASS NOTE
boolean search(Node head, int key) {
Node current = head;
while (current != null) {
if (current.data == key)
return true;
current = current.next;
}
return false;
}
PEMBUATAN SENARAI - CLASS NOTE
void sortLinkedList(Node head) {
Node current = head;
Node index = null;
int temp;
if (head == null) {
return;
} else {
while (current != null) {
index = current.next;
while (index != null) {
if (current.data > index.data) {
PEMBUATAN SENARAI - CLASS NOTE
temp = current.data;
current.data = index.data;
index.data = temp;
}
 index = index.next;
}
current = current.next;
}
}
}
PEMBUATAN SENARAI - CLASS NOTE
public void printList() {
Node tnode = head;
while (tnode != null) {
System.out.print(tnode.data + " ");
tnode = tnode.next;
}
}
PEMBUATAN SENARAI - CLASS NOTE
public static void main(String[] args) {
SD_0900 llist = new SD_0900();
llist.insertAtEnd(1);
llist.insertAtBeginning(2);
llist.insertAtBeginning(3);
llist.insertAtEnd(4);
llist.insertAfter(llist.head.next, 5);
System.out.println("Senarai: ");
llist.printList();
PEMBUATAN SENARAI - CLASS NOTE
System.out.println("\nHasil setelah penghapusan elemen: ");
llist.deleteNode(3);
llist.printList();
System.out.println();
int item_to_find = 3;
if (llist.search(llist.head, item_to_find))
System.out.println(item_to_find + " ditemukan");
else
System.out.println(item_to_find + " tidak ditemukan");
llist.sortLinkedList(llist.head);
System.out.println("\nUrutan List: ");
llist.printList();
}
}
SENARAI GANDA
(DOUBLE LINKED LIST)
 Double Linked List (DLL) mempunyai struktur sequential.
 Double Linked List terdiri dari dua reference yang menunjuk ke node selanjutnya (next node)
dan node sebelumnya (previous node)
  Untuk bergerak maju dan mundur pada double linked list menggunakan link next dan prev
pada node.
 Double Linked List mempunyai reference front untuk menandai awal node dan reference
back untuk menandai akhir list

PEMBACAAN SENARAI GANDA

 Double Linked List dapat dibaca melalui dua arah.
 Pembacaan maju (forward scan) yaitu membaca double linked list dimulai dari
reference front dan berakhir pada reference back.
 Pembacaan mundur (backward scan) yaitu membaca double linked list dimulai dari
reference back dan berakhir pada reference front.

CLASS DLL NODES

 Node pada Double Linked List di representasikan dengan class DNode
 Kumpulan object DNode membentuk sebuah list disebut double linked list

CLASS DLL NODES

 Object DNode mempunyai tiga variabel:
 nodeValue untuk menyimpan nilai
 prev untuk menandai node sebelumnya
 Next untuk menandai node sesudahnya.

CONSTRUCTOR CLASS DLL NODES

 Class mempunyai dua constructor.
 Default constructor
 Membuat object DNode dengan nodeValue bernilai null, sedangkan prev
dan next diset dengan nilai this (link yang menunjuk ke dirinya sendiri) .
 Constructor dengan argument
 Memberikan nilai pada nodeValue, sedangkan untuk variabel prev dan next
diset dengan nilai this.

CLASS DLL NODES

MEMBUAT NODE p dan q

MENYISIP NODE DI DEPAN

 Untuk menyisipkan Node diperlukan dua variabel reference yaitu:

 curr : menandai node saat ini
 prevNode : menandai node sebelum curr
 Menyisipkan node dilakukan sebelum curr dan sesudah prevNode.

MENGHAPUS NODE DI DEPAN

MENGHAPUS NODE DI BELAKANG

MENGHAPUS NODE DI SENARAI GANDA

 Untuk menghapus Node diperlukan dua variabel reference yaitu:
 curr : menandai node yang akan di hapus
 prevNode : menandai node sebelum curr
 Menghapus node dilakukan di curr.

MEMBACA MAJU DI SENARAI GANDA

MEMBACA MUNDUR DI SENARAI GANDA

IMPLEMENTASI SENARAI GANDA
package sd_dll;
class DoublyLinkedList {
// Class untuk Membuat Node Double Linked List (DLL)
class Node{
int item;
Node previous;
Node next;
public Node(int item) {
this.item = item;
}
}
//Insialisasi Head, Tail = Null
Node head, tail = null;
// Menambahkan node ke dalam list
public void addNode(int item) {
//Membuat Node baru
Node newNode = new Node(item);
//Bila list kosong, Head dan Tail adalah Node baru
if(head == null) {
head = tail = newNode;
//Head previous merujuk ke Null
head.previous = null;
//Tail nezt merujuk ke Null
tail.next = null;
}
else {
tail.next = newNode;
//newNode->previous diset ke tail
newNode.previous = tail;
//newNode menjadi tail bar
tail = newNode;
//tail's next menunjuk ke null
tail.next = null;
}
}
//Mencetak seluruh Node di DLL
 public void printNodes() {
Node current = head;
if(head == null) {
System.out.println("Doubly linked list Kosong");
return;
}
System.out.println("Nodes pada doubly linked list: ");
while(current != null) {
System.out.print(current.item + " ");
current = current.next;
}
}
}
IMPLEMENTASI SENARAI GANDA
public class SD_DLL {
public static void main(String[] args) {
//Membuat DLL sebagai objek
DoublyLinkedList dl_List = new DoublyLinkedList();
//Menambahkan Node ke List
dl_List.addNode(10);
dl_List.addNode(20);
dl_List.addNode(30);
dl_List.addNode(40);
dl_List.addNode(50);
//Mencetak semua Node
dl_List.printNodes();
}
}
JAVA COLLECTION
 Dikenalkan pada Java SDK
 Hashatble
 Vector
 Collection adalah suatu obyek yang digunakan untuk menyimpan sekumpulan obyek
 Obyek yang ada dalam Collection disebut elemen
 Collection menyimpan elemen yang bertipe Object
 Java Collection API terdiri:
 Collection : sekumpulan obyek yang tidak mempunyai posisi yang tetap (no
particular order) dan menerima duplikat.
 List: sekumpulan obyek yang berdasarkan urutan (ordered) dan menerima duplikat.
 Set: sekumpulan obyek yang tidak berdasarkan urutan (unordered) dan menolak
duplikat.
 Map: mendukung pencarian berdasarkan key, key ini harus unik. Has no particular
order.
LIST
 Elemen tersimpan berdasarkan urutan masukan (ordered).
 Menerima duplikat.
 Metode List:
 LinkedList : elemen dalam LinkedList masuk dari awal dan dihapus dari akhir.
 Vector : elemen larik yang berkembang.
 ArrayList: mirip vector, bersifat unsyncronized
ARRAY LIST

 ArrayList pada bahasa pemrograman Java, merupakan salah satu collection untuk
menampilkan daftar atau list nilai/value, yang bersifat dinamis
 ArrayList kita tidak dapat menggunakan tipe data primitive, seperti int, char, boolean, float,
dsb.

ARRAY VS ARRAY LIST

JAVA ARRAY LIST

 Mengimport ArrayList
import java.util.ArrayList;
 Membuat Objek ArrayList
ArrayList <tipedata> varname = new ArrayList();
CONTOH PROGRAM JAVA ARRAY LIST

import java.util.ArrayList;
public class sd_0300 {
public static void main(String[] args) {
 ArrayList<String> animals = new ArrayList<>();
// Menambahkan elemen di Array List
animals.add("Anjing");
animals.add("Kucing");
animals.add(”Kerbau");
System.out.println("ArrayList: " + animals);
}
}
CONTOH : MENAMPILKAN ELEMEN TERTENTU
import java.util.ArrayList;
class sd_0301 {
public static void main(String[] args) {
ArrayList<String> animals = new ArrayList<>();
// add elements in the arraylist
animals.add(”Anjing");
animals.add(”Kucing");
animals.add(”Kerbau");
System.out.println("ArrayList: " + animals);
// menampilkan indeks tertentu dari arraylist
String str = animals.get(1);
System.out.print("Element di index tsb : " + str);
}
}
CONTOH : MENGGANTIKAN ELEMEN TERTENTU
import java.util.ArrayList;
class sd_0302 {
public static void main(String[] args) {
ArrayList<String> animals = new ArrayList<>();
// add elements in the arraylist
animals.add(”Anjing");
animals.add(”Kucing");
animals.add(”Kerbau");
System.out.println("ArrayList: " + animals);
// Menggantikan elemen indeks tertentu dari arraylist
animals.set(2, ”Kuda");
System.out.println(”Hasil Modifikasi ArrayList: " + animals);
}
}
CONTOH : MENGHAPUS ELEMEN TERTENTU
import java.util.ArrayList;
class sd_0303 {
public static void main(String[] args) {
ArrayList<String> animals = new ArrayList<>();
// add elements in the arraylist
animals.add(”Anjing");
 animals.add(”Kucing");
animals.add(”Kerbau");
System.out.println("ArrayList: " + animals);
// Menghapus element Indeks ke - 2
String str = animals.remove(2);
System.out.println("ArrayList terbaru: " + animals);
System.out.println("Elemen yang dihapus: " + str);
}
}
CONTOH : MENERAPKAN PERULANGAN
import java.util.ArrayList;
class sd_0304 {
public static void main(String[] args) {
ArrayList<String> animals = new ArrayList<>();
// add elements in the arraylist
animals.add(”Anjing");
animals.add(”Kucing");
animals.add(”Kerbau");
System.out.println("ArrayList: " + animals);
// Perulangan Array List
System.out.println("Menampilkan dengan perulangan: ");
for (String language : animals) {
System.out.print(language);
System.out.print(", ");
}
}
}
OPERASI PADA ARRAY LIST

CONTOH 1 : METHOD SIZE

import java.util.ArrayList;
public class sd_0305 {
public static void main(String[] args) {
ArrayList<String> animals = new ArrayList<>();
// Menambahkan elemen di Array List
 animals.add("Anjing");
animals.add("Kucing");
System.out.println(animals.size());
CONTOH 2 : METHOD SIZE
import java.util.ArrayList;
public class sd_0306 {
public static void main(String[] args) {
ArrayList<Integer> primeNumbers = new ArrayList<>();
primeNumbers.add(2);
primeNumbers.add(3);
primeNumbers.add(5);
primeNumbers.add(7);
System.out.println("ArrayList: " + primeNumbers);
// Jumlah elemen pada Arra
int size = primeNumbers.size();
System.out.println("Length of ArrayList: " + size);
}
}
}
CONTOH : METHOD SORT
import java.util.ArrayList;
import java.util.Comparator;
public class sd_0307 {
public static void main(String[] args) {
ArrayList<Integer> numbers = new ArrayList<>();
numbers.add(7);
numbers.add(3);
numbers.add(9);
numbers.add(-33);
System.out.println("Unsorted ArrayList: " + numbers);
// Mengurut ArrayList secara Menaik (Ascending)
numbers.sort(Comparator.naturalOrder());
System.out.println("Sorted ArrayList: " + numbers);
}
}
CONTOH : METHOD CLONE
import java.util.ArrayList;
public class sd_0308 {
public static void main(String[] args) {
ArrayList<Integer> number = new ArrayList<>();
number.add(1);
number.add(3);
number.add(5);
System.out.println("ArrayList: " + number);
// Melakukan Duplikasi ArrayList
 ArrayList<Integer> cloneNumber = (ArrayList<Integer>)number.clone();
System.out.println("Cloned ArrayList: " + cloneNumber);
}
}
CONTOH : METHOD CONTAINS
import java.util.ArrayList;
public class sd_0309 {
public static void main(String[] args) {
ArrayList<String> bhs_prog = new ArrayList<>();
bhs_prog.add("Java");
bhs_prog.add("Python");
bhs_prog.add("JavaScript");
System.out.println("ArrayList: " + bhs_prog );
// Mencari kata Java di Array List
System.out.print("Apaka ada kata Java di arraylist: ");
System.out.println(bhs_prog .contains("Java"));
}
}
CONTOH : METHOD ESURECAPACITY
import java.util.ArrayList;
public class sd_0310 {
public static void main(String[] args) {
ArrayList<String> bhs_prog = new ArrayList<>();
bhs_prog.ensureCapacity(3);
// Tambahkan elemen di Array List
bhs_prog.add("Java");
bhs_prog.add("Python");
bhs_prog.add("C");
// Tambahkan elemen ke empat
bhs_prog.add("Swift");
System.out.println("ArrayList: " + bhs_prog );
}
}
CONTOH : METHOD IS EMPTY
import java.util.ArrayList;
public class sd_0311 {
public static void main(String[] args) {
ArrayList<String> bhs_prog = new ArrayList<>();
System.out.println("Baru Membuat ArrayList: " + bhs_prog);
// Periksa apakah ArrayList memiliki isi elemen
boolean hasil = bhs_prog.isEmpty();
System.out.println("Apakah ArrayList masih kosong? " + hasil);
// Tambahkan elements ke ArrayList
bhs_prog.add("Python");
bhs_prog.add("Java");
 bhs_prog.add("R");
System.out.println("Perbaharui isi ArrayList: " + bhs_prog);
// Periksa apakah ArrayList memiliki isi elemen
hasil = bhs_prog.isEmpty();
System.out.println("Apakah ArrayList masih kosong? " + hasil);
}
}
CONTOH : METHOD IS INDEX OF
import java.util.ArrayList;
public class sd_0308 {
public static void main(String[] args) {
ArrayList<String> bhs_prog = new ArrayList<>();
// Tambahkan elements ke ArrayList
bhs_prog.add("Python");
bhs_prog.add("Java");
bhs_prog.add("R");
System.out.println(”Isi ArrayList: " + bhs_prog);
// Mencari posisi elemen dari kata Java
int posisi = bhs_prog.indexOf("Java");
System.out.println("Index Kata yang dicari adalah: " + posisi);
}
}
TUMPUKAN (STACK)

 Tumpukan (stack) merupakan implementasi dari Struktur Data dengan konsep LIFO (Last In
First Out)

 Tumpukan (Stack) adalah penyimpanan data/item dimana data/item yang diakses adalah
paling akhir yang disebut top of stack.
 Item ditempatkan membentuk tumpukan
 Merupakan penyimpanan data dengan konsep LIFO (Last In First Out)
OPERASI TUMPUKAN (STACK)

 push(item) menambah item pada top of stack,

 pop(item) menghapus elemen dari top of stack
  peek() mengakses nilai top of stack

STATUS TUMPUKAN (STACK)

TUMPUKAN (STACK)- JAVA CLASS/COLLECTION

 Stack interface mendefinisikan kumpulan operasi yang mengakses dan mengupdate hanya
satu data pada akhir list
 Java Class menyimpan Stack Interface
 Stack di Collection dapat diimport dengan menggunakan perintah:
import java.util.*;
atau
import java.util.Stack;
 MEMBUAT TUMPUKAN (STACK)
 Import java.util.Stack
Membuat Stack Interface
 Stack<Type> <<var_stacks>> = new Stack<>();
varstacks : namvariabel tumpukan
// Membuat Stack tipe data Integer
Stack<Integer> stacks = new Stack<>();
// Membuat Stack tipe data String
Stack<String> stacks = new Stack<>();
OPERASI PUSH - TUMPUKAN (STACK)
import java.util.Stack;
public class SD_050 {
public static void main(String[] args) {
Stack<String> buku= new Stack<>();
buku.push("Algoritma");
buku.push("Basis Data");
buku.push("Etika");
buku.push("Kewarganegaraan");
System.out.println("Isi Tumpukan adalah " + buku);
}
}
OPERASI POP - TUMPUKAN (STACK)
import java.util.Stack;
public class SD_0501 {
public static void main(String[] args) {
Stack<String> buku= new Stack<>();
buku.push("Algoritma");
buku.push("Basis Data");
buku.push("Etika");
buku.push("Kewarganegaraan");
System.out.println("Isi Tumpukan adalah " + buku);
String element = buku.pop();
System.out.println("Elemen yang dihapus dari Tumpukan: " + element);
 }
}
OPERASI PEEK - TUMPUKAN (STACK)
import java.util.Stack;
public class SD_0502 {
public static void main(String[] args) {
Stack<String> buku= new Stack<>();
buku.push("Algoritma");
buku.push("Basis Data");
buku.push("Etika");
buku.push("Kewarganegaraan");
System.out.println("Isi Tumpukan adalah " + buku);
String element = buku.peek();
System.out.println("Elemen paling atas dari Tumpukan: " + element);
}
}
OPERASI SEARCH - TUMPUKAN (STACK)
import java.util.Stack;
public class SD_0503 {
public static void main(String[] args) {
Stack<String> buku= new Stack<>();
buku.push("Algoritma");
buku.push("Basis Data");
buku.push("Etika");
buku.push("Kewarganegaraan");
System.out.println("Isi Tumpukan adalah " + buku);
int posisi = buku.search("Basis Data");
System.out.println("Posisi tertentu di Tumpukan: " + posisi);
}
}
OPERASI EMPTY - TUMPUKAN (STACK)
import java.util.Stack;
public class SD_0504 {
public static void main(String[] args) {
Stack<String> buku= new Stack<>();
buku.push("Algoritma");
buku.push("Basis Data");
buku.push("Etika");
buku.push("Kewarganegaraan");
System.out.println("Isi Tumpukan adalah " + buku);
boolean hasil = buku.empty();
System.out.println("Apakah Tumpukan kosong : " + hasil);
}
}
 CONTOH TUMPUKAN (STACK)
import java.util.Stack;
public class SD_0606 {
public static void main(String[] args) {
Stack<Integer> nilai = new Stack<>();
nilai.push(10);
nilai.push(20);
nilai.push(30);
nilai.push(40);
System.out.println("Isi Tumpukan: " + nilai);
nilai.pop();
System.out.println("Data Setelah Operasi POP " + nilai);
nilai.push(50);
nilai.push(60);
nilai.push(70);
System.out.println("Data Setelah Operasi Push " + nilai);
System.out.println("Data Paling Atas :" + nilai.peek());
System.out.println("Posisi Angak 30 dalam Tumpukan " + nilai.search(30));
System.out.println("Tumpukan Kosong ? " +nilai.empty());
}
}
CONTOH TUMPUKAN (STACK)
public class SD_05 {
private int arr[];
private int top;
private int capacity;
SD_05(int size) {
arr = new int[size];
capacity = size;
top = -1;
}
CONTOH TUMPUKAN (STACK)
public void push(int x) {
if (isFull()) {
System.out.println("OverFlow\nProgram Terminated\n");
System.exit(1);
}
System.out.println(”Isikan " + x);
arr[++top] = x;
}
CONTOH TUMPUKAN (STACK)
public int pop() {
if (isEmpty()) {
System.out.println("STACK KOSONG");
System.exit(1);
 }
return arr[top--];
}
public int size() {
return top + 1;
}
CONTOH TUMPUKAN (STACK)
return top == -1;
}
public Boolean isFull() {
return top == capacity - 1;
}
public void printStack() {
for (int i = 0; i <= top; i++) {
System.out.println(arr[i]);
}
}
CONTOH TUMPUKAN (STACK)
public static void main(String[] args) {
SD_06 stack = new SD_06(5);
stack.push(1);
stack.push(2);
stack.push(3);
stack.push(4);
stack.pop();
System.out.println("\nsetelah mengisi stack");
stack.printStack();
}
}
POLISH NOTATION
 Salah satu aplikasi STACK adalah untuk menulis ungkapan dengan menggunakan notasi
tertentu.
 Cara penulisan ungkapan dapat dilakukan dengan menggunakan :
 Notasi INFIX : Operator diletakkan diantara 2 operand
Cth: A+B  dimana A, B sbg operand dan + sbg operator
 Notasi PREFIX ( POLISH ) : Operator diletakkan sebelum 2 operand disajikan
Cth : +AB
 Notasi POSTFIX ( SUFFIX ) :operator diletakkan setelah 2 operand disajikan
Cth : AB+
 Latihan
 Subtitusikanlah operator berikut dengan notasi prefix dan notasi postfix :
 (A + B) x (C –(D ^ E))
 (A x B) – ( C + D ) / ( E x ( F – G ) )
 ALGORITMA KONVERSI INFIX KE POSTFIX

 Langkah 0 ( Awal )
 Baca ungkapan dalam notasi infix, misalnya = S
 Tentukan panjang ungkapan tersebut, misalnya N karakter
 Siapkan sebuah tumpukan kosong dan siapkan derajad masing-masing operator,
misalnya :
 ^ pangkat = bernilai 3
 x , / = bernilai 2
 + , - = bernilai 1
 ) , ( = bernilai 0
 Langkah 1
Dimulai dari I=1 sampai N, kerjakan langkah2 berikut
 R=S[I]
 Test nilai R, jika R adalah :
operand : langsung ditulis
kurung buka : push ke dalam tumpukan
kurung tutup : pop dan tulis semua isi tumpukan sampai ujung tumpukan = ‘(‘. Pop juga
tanda ‘(‘ ini, tapi tidak ditulis.
operator : jika tumpukan kosong, atau derajad R lebih tinggi dibanding derajad ujung
tumpukan, push operator ke dalam tumpukan. Jika tidak, pop ujung tumpukan da tulis, kemudian
ulangi pembandingan R ujung tumpukan. Kemudian R di push.
 Langkah 2
Jika akhir notasi infix telah tercapai, dan tumpukan masih belum kosong, pop semua isi tumpukan
dan tulis hasilnya.
ALGORITMA KONVERSI INFIX KE POSTFIX
1. ( A + B ) x ( C – D )  N = 11 karakter

2. (A + B) * (C – D) ^ E  N = 13 karakter
 Cara Substitusi : Infix Postfix
(AxB)x(C–D) 1. A*B 1. AB*
2. C-D 2. CD-
3. 1*2 3. 12*
4. AB*CD-*
LATIHAN :

1. A + B * C – D ^ E
2. (A * B) – ( C + D ) / ( E * ( F – G ))

ANTRIAN
(QUEUE)

 basic queue operations:

 add (enqueue): Add an element to the back.
 remove (dequeue): Remove the front element.
 peek: Examine the element at the front
 Antrian (Queue) adalah penyimpanan item yang dapat diakses melalui depan (front) hingga
belakang (back) dari antrian.
 Item masuk pada back dan keluar dari front
 FIFO (First In First Out)
QUEUE INTERFACE
  Queue interface mendefinisikan kumpulan operasi yang mengakses dan mengupdate hanya
satu data pada awal list

 Java Class menyimpan Stack Interface

MEMBUAT QUEUE – LINKED LIST

Queue<Integer> q = new LinkedList<Integer>();

q.add(42);
q.add(-3);
q.add(17); // front [42, -3, 17] back
System.out.println(q.remove()); // 42
IMPORTANT: When constructing a queue you must use a new LinkedList object instead of a new
Queue object.

CONTOH ANTRIAN
import java.util.LinkedList;
import java.util.Queue;
public class SD_061 {
public static void main(String[] args) {
Queue<Integer> numbers = new LinkedList<>();
numbers.offer(1);
numbers.offer(2);
numbers.offer(3);
System.out.println("Antrian: " + numbers);
int accessedNumber = numbers.peek();
System.out.println("Isi Antrian: " + accessedNumber);

CONTOH ANTRIAN – LINKED LIST

int removedNumber = numbers.poll();
System.out.println("Elemen yang dihapus: " + removedNumber);
System.out.println("Sisa Elemen Antrian: " + numbers);
}
}

MEMBUAT QUEUE – PRIORITY

Queue<Integer> q = new PriorityQueue<Integer>();

q.add(42);
q.add(-3);
q.add(17); // front [42, -3, 17] back
System.out.println(q.remove()); // 42
IMPORTANT: When constructing a queue you must use a new PriorityQueue object instead of a new
Queue object.

CONTOH ANTRIAN – PRIORITY

import java.util.Queue;
import java.util.PriorityQueue;
public class SD_062 {
public static void main(String[] args) {
Queue<String> queue = new PriorityQueue<>();
queue.add("Andi");
 queue.add("Budi");
queue.add("Cindy");
queue.add("Dono");
System.out.println("Isi Antrian Adalah : " + queue);
System.out.println("Elemen Pertama Antrian : " + queue.peek());

CONTOH ANTRIAN – PRIORITY

System.out.println("Elemen yang dihapus :" + queue.remove());
System.out.println("Elemen Paling Depan setelah penghapusan: " + queue.peek());
System.out.println("Jumlah dalam Antrian : " + queue.size());
System.out.println("Apakah Dono ada dalam antrian: " + queue.contains("Dono"));
// Periksa apakah Antrian Kosong atau tidak
if (queue.isEmpty()) {
System.out.println("Antrian Kosong");
}
else {
System.out.println("Antrian tidak Kosong");
}
}
}

ANTRIAN – LARIK (ARRAY)

ALGORITMA ENQUEUE
if (size of queue is > N) {
print "Error: queue is full"
return
}
rear = rear + 1
queue[rear] = item

ANTRIAN – LARIK (ARRAY)

ALGORITMA DEQUEUE
if (rear == -1 and front == -1) {
print "Error: queue is empty"
return
}
item = queue[front]
front = front + 1
return item

OPERASI ANTRIAN (QUEUE)

 Create()
 IsEmpty()
 IsFull()
 Enqueue ( tambah )
 Dequeue ( ambil )
 Clear()
 Tampil()

IMPLEMENTASI ANTRIAN
public class SD_063 {
int SIZE = 5;
int items[] = new int[SIZE];
int front, rear;
SD_063() {
front = -1;
rear = -1;
}
IMPLEMENTASI ANTRIAN
boolean isFull() {
if (front == 0 && rear == SIZE - 1) {
return true;
}
return false;
 }
boolean isEmpty() {
if (front == -1)
return true;
else
return false;
}
IMPLEMENTASI ANTRIAN
void enQueue(int element) {
if (isFull()) {
System.out.println("Isi Antrian Peuh");
} else {
if (front == -1)
front = 0;
rear++;
items[rear] = element;
System.out.println("Sisipkan " + element);
}
}
IMPLEMENTASI ANTRIAN
int deQueue() {
int element;
if (isEmpty()) {
System.out.println("Isi Antrian Kosong");
return (-1);
} else {
element = items[front];
if (front >= rear) {
front = -1;
rear = -1;
}
IMPLEMENTASI ANTRIAN
else {
front++;
}
System.out.println("Menghapus -> " + element);
return (element);
}
}
IMPLEMENTASI ANTRIAN
void display() {
int i;
if (isEmpty()) {
System.out.println("Antrian Kosong");
} else {
 System.out.println("\nIndek Depan-> " + front);
System.out.println("Items -> ");
for (i = front; i <= rear; i++)
System.out.print(items[i] + " ");
System.out.println("\nIndek Belakang-> " + rear);
}
}
IMPLEMENTASI ANTRIAN
public static void main(String[] args) {
SD_063 q = new SD_063();
// deQueue belum tentu kosong Antrian
q.deQueue();
// Masukkan 5 elemen
q.enQueue(1);
q.enQueue(2);
q.enQueue(3);
q.enQueue(4);
q.enQueue(5);
IMPLEMENTASI ANTRIAN
// Elemen ke-enam tidak bisa masuk, antrian sudah penuh
q.enQueue(6);
q.display();
// deQueue menghapus elemen 1
q.deQueue();
// Hasil Akhir Isi Antrian
q.display();
}
}
 PENGURUTAN (SORT)

 Sorting
 Sorting is a process that organizes a collection of data into either ascending or
descending order.
 Pengurutan : menyusun data agar terurut
 Terurut menaik  ascending
 Terurut menurun  Descending
 Contoh Pengurutan
 Mengurutkan harga dari terendah hingga tertinggi
 Mengurutkan mahasiswa yang paling tinggi hingga paling rendah
 Mengurutkan IPK tertinggi hingga terendah
 Mengurutkan lagu berdasarkan artis, album, playlist, dll

ALGORITMA PENGURUTAN (SORT)

 Algoritma Pengurutan
 Bubble Sort
 Selection Sort
 Insertion Sort
 Merge Sort
  Quick Sort
BUBBLE SORT
 Algoritma Pengurutan
 Aturan pengurutan berdasarkan perbandingan
 Metode paling sederhana dan mudah
 Mengurutkan data dengan membandingkan elemen sekarang dengan elemen
berikutnya lalu dilakukan proses pertukaran
 Algoritma ini menggeser satu persatu elemen
ALGORITMA BUBBLE SORT

PROSES BUBBLE SORT

PROSES BUBBLE SORT

PROSES BUBBLE SORT

PROSES BUBBLE SORT

IMPLEMENTASI BUBBLE SORT

import java.util.Arrays;
public class SD_Bubble {
static void bubbleSort(int array[]) {
int size = array.length;
for (int i = 0; i < size - 1; i++)
for (int j = 0; j < size - i - 1; j++)
if (array[j] > array[j + 1]) {
int temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
IMPLEMENTASI BUBBLE SORT
public static void main(String[] args) {
int[] data = { -2, 45, 0, 11, -9 };
System.out.println("Data Belum Terurut");
System.out.println(Arrays.toString(data));
SD_Bubble.bubbleSort(data);
System.out.println("Data terurut secara Ascending:");
System.out.println(Arrays.toString(data));
}
}
SELECTION SORT
 Algoritma Pengurutan
 Kombinasi Sorting dan Searching
 Metode pengurutan dengan prioritas antrian
 Metode ini membandingkan elemen yang sekarang dengan elemen yang berikutnya
sampai dengan elemen yang terakhir
  Bila ditemukan elemen lain yang lebih kecil dari elemen sekarang dicatat posisinya
dan kemudian ditukarkan, begitulah seterusnya
 Pertukaran data secara fisik dilakukan diakhir perulangan
ALGORITMA SELECTION SORT

PROSES SELECTION SORT

PROSES SELECTION SORT

PROSES SELECTION SORT

PROSES SELECTION SORT

IMPLEMENTASI PENGURUTAN (SORT)
import java.util.Arrays;
class SelectionSort {
void selectionSort(int array[]) {
int size = array.length;
for (int step = 0; step < size - 1; step++) {
int min_idx = step;
for (int i = step + 1; i < size; i++) {
if (array[i] < array[min_idx]) {
min_idx = i;
}
}

IMPLEMENTASI PENGURUTAN (SORT)

int temp = array[step];
array[step] = array[min_idx];
array[min_idx] = temp;
}
}
public static void main(String args[]) {
int[] data = { 20, 12, 10, 15, 2 };
SelectionSort ss = new SelectionSort();
ss.selectionSort(data);
System.out.println(”Data setelah diurutkan: ");
System.out.println(Arrays.toString(data));
}
}
INSERTION SORT
 Insertion Sort merupakan sebuah teknik pengurutan dengan cara membandingkan dan
mengurutkan dua data pertama pada array, kemudian membandingkan data para array
berikutnya apakah sudah berada di tempat semestinya.
 Algorithma insertion sort seperti proses pengurutan kartu yang berada di tangan kita.
 Algoritma ini tidak cocok untuk set data dengan jumlah besar.
ALGORITMA INSERTION SORT

PROSES INSERTION SORT

PROSES INSERTION SORT

PROSES INSERTION SORT

PROSES INSERTION SORT

IMPLEMENTASI INSERTION SORT

import java.util.Arrays;
public class SD_Sort {
void SDSort(int array[]) {
int size = array.length;
for (int step = 1; step < size; step++) {
int key = array[step];
int j = step - 1;
while (j >= 0 && key < array[j]) {
array[j + 1] = array[j];
--j;
}
IMPLEMENTASI INSERTION SORT
array[j + 1] = key;
}
}
public static void main(String[] args) {
int[] data = { 9, 5, 1, 4, 3 };
System.out.println("Data Belum Terurut");
System.out.println(Arrays.toString(data));
 SD_Sort is = new SD_Sort();
is.SDSort(data);
System.out.println("Data terurut secara Ascending: ");
System.out.println(Arrays.toString(data));
}
}
MERGE SORT
 Algoritma Pengurutan
 Untuk kebutuhan pengurutan atas suatu rangkaian data yang tidak memungkinkan
untuk ditampung dalam memori komputer karena jumlahnya yang terlalu besar
 Algoritma pengurutan data merge sort dilakukan dengan menggunakan cara divide
and conquer
 Divide and conquer adalah memecah kemudian menyelesaikan setiap bagian
kemudian menggabungkannya kembali.
ALGORITMA MERGE SORT

ALGORITMA MERGE SORT

void mergesort(DataType theArray[], int first, int last) {
if (first < last) { // more than one item
int mid = (first + last)/2; // index of midpoint
mergesort(theArray, first, mid);
mergesort(theArray, mid+1, last);
// merge the two halves
merge(theArray, first, mid, last);
}
} // end mergesort
CONTOH MERGE SORT
PROSES MERGE SORT
• Extra array for merge operation

PROSES MERGE SORT

DEMO MERGE SORT

• On array = {5, 2, 4, 7, 1, 3, 2, 6}

IMPLEMENTASI MERGE SORT

public class SD_Merge {
void merge(int arr[], int p, int q, int r) {
int n1 = q - p + 1;
int n2 = r - q;
 int L[] = new int[n1];
int M[] = new int[n2];
for (int i = 0; i < n1; i++)
L[i] = arr[p + i];
for (int j = 0; j < n2; j++)
M[j] = arr[q + 1 + j];
IMPLEMENTASI MERGE SORT
int i, j, k;
i = 0; j = 0;
k = p;
while (i < n1 && j < n2) {
if (L[i] <= M[j]) {
arr[k] = L[i];
i++;
} else {
arr[k] = M[j];
j++;
}
IMPLEMENTASI MERGE SORT
k++;
}
while (i < n1) {
arr[k] = L[i];
i++;
k++;
}
while (j < n2) {
arr[k] = M[j];
j++;
k++;
}
}
IMPLEMENTASI MERGE SORT
void mergeSort(int arr[], int l, int r) {
if (l < r) {
int m = (l + r) / 2;
mergeSort(arr, l, m);
mergeSort(arr, m + 1, r);
merge(arr, l, m, r);
}
}
IMPLEMENTASI MERGE SORT
static void printArray(int arr[]) {
int n = arr.length;
for (int i = 0; i < n; ++i)
 System.out.print(arr[i] + " ");
System.out.println();
}
IMPLEMENTASI MERGE SORT
public static void main(String[] args) {
int arr[] = { 6, 5, 12, 10, 9, 1 };
System.out.println("Larik belum terurut");
printArray(arr);
SD_Merge ob = new SD_Merge();
ob.mergeSort(arr, 0, arr.length - 1);
System.out.println("Larik terurut:");
printArray(arr);
}
}
PENCARIAN (SEARCHING)

 Pencarian (searching) merupakan proses menelusuri data pada penyimpanan data.

 Tempat penyimpanan data dalam memory dapat berupa array / linked list
 Beberapa metode pencarian:
 Sequential Search
 Binary Search
 Fibonacci Search
 Interpolation Search
LINEAR/SEQUENTIAL SEARCH

 Pencarian Sekuential adalah proses membandingkan setiap elemen Larik satu persatu secara
beruntun, dari elemen pertama sampai elemen yang dicari ditemukan
 Data yang ada pada suatu array dibandingkan satu persatu dengan data yang dicari
 Pencarian ini hanya melakukan pengulangan dari 1 hingga dengan jumlah data.
 Pada setiap pengulangan, dibandingkan data ke-i dengan yang dicari. Bila sama, data telah
ditemukan. Bila hingga akhir pengulangan, tidak ada yang sama, berarti data tidak
ditemukan

ALGORITMA LINEAR SEARCH

ALGORITMA SEQUENTIAL SEARCH
1. i1
2. Ketemu  False
3. Selama (not ketemu) dan ( i <= N) kerjakan baris 4
4. Jika (Data[i] = x) maka ketemu  true, jika tidak i  i +1
5. IF (ketemu) maka i adalah indeks dari data yang dicari,
6. jika tidak data tidak ditemukan
PROSES SEQUENTIAL SEARCH
Diberikan Larik (Array) A, dengan data yang akan dicari adalah 5?

Iterasi 1
If A[1] == 5?
Hasilnya False
PROSES SEQUENTIAL SEARCH
Iterasi 2
If A[2] == 5 ?
Hasilnya False, maka Data belum ditemukan
Iterasi 3
If A[3] == 5 ?
Hasilnya True, Maka Data ditemukan

PROSES SEQUENTIAL SEARCH

IMPLEMENTASI SEQUENTIAL SEARCH

public class SD_SEARCH {
public static int linearSearch(int[] arr, int element) {
 for (int i = 0; i < arr.length; i++) {
if (arr[i] == element) {
return i;
}
}
return -1;
}
IMPLEMENTASI SEQUENTIAL SEARCH
public static void main(String[] args) {
int[] array = { 10, 20, 30, 50, 70, 90 };
int element = 50;
int index = linearSearch(array, element);
if (index != -1) {
System.out.println(element + " data ditemukan pada indeks ke : " +index);
} else {
System.out.println(element + " data tidak ditemukan");
}
}
}
IMPLEMENTASI SEQUENTIAL SEARCH
import java.util.Scanner;
public class SD_Search01 {
public static void main(String[] args) {
int jum = 0; int k = 0;
int x = 0; int j = 0;
System.out.print("Masukan jumlah elemen array : ");
Scanner s = new Scanner(System.in);
jum = s.nextInt();
int[] array = new int[jum];
System.out.println("Masukan nilai array sebanyak : " +jum);
IMPLEMENTASI SEQUENTIAL SEARCH
for (int i=0; i<jum; i++)
{
array[i] = s.nextInt();
}
System.out.print("Masukan nilai array yang akan di cari : ");
int nilai = s.nextInt();
System.out.print("Nilai dalam array : ");
for (x = 0; x < jum; x++)
{
System.out.print(array[x]);
}
IMPLEMENTASI SEQUENTIAL SEARCH
for (j = 0; j < array.length; j++) {
if (nilai == array[j])
 {
System.out.println(" ");
System.out.println("nilai yang dicari : " +nilai);
System.out.println("ada pada index ke : "+j); k = 1;
}
}
if (k==0){
System.out.println("\nnilai "+nilai+" tidak ada di array");
}
}
}
BINARY SEARCH
 Pencarian sebuah elemen dalam sebuah array satu dimensi dengan cara selalu
membandingkan dengan nilai yang berada di tengah array tersebut
 Apabila tidak sama maka array akan dibagi dua dan pencarian diulang pada bagian dimana
nilai yang dicari
 Salah satu syarat pencarian bagi dua (binary search) adalah data sudah terurut
 Apabila data belum keadaan terurut, pencarian biner tidak dapat dilakukan
 Data yang terurut merupakan syarat mutlak penerapan pencarian bagi dua (binary search)
ALGORITMA BINARY SEARCH

ALGORITMA BINARY SEARCH

1. Input N. Tentukan Lo=0; Hi=N-1; dan Flag=0 (untuk tanda tidak ditemukan yang dicari) 
Mid = (Lo + Hi)/2
2. Selama Lo <= Hi dan Flag==0
 Hitung Mid=(Lo+Hi)/2
 Bila N==A[Mid], isi Flag=1; (tanda ditemukan)
 Bila N<A[Mid], isi Hi=Mid-1, proses pencarian dibagian kiri
 Bila N>A[Mid], isi Hi=Mid+1, proses pencarian dibagian kanan
3. Proses pencarian selesai
INTERPRETASI ALGORITMA
1. Data diambil dari posisi awal 1 dan posisi akhir n
 2. Kemudian cari posisi data tengah dengan rumus: (posisi awal + posisi akhir) / 2
3. Kemudian data yang dicari dibandingkan dengan data yang di tengah, apakah sama atau
lebih kecil, atau lebih besar?
4. Jika data sama, berarti ketemu.
5. Jika lebih besar, maka ulangi langkah 2 dengan posisi awal adalah posisi tengah + 1
6. Jika lebih kecil, maka ulangi langkah 2 dengan posisi akhir adalah posisi tengah – 1
PROSES BINARY SEARCH

CONTOH 1: PROSES BINARY SEARCH

Contoh Data:
Misalnya data yang dicari 23 (X = 23)
Iterasi 1
0 1 2 3 4 5 6 7 8
3 9 11 12 15 17 23 31 35
A B C
Karena 23 > 15 (data tengah), maka: awal = tengah + 1
Iterasi 2
0 1 2 3 4 5 6 7 8
3 9 11 12 15 17 23 31 35
A B C
X = B (sama dengan data tengah). Output = “Data ditemukan”
CONTOH 2: PROSES BINARY SEARCH
Misalnya ingin mencari data 17 pada sekumpulan data berikut :

Mula-mula dicari data tengah, dengan rumus (0 + 9) / 2 = 4.

Berarti data tengah adalah data ke-4 =15.
Data yang dicari yaitu 17, maka dibandingkan dengan data tengah ini --> 15.
Apakah 17>15 ?
Data tengah yang baru didapat dengan rumus (5 + 9) / 2 = 7.
Berarti data tengah yang baru adalah data ke-7, yaitu 23. Data yang dicari yaitu 17 dibandingkan
dengan data tengah ini.
Karena 17 < 23, berarti proses dilanjukkan tetapi kali ini posisi akhir dianggap sama dengan posisi
tengah – 1 atau 6
Data tengah yang baru didapat dengan rumus (5 + 6) / 2 = 5.
Berarti data tengah yang baru adalah data ke-5, yaitu 17.
Data yang dicari dibandingkan dengan data tengah ini dan ternyata sama.
Jadi data ditemukan pada indeks ke-5.
Disini dapat dilihat bahwa posisi awal lebih besar daripada posisi akhir, yang artinya data tidak
ditemukan.

IMPLEMENTASI BINARY SEARCH

public class SD_Binary {
public static int binarySearch(int arr[], int first, int last, int element){
int mid = (first + last)/2;
while( first <= last ){
if ( arr[mid] < element ){
first = mid + 1;
}else if ( arr[mid] == element ){
return mid;
}else{
last = mid - 1;
}
mid = (first + last)/2;
}
return -1;
}
public static void main(String[] args) {
int[] array = { 10, 20, 30, 40, 50, 60 };
int element = 50;
int last=array.length-1;
int index = binarySearch(array,0,last,element);
if (index != -1) {
System.out.println(element + " data ditemukan pada indeks ke :" + index);
} else {
System.out.println(element + " data tidak ditemukan");
}
}
}
FIBONACCI SEARCH
  Merupakan pencarian sebuah elemen dalam sebuah array satu dimensi dengan
menggunakan angka fibonacci sebagai titik (index) elemen array yang isinya dibandingkan
dengan nilai yang dicari (misal N)
 Salah satu syarat pencarian fibonacci adalah data sudah dalam keadaan terurut
 Prosesnya hanya menggunakan operasi tambah dan kurang yang memerlukan waktu yang
lebih cepat dibandingkan dengan proses pembagian yang digunakan pada binary search
ALGORITMA FIBONACCI SEARCH

PROSES FIBONACCI SEARCH

IMPLEMENTASI FIBONACCI SEARCH

public class SD_Fibonacci {
static int min(int a, int b) {
return (a > b) ? b : a;
}
static int fibonacci_search(int arr[], int n, int key) {
int offset = -1; int Fm2 = 0;
 int Fm1 = 1;
int Fm = Fm2 + Fm1;
while (Fm < n) {
Fm2 = Fm1;
Fm1 = Fm;
Fm = Fm2 + Fm1;
}
while (Fm > 1) {
int i = min(offset + Fm2, n - 1);
if (arr[i] < key) {
Fm = Fm1;
Fm1 = Fm2;
Fm2 = Fm - Fm1;
offset = i;
} else if (arr[i] > key) {
Fm = Fm2;
Fm1 = Fm1 - Fm2;
Fm2 = Fm - Fm1;
} else
return i;
}
if (Fm1 == 1 && arr[offset + 1] == key)
return offset + 1;
return -1;
}
public static void main(String[] args) {
int i, n, key;
int arr[] = {6, 11, 19, 24, 33, 54, 67, 81, 94, 99};
n = 10;
key = 67;
int pos = fibonacci_search(arr, n, key);
if(pos >= 0)
System.out.print("Elemen ditemukan di index " + pos);
else
System.out.print("Data tidak ditemukan");
}

}
INTERPOLATION SEARCH
 Merupakan pencarian sebuah elemen dalam sebuah array satu dimensi dengan
menggunakan rumus interpolasi atau perkiraan secara interpolasi
 Berlaku rumus interpolasi adalah
 b/a = q/p
IMPLEMENTASI INTERPOLATION SEARCH
import java.util.Arrays;
public class SD_Interpolation {
public static void main(String[] args) {
int[] sourceArray {1,2,3,4,6,7,9,11,12,14,15,16,17,19,33,34,43,45,55,66,76,88};
System.out.println("Data Larik: "+Arrays.toString(sourceArray));
printline(50);
int location = find(sourceArray, 55);
if(location != -1){
System.out.println("Elemen di indeks "+(location+1));
}else {
System.out.println("Element tidak ditemukan");
}
}
IMPLEMENTASI INTERPOLATION SEARCH
public static int find(int[] intArray, int data){
int lowerBound = 0;
int upperBound = intArray.length -1;
int midPoint = -1;
int comparisons = 0;
int index = -1;
while(lowerBound <= upperBound){
System.out.println("Comparison " + (comparisons +1) ) ;
System.out.println("lowerBound : "+lowerBound
+ " , intArray[" + lowerBound+"] = "
+ intArray[lowerBound]) ;
IMPLEMENTASI INTERPOLATION SEARCH
System.out.println("upperBound : "+upperBound + " , intArray[" + upperBound+"] = " +
intArray[upperBound]) ;
comparisons++;
midPoint = lowerBound +
Math.round((float)(upperBound - lowerBound)
/ (intArray[upperBound] - intArray[lowerBound])
* (data - intArray[lowerBound]));
 System.out.println("midPoint = "+midPoint);
// data found
if(intArray[midPoint] == data){
index = midPoint;
break;
}
else {
if(intArray[midPoint] < data){
lowerBound = midPoint + 1;
}
else{
upperBound = midPoint -1;
}
}
}
System.out.println("Total comparisons : " + comparisons);
return index;
}
public static void printline(int count){
for(int i=0;i <count-1;i++){
System.out.print("=");
}
System.out.println("=");
}
}