Praktikum Searching)

5/12/2018 Praktikum Searching) - slidepdf.com

http://slidepdf.com/reader/full/praktikum-searching 1/14

PRAKTIKUM ALGORITMA DAN STRUKTUR DATA

MODUL KE-6

ALGORITMAPENCARIAN DAN PENGURUTAN

LABORATORIUM PEMROGRAMAN

PROGRAM STUDI TEKNIK INFORMATIKA

FAKULTAS TEKNIK

UNIVERSITAS MUHAMMADIYAH MALANG

2011



I. TUJUANMahasiswa mampu :

1. Memahami algoritma pencarian (linear search dan binary search)

2. Menerapkan algoritma pencarian kedalam pemrograman3. Memahami algoritma pengurutan (insertion sort, selection sort, bubble sort, merge sort)

4. Menerapkan algoritma pengurutan kedalam pemrograman

II. ALAT YANG DIGUNAKANPeralatan yang digunakan :

1. Perangkat PC yang terinstall Java

2. Editor Java

III. DASAR TEORIBeberapa metode pengurutan data dalam java :

1. Buble short

Merupakan salah satu dari banyak teknik pengurutan (sort) yang paling sering dan paling

sederhana. Seperti namanya, bubble yang berarti gelembung, teknik ini diibaratkan

seperti gelembung. Ia menggeser nilai terkecil atau terbesar (tergantung jenisnya,

ascending atau descending) ke ujung. Algoritma Bubble Sort ini cukup simpel, semisal

pengurutan secara ascending (kecil ke besar)

ia membandingkan nilai petama dengan nilai kedua, apabila nilai pertama lebih kecil berarti tidak ada perubahan. Namun apabila nilai kedua lebih kecil daripada nilai

pertama, maka nilai kedua pindah ke nilai pertama dan nilai pertama pindah ke urutan

kedua. Setelah melakukan pengecekan, berlanjut ke pengecekan nilai kedua dan ketiga

dengan cara yang sama dengan diatas, begitu seterusnya…

Dibawah ini ilustrasinya..

2. Insertio Short

Salah satu algoritma sorting yang paling sederhana adalah insertion sort . Ide

dari algoritma ini dapat dianalogikan seperti mengurutkan kartu. Penjelasan berikut ini

menerangkan bagaimana algoritma insertion sort bekerja dalam pengurutan kartu.



Anggaplah anda ingin mengurutkan satu set kartu dari kartu yang bernilai paling kecil

hingga yang paling besar. Seluruh kartu diletakkan pada meja, sebutlah meja ini sebagai

meja pertama, disusun dari kiri ke kanan dan atas ke bawah. Kemudian kita mempunyai

meja yang lain, meja kedua, dimana kartu yang diurutkan akan diletakkan. Ambil

kartu pertama yang terletak pada pojok kiri atas meja pertama dan letakkan pada meja

kedua. Ambil kartu kedua dari meja pertama, bandingkan dengan kartu yang berada

pada meja kedua, kemudian letakkan pada urutan yang sesuai setelah perbandingan.

Proses tersebut akan berlangsung hingga seluruh kartu pada meja pertama telah

diletakkan berurutan pada meja kedua.

Algoritma insertion sort pada dasarnya memilah data yang akan diurutkan

menjadi dua bagian, yang belum diurutkan (meja pertama) dan yang sudah diurutkan

(meja kedua). Elemen pertama diambil dari bagian array yang belum diurutkandan kemudian diletakkan sesuai posisinya pada bagian lain dari array yang telah

diurutkan. Langkah ini dilakukan secara berulang hingga tidak ada lagi elemen yang

tersisa pada bagian array yang belum diurutkan.

3. Selection short

Jika anda diminta untuk membuat algoritma sorting tersendiri, anda mungkin akan

menemukan sebuah algoritma yang mirip dengan selection sort. Layaknya insertion

sort, algoritma ini sangat rapat dan mudah untuk diimplementasikan.

Mari kita kembali menelusuri bagaimana algoritma ini berfungsi terhadap satu

paket kartu. Asumsikan bahwa kartu tersebut akan diurutkan secara ascending.

Pada awalnya, kartu tersebut akan disusun secara linier pada sebuah meja dari kiri ke

kanan, dan dari atas ke bawah. Pilih nilai kartu yang paling rendah, kemudian

tukarkan posisi kartu ini dengan kartu yang terletak pada pojok kiri atas meja. Lalu cari

kartu dengan nilai paling rendah diantara sisa kartu yang tersedia. Tukarkan kartu yang

baru saja terpilih dengan kartu pada posisi kedua. Ulangi langkah – langkah tersebut

hingga posisi kedua sebelum posisi terakhir dibandingkan dan dapat digeser dengan

kartu yang bernilai lebih rendah.

Ide utama dari algoritma selection sort adalah memilih elemen dengan nilai

paling rendah dan menukar elemen yang terpilih dengan elemen ke-i. Nilai dari i

dimulai dari 1 ke n, dimana n adalah jumlah total elemen dikurangi 1.

4. Merger Short

Prinsip utama yang diimplementasikan pada algoritma merge-sort seringkali disebut

sebagai pecah-belah dan taklukkan ( bahasa Inggris: divide and conquer ). Cara kerja

http://id.wikipedia.org/wiki/Bahasa_Inggris

http://id.wikipedia.org/wiki/Bahasa_Inggris



algoritma merge sort adalah membagi larik data yang diberikan menjadi dua bagian

yang lebih kecil. Kedua larik yang baru tersebut kemudian akan diurutkan secara

terpisah. Setelah kedua buah list tersusun, maka akan dibentuk larik baru sebagai hasil

penggabungan dari dua buah larik sebelumnya. Menurut keefektifannya, alogaritma ini

bekerja dengan tingkat keefektifan O(nlog(n)). Dalam bentuk pseudocode sederhana

algoritma ini dapat dijabarkan sebagai berikut:

public static void mergesort(int[ ] data, int first, int n){

int n1;

int n2;

if (n > 1) {

n1 = n / 2;

n2 = n - n1;

mergesort(data, first, n1);

mergesort(data, first + n1, n2);

merge(data, first, n1, n2);

}}

private static void merge(int[ ] data, int first, int n1, int n2) {

int[ ] temp = new int[n1+n2];

int copied = 0;

int copied1 = 0;

int copied2 = 0;

int i;

while ((copied1 < n1) && (copied2 < n2)){

if (data[first + copied1] < data[first + n1 + copied2])

temp[copied++] = data[first + (copied1++)];

else

temp[copied++] = data[first + n1 + (copied2++)];}

while (copied1 < n1)



temp[copied++] = data[first + n1 + (copied2++)];

for (i = 0; i < n1+n2; i++)

data[first + i] = temp[i];

}

IV. PROSEDUR PELAKSANAANProsedur pelaksanaan praktikum adalah sebagai berikut :

1. Mahasiswa mencoba latihan yang ada pada modul praktikum

2. Mahasiswa menganalisa hasil dari program pada latihan yang telah dijalankan

3. Mahasiswa mengerjakan tugas yang diberikan

4. Mahasiswa mendemonstrasikan program yang telah dikerjakan pada dosen/assisten

5. Mahasiswa membuat laporan dari tugas yang telah dikerjakan

6. Upload laporan melalui e-labit.umm.ac.id

http://id.wikipedia.org/wiki/Larik

http://id.wikipedia.org/wiki/Notasi_O_besar

http://id.wikipedia.org/wiki/Pseudocode

http://id.wikipedia.org/wiki/Larik

http://id.wikipedia.org/wiki/Notasi_O_besar

http://id.wikipedia.org/wiki/Pseudocode



V. LATIHAN

ALGORITMA PENCARIAN

1. Linear atau Sequential Search

import java.util.Arrays;import java.util.Scanner;import static java.lang.Math.*;

public class SequentialSearch{

public static void main(String args[]){

Scanner sc = new Scanner(System.in);int j, k, number, size;boolean found = false;System.out.print("Enter the array size: ");

size = sc.nextInt();int[] intArray = new int[size];for (j=0; j<size; j++)

intArray[j] = (int) (random()*100);System.out.println(" " + size + " element int array of random ints between 0 and 99 has

been loaded.");System.out.println("The random array for verification is:\n\n");System.out.println(Arrays.toString(intArray));System.out.println("\nGuess one of the numbers: ");number = sc.nextInt();//// linear search algorithmk=0;while (!found && k<size)

if (intArray[k]==number)

found=true;elsek +=1;

System.out.println();

if (found)System.out.println("Found in position " + k);

elseSystem.out.println("The number is not found");

/////////////////////////

}}

2. Binary Search

class OrdArray{private long[] a; // ref to array aprivate int nElems; // number of data items//-----------------------------------------------------------public OrdArray(int max) // constructor{a = new long[max]; // create arraynElems = 0;}//-----------------------------------------------------------

public int size(){ return nElems; }//-----------------------------------------------------------public int find(long searchKey){



int lowerBound = 0;int upperBound = nElems-1;int curIn;while(true){curIn = (lowerBound + upperBound ) / 2;if(a[curIn]==searchKey)return curIn; // found it

else if(lowerBound > upperBound)return nElems; // can’t find itelse // divide range{if(a[curIn] < searchKey)lowerBound = curIn + 1; // it’s in upper half elseupperBound = curIn - 1; // it’s in lower half } // end else divide range} // end while} // end find()//-----------------------------------------------------------public void insert(long value) // put element into array{

int j;for(j=0; j<nElems; j++) // find where it goesif(a[j] > value) // (linear search)break;for(int k=nElems; k>j; k--) // move bigger ones upa[k] = a[k-1];a[j] = value; // insert itnElems++; // increment size} // end insert()//-----------------------------------------------------------public boolean delete(long value){int j = find(value);if(j==nElems) // can’t find it

return false;else // found it{for(int k=j; k<nElems; k++) // move bigger ones downa[k] = a[k+1];nElems--; // decrement sizereturn true;}} // end delete()//-----------------------------------------------------------public void display() // displays array contents{for(int j=0; j<nElems; j++) // for each element,System.out.print(a[j] + " "); // display it

System.out.println("");}//-----------------------------------------------------------} // end class OrdArray///////////////////////////////////////////////////////////////class OrderedApp{public static void main(String[] args){int maxSize = 100; // array sizeOrdArray arr; // reference to arrayarr = new OrdArray(maxSize); // create the arrayarr.insert(77); // insert 10 itemsarr.insert(99);arr.insert(44);arr.insert(55);arr.insert(22);arr.insert(88);arr.insert(11);



arr.insert(00);arr.insert(66);arr.insert(33);arr.display(); // display itemsint searchKey = 99; // search for itemSystem.out.println("Search key " + searchKey);if( arr.find(searchKey) != arr.size() )System.out.println("Found " + searchKey);

elseSystem.out.println("Can’t find " + searchKey);} // end main()} // end class OrderedApp

ALGORITMA PENGURUTAN

3. Contoh class untuk algoritma pengurutan selection sort

public class selectionSort {

static int X[]={7,3,4,1,8,2,6,5};sttaic void selectionSort(){

int i,min,j,t;int n = X.length;

for (i=0; i < n; i++) {

min = i;for (j = i+1; j < n; j++) {

if (X[min] > X[j]){min = j;

}}if(min!=i){

t = X[min];X[min] = X[i];X[i] = t;}

}}

public static void main(String[] args){

cetak();System.out.println();selectionSort();cetak();System.out.println();

}}

4. Contoh method untuk algoritma pengurutan Insertion Sort

void insertionSort(){

int i=1,t,j;int n= X.length;for(i=1;i<n;i++){

t=X[i];for (j =i-1; j >= 0; j--) {

if (t < X[j]){

X[j+1] = X[j];X[j]=t;}else {



X[j+1] = t;break;

}}

}}

5. Contoh method untuk algoritma pengurutan Bubble Sort

void bubbleSort(){

boolean status = true;int i,j,tmp;int n = X.length;

for (i=0; i < n-1 && status; i++){status = false;for (j=n-1; j > i; j--) {

if (X[j] < X[j-1]) {tmp = X[j];X[j] = X[j-1];

X[j-1] = tmp;status = true;

}}

}}

6. Contoh method untuk algoritma pengurutan Merge Sort

void mergeSort(int l,int r){

if(l==r) return;

else{int mid = (l+r)/2;

mergeSort(l, mid);mergeSort(mid+1,r);Merging(l,mid+1,r);

}}

static void Merging(int kiri,int tengah, int kanan){

int j=0;

int batasBawah = kiri;int mid = tengah-1;

int n=kanan-batasBawah+1;int tampung[] = new int[X.length];

while(kiri <=mid && tengah <= kanan){

if(X[kiri] < X[tengah])tampung[j++]=X[kiri++];

elsetampung[j++]=X[tengah++];

}

while(kiri<=mid){tampung[j++]=X[kiri++];

}

while(tengah<=kanan){tampung[j++]=X[tengah++];

}



for(int i=0;i<n;i++){

X[batasBawah+i]=tampung[i];}

}

VI. TUGAS PRAKTIKUM

1. (1 orang) Gabungkan ke-4 algoritma pengurutan diatas. Buatlah menu yang memberikan

pilihan kepada user jenis pengurutan dan algoritma yang dikehendaki. Deret bilangan

yang akan diurutkan didapat dari input user.

Contoh tampilan :

Jumlah data yang dikehendaki : 5

Masukkan data 1 : 5

Masukkan data 2 : 8

Masukkan data 3 : 2

Masukkan data 4 : 9

Masukkan data 5 : 1

Algoritma pengurutan:

1. bubble

2. selection

3. insertion

4. merge

Masukkan pilihan algoritma : 2

Metode pengurutan :

1. ascending

2. descending

Masukka pilihan : 2

Hasil pengurutan : 9 8 5 2 1

2. (2 orang) Modifikasi contoh program yang ada pada latihan. Buatlah program yang

dapat mengurutkan sejumlah data berupa karakter. Anda dapat mengambil salah satu

algoritma pengurutan yang paling anda kuasai.

Contoh :

Data : d r g a z y m

Hasil pengurutan :

Ascending : a d g m r y z



Descending : z y r m g d a

*2 orang masing-masing mengerjakan untuk algoritma yang berbeda.

3. (2 orang) Gabungkan seluruh algoritma pengurutan diatas. Bangkitkan bilangan secara

acak dengan jumlah bilangan yang dibangkitkan berturut-turut adalah : 100, 1000,

10000, 100000, 1000000. Lakukan pengurutan secara ascending. Kemudian lakukan

analisa terhadap running time (T(n)) untuk jumlah perbandingan dari tiap algoritma.

Analisa hasilnya dan berikan kesimpulan algoritma mana yang paling kecil jumlah

perbandingannya!

Untuk menganalisa hasil percobaan diatas lengkapi tabel berikut :

Percobaan Algoritma Jumlah Data (n)Banyak

perbandinganSelection Sort 10 45

Insertion Sort 21

Bubble Sort 42

Merge Sort 23

1 Selection Sort 100 ….

Insertion Sort …..

Bubble Sort …..

Merge Sort .......



Bubble Sort …..

Merge Sort .......



Bubble Sort …..

Merge Sort .......



Bubble Sort …..

Merge Sort .......

5 Selection Sort 1000000 ….Insertion Sort …..

Bubble Sort …..

Merge Sort .......

VII. HASIL PRAKTIKUMJawaban soal no. 1 package Prkatikum6;

import java.util.*;

public class soal1 {

static int[] data ;



public soal1(int max){

data = new int[max];

}

void print(){

for (int i=0;i<data.length;i++){

System.out.print(" " + data[i]);

}

}

public static void mergesort(int[ ] data, int first, int n){

int n1;

int n2;

if (n > 1) {

n1 = n / 2;

n2 = n - n1;

mergesort(data, first, n1);

mergesort(data, first + n1, n2);

merge(data, first, n1, n2);

}}

private static void merge(int[ ] data, int first, int n1, int n2) {

int[ ] temp = new int[n1+n2];

int copied = 0;

int copied1 = 0;

int copied2 = 0;

int i;

while ((copied1 < n1) && (copied2 < n2)){

if (data[first + copied1] < data[first + n1 + copied2])


elsetemp[copied++] = data[first + n1 + (copied2++)];

}




temp[copied++] = data[first + n1 + (copied2++)];

for (i = 0; i < n1+n2; i++)

data[first + i] = temp[i];

}

void insertionSort(){

int i=1,t,j;

int n= data.length;

for(i=1;i<n;i++){

t=data[i];

for (j =i-1; j >= 0; j--) {

if (t < data[j]){

data[j+1] = data[j];

data[j]=t;

}

else {

data[j+1] = t;

break;

}



}

}

}

void bubbleSort(){

boolean status = true;

int i,j,tmp;

int n = data.length;

for (i=0; i < n-1 && status; i++){

status = false;

for (j=n-1; j > i; j--) {

if (data[j] < data[j-1]) {

tmp = data[j];

data[j] = data[j-1];

data[j-1] = tmp;

status = true;

}

}

}}

void des(){

boolean status = true;

int i,j,tmp;


for (i=0; i < n-1 && status; i++){

status = false;

for (j=n-1; j > i; j--) {

if (data[j] > data[j-1]) {

tmp = data[j];

data[j] = data[j-1];

data[j-1] = tmp;status = true;

}

}

}

}

void selectionSort(){

int i,min,j,t;


for (i=0; i < n; i++) {

min = i;for (j = i+1; j < n; j++) {

if (data[min] > data[j]){

min = j;

}

}

if(min!=i){

t = data[min];

data[min] = data[i];

data[i] = t;

}

}

}

public static void main(String[] args){



Scanner scan = new Scanner(System.in);

int pl3;

System.out.println("Program Pengurutan Data");

System.out.println("========================\n");

System.out.print("masukkan jumlah data yang ingin diurutkan!");

int jmldata = scan.nextInt();

soal1 x = new soal1(jmldata);

for (int i=0;i<jmldata;i++){

System.out.print("Masukkan data ke "+(i+1)+" : "); data[i]=scan.nextInt();

}

do{

System.out.println("\nData yang telah di masukkan!");

x.print();

System.out.print("\n\n");

//Algoritma pengurutan

System.out.println("Algoritam Pengurutan :");

System.out.println("1. Buble");

System.out.println("2. Selection");

System.out.println("3. Insection");

System.out.println("4. Merge");

System.out.print("Masukkan pilihan : ");int pl1 =scan.nextInt();

if (pl1==1){

x.bubbleSort();

x.print();

}else if(pl1==2){

x.selectionSort();x.print();

}else if(pl1==3){

x.insertionSort();

x.print();

}else if(pl1==4){

x.mergesort(data,0,data.length);

x.print();

}else{

System.out.println("Pilihan tidak ada!");

}

//Metode pengurutanSystem.out.println("\n\n");

System.out.println("Metode Pengurutan :");

System.out.println("1. Ascending");

System.out.println("2. Descending");

System.out.print("Masukkan pilihan : ");int pl2 =scan.nextInt();

if (pl2==1){

x.bubbleSort();

}else if(pl2==2){

x.des();

x.print();

System.out.println("\n");

}else{

System.out.println("Pilihan tidak ada!");

}



System.out.println("Ingin menjalan program kembali 1 = Y dan 0 = N : ");pl3=scan.nextInt();

}while(pl3!=0);

}

}

Screanshort soal 1

VIII. Kesimpulan

Modul 6 praktikum ini adalah modul yang terahkir dalam praktek matakuliah

ASD, menerangkan berberapa metode pengurutan data yang diantanyaranya adalah

buble short, selection short, insection short dan merger short. Semua dari metode ini

sama yaitu mengurutkan data entah data itu string,chat, atau integer, tetapi penerapan

yang lebih mendalam adalah untuk menyelesaikan masalah berdasarkan jumlah datanya,

tentu hal ini akan teruji efisiensi dari masing-masing metode. Selain hal tersebut di

dalam metode terdapat metode pengurutan data dari terkecil ke data yang terbesar yaitu

atau sering disebut ascending dan sebaliknya descending .

Praktikum Searching)

Documents

Transcript of Praktikum Searching)