P. 1
Modul 02b Insertion Sort Dan Per Banding An Berbagai Metode Sort

Modul 02b Insertion Sort Dan Per Banding An Berbagai Metode Sort

|Views: 33|Likes:
Published by Vita Gustra

More info:

Published by: Vita Gustra on May 29, 2012
Copyright:Attribution Non-commercial

Availability:

Read on Scribd mobile: iPhone, iPad and Android.
download as PDF, TXT or read online from Scribd
See more
See less

05/29/2012

pdf

text

original

ALGORITMA DAN PEMROGRAMAN 2

Modul 10 Oleh: Anis Cherid, M.T.I
PENGURUTAN SISIP (INSERTION SORT) Dibanding metode pengurutan gelembung (bubble sort) dan pengurutan pilih (selection sort), pengurutan sisip merupakan teknik pengurutan yang paling mirip dengan teknik yang pada umumnya dipergunakan oleh manusia ketika mengurutkan sekumpulan data. Karena itu, algoritma pengurutan sisip lebih mudah kita pahami. Namun demikian, untuk mengimplementasikan pengurutan sisip ke dalam sebuah program, kita harus menggunakan algoritma yang lebih rumit dibanding pengurutan gelembung maupun pengurutan pilih. Jika kita memiliki 6 buah kartu yang masing-masing bernilai 15, 16, 01, 04, 12 dan 11, maka proses pengurutan yang kita lakukan adalah sebagai berikut: Kondisi awal: Kartu terurut dimulai dari 15 Langkah 1: Kartu berikut 16, kartu terurut terdiri dari 15, 16 Langkah 2: Kartu berikut 01, kartu terurut terdiri dari 01, 15, 16 Langkah 3: Kartu berikut 04, kartu terurut terdiri dari 01, 04, 15, 16 Langkah 4: Kartu berikut 12, kartu terurut terdiri dari 01, 04, 12, 15, 16 Langkah 5: Kartu berikut 11, kartu terurut terdiri dari 01, 04, 11, 12, 15, 16. Implementasi algorima pengurutan sisip (menaik) di atas, pada dasarnya dilakukan dengan menyisipkan sebuah data baru ke dalam bagian array yang sudah terurut. Lokasi penyisipan yang tepat dilakukan dengan menelusuri satu persatu elemen dalam array yang sudah terurut, dimulai dari elemen yang datanya terbesar dan diakhiri pada elemen 1. Selama proses pencarian posisi yang tepat dilakukan, masing-masing dari data dalam elemen array yang sudah terurut digeser 1 elemen ke sebelah kanan. Misalnya terdapat array yang terdiri dari 6 elemen, maka proses pengurutan sisip dapat diilustrasikan sebagai berikut:
Array yang tidak terurut: 15 16 01 04 12 11 Pass 1: mencari posisi sisip untuk 16 (nilai elemen 2). Posisi sisip : 2: dibanding 1 (16 > 15) >>> posisi 2 benar. Elemen 2 = Nilai. 15 16 01 04 12 11 Pass 2: mencari posisi sisip untuk 01 (nilai elemen 3). Posisi sisip : 3: dibanding 2 (01 < 16) >>> posisi 3 salah, geser elemen 2. 15 -- 16* 04 12 11 2: dibanding 1 (01 < 15) >>> posisi 2 salah, geser elemen 1. -- 15* 16 04 12 11 1: Elemen terurut sudah diperiksa semua. Elemen 1 = Nilai.

1

geser elemen 3 posisi 3 salah. posisiBenar=0.pass++){ posisiSisip = pass. geser elemen 3 posisi 3 benar.pass<N. int N){ int pass.15* 16 12 11 2: dibanding 1 (04 > 01) >>> 01 04* 15 16 12 11 Pass 4: mencari posisi sisip Posisi sisip: 5: dibanding 4 (12 < 16) >>> 01 04 15 -. posisi 5 salah. /* cari posisi sisip yang benar sambil menggeser */ while (posisiSisip > 0 && !posisiBenar){ if (nilai < L[posisiSisip-1]){ L[posisiSisip] = L[posisiSisip-1]. geser elemen 3 posisi 3 benar. Elemen 2 = Nilai. /*geser elemen*/ --posisiSisip. Pass 3: mencari posisi sisip Posisi sisip : 4: dibanding 3 (04 < 16) >>> 01 15 -. nilai = L[posisiSisip]. } else { posisiBenar = 1. untuk 12 (nilai elemen 5). geser elemen 4 posisi 4 salah. geser elemen 2 posisi 2 benar. Elemen 3 = Nilai. geser elemen 4 posisi 4 salah.16* 5: dibanding 4 (11 < 15) >>> 01 04 12 -. } } /* posisiSisip=0 or posisiBenar */ L[posisiSisip] = nilai. posisiSisip.12* 15 16 3: dibanding 2 (11 > 04) >>> 01 04 11* 12 15 16 Di bawah ini disajikan fungsi yang mengimplementasikan algoritma pengurutan pilih yang memiliki 2 buah parameter.15* 16 11 3: dibanding 2 (12 > 15) >>> 01 04 12* 15 16 11 Pass 5: mencari posisi sisip Posisi sisip: 6: dibanding 5 (11 < 16) >>> 01 04 12 15 -. geser elemen 5 posisi 5 salah. untuk 11 (nilai elemen 6). Elemen 3 = Nilai. /* elemen L[0] dianggap sudah terurut*/ for (pass = 1. } } 2 .16* 11 4: dibanding 3 (12 < 15) >>> 01 04 -. nilai. posisi 6 salah.15* 16 4: dibanding 3 (11 < 12) >>> 01 04 -.16* 12 11 3: dibanding 2 (04 < 15) >>> 01 -.01* 15 16 04 12 11 untuk 04 (nilai elemen 4). posisi 4 salah. posisiBenar = 0. yaitu array yang akan diurutkan dan jumlah elemen array yang akan diurutkan [RIN01]: void insertionSort (int L[].

if (N==0){ break. } while (1). int). } void periksaLayar(int *jumlahBaris){ ++(*jumlahBaris).i<N.i++){ if (elemenKosong!=-1 && elemenKosong==i){ printf("--"). " "atau 0 untuk keluar): ").. } while ((N<2 || N>MAX) && N!=0)..h> #include <conio. } } printf("\n").h> #include <stdlib."). int). if(*jumlahBaris>22){ printf(">>>>>>>>>Tekan ENTER untuk melanjutkan. insertionSort(int [].h> #include <time. insertionSort(arrPenampung.arrPenampung[MAX]. scanf("%d". disajikan di bawah ini: #include <stdio.h> #define MAX 17 void void void void tampilkanArray(int [].Program yang lebih lengkap untuk menyajikan kondisi array pada masing-masing posisi penyisipan. int N. int. } if(elemenBintang!=-1 && elemenBintang==i){ printf("* "). clrscr(). int. for (i=0. periksaLayar(int *). getch(). do{ do { printf("Berapa jumlah elemen yang " "akan diurutkan (2 s/d 17. printf("Tekan sembarang kunci untuk " "mengurutkan array yang berbeda. } else { printf(" ").L[i]). } void tampilkanArray(int L[]. resetArray(int []. void main(){ int N=0. } else { printf("%02d". } resetArray(arrPenampung. int elemenBintang){ int i.&N). N).. int elemenKosong.. int). N)."). 3 .

if (!posisiBenar){ tampilkanArray(L. } } /*posisiSisip=0 or posisiBenar*/ L[posisiSisip] = nilai. printf("elemen %d = Nilai". while (posisiSisip > 0 && !posisiBenar){ printf("%2d: dibanding %2d (%02d %c %02d) >>> " "posisi %d %s. /* elemen L[0] dianggap sudah terurut */ for (pass=1. printf ("Array yang tidak terurut:\n").\n". nilai. periksaLayar(&lineCounter). N. 4 . posisiBenar=0. tampilkanArray (L. L[posisiSisip-1]. printf("Pass %d: mencari posisi sisip untuk %02d" " (nilai elemen %d). periksaLayar(&lineCounter). pass.posisiSisip+1). periksaLayar(&lineCounter). /*geser elemen*/ --posisiSisip. printf("\n").posisiSisip+1). } else { posisiBenar = 1. printf("\n").getch().pass++){ nilai = L[pass].pass+1). int N){ int i. N.i<N. " "Elemen 1 = Nilai\n "). periksaLayar(&lineCounter).nilai. ".posisiSisip+1.i++){ L[i]=random(99)+1. printf(" ").pass<N. posisiSisip+1). } } void resetArray(int L[]. lineCounter. (nilai<L[posisiSisip-1]? "salah":"benar")).nilai. posisiSisip+1. posisiSisip. } } void insertionSort(int L[]. posisiSisip. if (posisiSisip==0){ printf(" 1: Elemen terurut sudah diperiksa semua. printf("geser elemen %d". for (i=0. int N){ int pass.posisiSisip. } printf("\n "). posisiBenar = 0. *jumlahBaris=1. periksaLayar(&lineCounter). /* cari posisi sisip yang benar sambil menggeser */ printf("Posisi sisip:\n"). posisiSisip = pass. -1). (nilai<L[posisiSisip-1]?'<':'>'). -1. randomize(). lineCounter = 4. if (nilai < L[posisiSisip-1]){ L[posisiSisip] = L[posisiSisip-1].

posisiBenar := false. nilai := pL^[posisiSisip]. } if (posisiSisip != pass){ tampilkanArray(L. -1. {elemen pL^[1] dianggap sudah terurut} for pass := 2 to N do begin posisiSisip := pass. procedure insertionSort (var L : TArray. posisiSisip). N. dipergunakan adalah sebagai berikut: program pembandingan_algoritma_sorting. yaitu bubble-sort. Sedangkan algoritma insertion-sort adalah yang paling mirip dengan cara yang digunakan oleh manusia untuk mengurutkan sekumpulan nilai tertentu. -1). Dari ketiga algoritma ini.winprocs.i : Integer. {cari posisi sisip yang benar sambil menggeser} while (posisiSisip > 1) and (not posisiBenar) do begin yaitu shell-sort). Untuk menguji kecepatan pengurutan dari ketiga algoritma ini (ditambah sebuah algoritma lain yang belum dipelajari. bubble-sort adalah algoritma yang paling tidak sama dengan cara manusia mengurutkan kumpulan nilai yang berbeda-beda.periksaLayar(&lineCounter). var pass. type TArray=array[1. } } MEMBANDINGKAN KECEPATAN BERBAGAI ALGORITMA SORTING Di bawah ini disajikan sebuah program yang membandingkan kecepatan beberapa algoritma sorting yang sudah dipelajari sejauh ini. pL:^TArray. selection-sort dan insertion-sort. program yang 5 . } else { tampilkanArray(L. N. a:TArray. posisiSisip. } periksaLayar(&lineCounter). var i.j:Integer. const max=15000. posisiBenar : boolean. -1. N : Integer). begin new(pL). nilai. uses wincrt.max] of byte. time:longint.. for i:=1 to N do pL^[i]:=L[i].

indeksMin.1 {Pembandingan pada pass selanjutnya } {hanya sampai elemen terakhir tempat } {terjadinya pertukaran . pL:^TArray. N : Integer). langkah. {for} dispose(pL). end else posisiBenar := true.1. {procedure} procedure bubbleSort(var L : TArray. var batas_belum_terurut. {while} dispose(pL). end. N : Integer). } end {if} end. begin new(pL). begin new(pL). end. pL:^TArray. for i:=1 to N do pL^[i]:=L[i]. end. end. temp. {procedure} procedure selectionSort(var L : TArray.temp: Integer. for pass:= 1 to N-1 do begin {pencarian nilai minimum} 6 . batas_belum_terurut := N .i : Integer. var pass. pL^[langkah + 1] := temp. posisiSisip := posisiSisip . i.} end. } {Jika sebelumnya tidak ada pertukaran} {maka batas_belum_terurut = 0-1 = -1. {for} batas_belum_terurut := tukar_terakhir . for langkah := 1 to batas_belum_terurut do begin if pL^[langkah] > pL^[langkah + 1] then begin temp := pL^[langkah].1. for i:=1 to N do pL^[i]:=L[i].} {dan pertukaran terakhir dalam } {pass disimpan dalam variabel. while batas_belum_terurut > 0 do begin tukar_terakhir := 0. tukar_terakhir. {while} {posisiSisip<1 or posisiBenar} pL^[posisiSisip] := nilai. pL^[langkah] := pL^[langkah + 1].if nilai < pL^[posisiSisip-1] then begin pL^[posisiSisip] := pL^[posisiSisip-1]. {Menandakan terjadi pertukaran.1. tukar_terakhir := langkah.

temp. pL^[Index]:=pL^[Index + Gap]. { If an exchange was made. pL:^TArray.Gap do if pL^[Index] > pL^[Index + Gap] then begin temp:=pL^[Index]. { Set done to true } for Index := 1 to NumItems . end. {if} end. gap := NumItems. for i:= pass + 1 to N do begin if pL^[i] < pL^[indeksMin] then begin indeksMin := i. we're not done. { This is our index into the array } gap : Integer.i:Integer. end. { This is the gap of the sort. pL^[indeksMin] := pL^[pass]. while gap <> 1 do begin gap := gap div 2. 7 . dispose(pL). {if} end. {for i} {menukar nilai dalam elemen urut ke-pass dengan nilai min} if indeksMin <> pass then begin temp:=pL^[indeksMin]. } var Index. it is done over a distance of GAP. pL^[Index + Gap]:=temp. {for pass} dispose(pL). { This is the shell sort. NumItems : Integer). {procedure} procedure ShellSort(Var L : TArray. { Set our Gap to half of what it was } done := false.indeksMin := pass. done := false. pL^[pass] := temp. i:=5000. } done : boolean. end. begin new(pL). It is much like the bubble sort. {program utama} begin randomize. while not done do begin done := true. end. end. for i:=1 to NumItems do pL^[i]:=L[i]. } end. end. except instead of comparing and swapping adjacent elements.

' detik').47 detik 3.55 detik Selection 0.22 detik 0.' detik').34 detik 0. Shell-sort merupakan algoritma yang memanfaatkan kelebihan-kelebihan yang dimiliki oleh komputer dibanding manusia. sementara bubblesort adalah algoritma yang paling lambat. i:=i+2000. write((gettickcount-time)/1000:10:2.i).98 detik 1. bubbleSort(a. time:=gettickcount.05 detik 1. akan dibutuhkan waktu yang lebih lama 8 .66 detik 2. jika manusia diharuskan mengurutkan dengan algoritma shell-sort. time:=gettickcount. Artinya.05 detik Dari hasil pembandingan tersebut tampak bahwa semakin dekat algoritma sorting dengan cara yang dipergunakan manusia.83 detik 1. time:=gettickcount. write((gettickcount-time)/1000:10:2. write(i:7).02 detik 0. selectionSort(a. Tetapi kecenderungan ini tidak sepenuhnya benar jika algoritma sorting yang lebih canggih dimasukkan dalam pembandingan.03 detik 0. Insertion-sort yang paling mirip dengan cara manusia mengurutkan lebih cepat dalam melakukan proses pengurutan. time:=gettickcount.i). write((gettickcount-time)/1000:10:2.05 detik 0.72 detik 1. writeln. end. end. semakin cepat komputer melaksanakan algoritma tersebut.' detik'). write((gettickcount-time)/1000:10:2. while (i<=max) do begin for j:=1 to i do begin a[j]:=random(256). shellSort(a.' detik'). Shell-sort merupakan modifikasi dari algoritma bubble-sort dan merupakan metode yang sama sekali tidak mirip dengan cara manusia mengurutkan.55 detik Shell 0.02 detik 0.44 detik 0.52 detik 0. misalnya kemampuan mengelola variabel dan melakukan struktur perulangan dengan cepat. insertionSort(a. end. ' Insertion Shell').i).writeln(' N Bubble Selection'.17 detik 1.47 detik 1.97 detik Insertion 0. Output dari program di atas adalah: N 5000 7000 9000 11000 13000 15000 Bubble 0.17 detik 0.02 detik 0.50 detik 4. readln.i).56 detik 0.

qsort((void *)list. jika N meningkat 3 kali lipat. Terdapat algoritma sorting lain yang peningkatan waktu yang dibutuhkan meningkat secara logaritmis. Berikut ini adalah contoh program yang menggunakan fungsi tersebut [BOR97]: #include #include #include #include #include <stdio. printf("\n5 string sebelum diurutkan: "). printf("*****************************************************" "**************************").i<100.h> <time. i < 5. int main(void) { int i.h> <alloc. 9 .i++) { p[i]=random(100). printf("\n5 string SESUDAH diurutkan: "). maka waktu yang dibutuhkan meningkat secara linear. char list[5][4] = { "cat". finish. Perhatikan bahwa dengan menggunakan algoritma bubble. waktu yang dibutuhkan untuk mengurutkan N data meningkat secara kuadratik. printf("\n100 elemen data sebelum diurutkan: \n"). selection dan insertion. const void *b). for (i=0. list[i]). Algoritma sorting yang canggih ini disebut quicksort dan Bahasa C sudah menyediakan fungsi qsort() untuk melaksanakan algoritma ini. const void *b).h> <stdlib. "can" }. printf("\n*****************************************************" "**************************"). pada shell-sort. int sort_string(const void *a. int *p. randomize().h> int sort_integer(const void *a. 5. max=25000. "car". list[i]). "cab". p=(int *) malloc (sizeof(int)*100). sort_string). atau sebanyak 3 kali lipat juga.h> <string. for (i = 0.dibanding jika manusia yang sama harus mengurutkan dengan metode insertionsort. Tetapi. i++) printf("%s ". sizeof(list[0]). "cap". clock_t start. Jika N meningkat dari 5000 menjadi 15000 (3 kali lipat) maka ketiga algoritma sorting tersebut memerlukan waktu 9 kali lipat lebih lama. Sedangkan. komputer akan lebih cepat melakukan pengurutan dengan algoritma shell-sort dibanding algoritma lain yang telah dipelajari sejauh ini. i++) printf("%s ". printf("\n*****************************************************" "**************************"). double elapsed. maka waktu yang dibutuhkan hanya meningkat sebanyak log X kali lipat (misalnya log 1000 = 7 kali lipat). artinya jika jumlah elemen yang diurutkan meningkat sebanyak X kali lipat (misalnya 1000 kali lipat). for (i = 0. j. i < 5.

p=(int *)a. sort_integer). maka qsort() tidak akan menukar posisi kedua elemen. terlebih dahulu harus dikonversi menjadi pointer bertipe int.printf("%d ". 100. start=clock(). printf("%6d %7. finish=clock(). i. free(p). sizeof(p[0]).i+=5000){ p=(int *) malloc (sizeof(int)*i).i. printf("\n*****************************************************" "**************************"). const void *b) { /***** fungsi yang dibutuhkan oleh fungsi qsort() untuk membandingkan antara 2 elemen array. for (i=0. yaitu dengan p=(int *)a. x=*p. printf("\n100 elemen data SESUDAH diurutkan: \n").i++) { printf("%d ".Jika -1 atau 0 yang dikembalikan oleh fungsi ini.j++) p[j]=random(1000). return(x<y?-1:x==y?0:1). qsort((void *)p. p[i]).elapsed).5f\n". } free(p). sort_integer). p[i]). Fungsi ini mengembalikan nilai -1.i<100. maka statement di atas diganti menjadi: return(x>y?-1:x==y?0:1). } return 0. } int sort_integer( const void *a. *****/ int x.*p. for(i=1000. printf("\n*****************************************************" "**************************"). Untuk memperoleh nilainya. sizeof(p[0]). elapsed=(double)(finish-start)/CLK_TCK. const void *b) { 10 .j<i. baru kemudian diperoleh nilainya dengan x=*p **/ y=*((int *)b). /** Jika pengurutan ingin diakukan secara menaik (ascending).y. printf("\nTabel Waktu yang Dibutuhkan untuk " "melakukan QuickSort"). for(j=0. **/ } int sort_string( const void *a. printf("\n N Waktu (detik) \n"). /** elemen pertama dikirim sebagai void pointer a.i<=max. 0 atau 1. } qsort((void *)p.

[BOR97] Borland Intenational. juga harus dibuat sebuah fungsi yang membandingkan 2 buah elemen array. 11 .02 Help. Secara umum. Selanjutnya nama fungsi tersebut digunakan sebagai parameter ketika memanggil fungsi qsort()./***** fungsi yang dibutuhkan oleh fungsi qsort() untuk membandingkan antara 2 elemen array. } Dalam contoh program di atas. untuk bisa menggunakan fungsi qsort(). maka qsort() akan menempatkan elemen b sebelum elemen a dalam posisi pengurutan. Jika fungsi ini mengembalikan nilai -1 atau 0. 0 atau 1. 2001. Borland. 1997. jumlahElemenAray. Buku 2. namaFungsiPembanding). sizeOfElemen. Jika yang dikembalikan fungsi ini adalah 1. Algoritma dan Pemrograman dengan Bahasa Pascal dan C. Jika -1 atau 0 yang dikembalikan oleh fungsi ini. REFERENSI [RIN01] Rinaldi Munir & Leoni Lidya. Borland C++ 5. maka qsort() tidak akan menukar posisi kedua elemen. maka qsort() tidak akan menukar posisi kedua elemen.(char *)b) ). pemanggilan fungsi qsort() dilakukan sebagai berikut: qsort( (void *) namaArray. Bandung: Informatika. Fungsi ini mengembalikan nilai -1. *****/ return( strcmp((char *)a.

You're Reading a Free Preview

Download
scribd
/*********** DO NOT ALTER ANYTHING BELOW THIS LINE ! ************/ var s_code=s.t();if(s_code)document.write(s_code)//-->