PEMROGRAMAN MODULARadalah suatu teknik pemrograman di mana program yang biasanya cukup besar dibagi-bagi menjadi beberapa bagian program yang lebih kecil .Dalam beberapa bahasa pemrograman disebut : sub-rutin, modul, prosedur, atau fungsi.

STRUKTUR POHON

ILUSTRASIDEKLARASI A, B, Temp : integerALGORITMA { baca nilai A dan B} read(A) read(B) {proses pertukaran} temp A A B B temp { tulis nilai A dan B setelah pertukaran } output(A) output(B)

Dipecah subprogramDEKLARASI A, B : integer

Baca(A,B:Integer) ALGORITMA: read(A) read(B)

Tukar(A, B:integer) DEKLARASI temp : integer {peubah bantu} ALGORITMA temp A A B B temp Tulis(A,B : integer) ALGORITMA output(A) output(B)

ALGORITMA Baca(A,B) Tukar(A,B) Tulis(A,B)

KEUNTUNGAN Pemrogram Modular 1. Program lebih pendek 2. Mudah menulis (banyak programer) 3. Mudah dibaca dan dimengerti (bandingkan dg nonmodular dg banyak instruksi) 4. Mudah didokumentasi 5. Mengurangi kesalahan dan mudah mencari kesalahan(debug) program 6. Kesalahan yang terjadi bersifat lokal

Dua bentuk pemrogram modular : PROSEDUR dan FUNGSIStruktur setiap subprogram tersebut pada hakekatnya sama , yaitu :Nama modul (subprogram)Bagian deklarasiAlgoritma (intruksi yg akan dilaksanakan) Perbedaan penggunaannya dalam bahasa pemrograman Pascal :Prosedur merupakan modul(subprogram) yg melakukan aktifitas tertentu tanpa adanya pengembalian nilaiFungsi terdapat pengembalian nilai

PROSEDURDalam bahasa pemrogramanProsedur adalah modul program yang mengerjakan tugas/aktifitas yg spesifik dan menghasilkan suatu efek netto (membandingkan keadaan awal dan keadaan akhir dari suatu aktifitas prosedur)Setiap prosedur perlu mendefinisikan keadaan awal sebelum rangkaian instruksi di dalam prosedur dilaksanakan, dan keadaan akhir yg diharapkan setelah instruksi di dalam prosedur dilaksanakan

STRUKTUR PROSEDURJUDUL (header) nama prosedur dan deklarasi parameter(kalau ada)DEKLARASI mengumumkan nama-nama dan tipe dataALGORITMA badan prosedur (instruksi)

*sama dengan struktur ALGORITMA

Nama ProsedurNama yang unikSebaiknya diawali dengan kata kerja karena prosedur berisi suatu aktifitasMisalnya: HitungLuas, Tukar, CariMaks, Tulis, dll.

ParameterAdalah nama-nama peubah (variabel) yang dikdeklarasikan pada bagian header (judul) prosedur dan titik dimana dia dipanggil.Penggunaan parameter menawarkan mekanisme pertukaran informasi (antara yg memanggil (program/algoritma utama) dg prosedur itu sendiri)

Parameter dibedakan menjadi dua :Parameter aktual (argumen) :Parameter yg disertakan pada waktu pemanggilan prosedur (parameter yg ada pada program/algoritma utama).Parameter formal :Parameter yg dideklarasikan di dalam bagian header prosedur itu sendiri.

Ketika prosedur dipanggil, parameter aktual menggantikan parameter formal.Tiap-tiap parameter aktual berpasangan dengan parameter formal yg bersesuain (berkorespondasi satu satu)

Notasi algoritma untuk PROSEDURProcedure NamaProsedur(deklarasi parameter, jika ada){spesifikasi prosedur, berisi penjelasan tentang apa yg dilakukan oleh prosedur ini.K.awal : keadaan sebelum prosedur dilaksanakan.K. akhir : keadaan setelah prosedur dilaksanakan}DEKLARASI {semua nama yg dipakai di dalam prosedur dan hanya berlaku lokal di dalam prosedur ini}ALGORITMA{badan prosedur, berisi urutan instruksi}

Pendeklarasian Parameter dalam prosedur bukanlah keharusanContoh :Procedure HitungLuasSegitiga{menghitung luas segitiga dengan rumus : L = (alas x tinggi)/2}{K.awal : sembarang}{K.akhir : luas segitiga tercetak}DEKLARASIAlas, tinggi, luas : realALGORITMARead(alas, tinggi)Luas (alas * tingg) / 2Write(luas)

Pemanggilan ProsedurProsedur bukan program yg beridiri sendiriProsedur tidak dapat dieksekusi secara langsung.Instruksi-instruksi di dalam prosedur dapat dilaksanakan bila prosedur itu diakses.Prosedur diakses dg cara memanggil namanya dari program pemanggil (misalnya dari program utama atau modul program lainnya)Jika prosedur tanpa parameter, maka pemanggilannya cukup dg nama prosedurnya saja, contoh : HitungLuasSegitiga

Notasi Algoritma :PROGRAM Segitiga{menghitung luas segitiga}DEKLARASI Procedure HitungLuasSegitiga{menghitung luas segitiga dengan rumus : L = (alas x tinggi)/2}{K.awal : sembarang}{K.akhir : luas segitiga tercetak}DEKLARASIAlas, tinggi, luas : realALGORITMARead(alas, tinggi)Luas (alas * tinggi) / 2Write(luas)ALGORITMA HitungLuasSegitiga

KUISBUATLAH NOTASI ALGORITMA UNTUK MELAKUKAN PEMANGGILAN PROSEDUR LUASSEGITIGA SEBANYAK 3 X

Nama Global dan Nama LokalNama Lokal :Nama-nama (Konstanta, peubah(variabel), tipe, dll) yang dideklarasikan di dalam prosedur (termasuk parameter, jika ada). (hanya dikenal/digunakan dalam lingkup (scope) prosedur tersebut

Nama Global :Nama-nama (Konstanta, peubah(variabel), tipe, dll) yang dideklarasikan di dalam program utama. (dapat dikenal/digunakan dibagian manapun dalam program (progam utama maupun prosedur).

_______________________________________________________________Nama Peubah (variabel) I, N, alas, tinggi variabel GLOBALNama Peubah (variabel) luas variabel LOKAlPROGRAM Segitiga{menghitung luas N buah segitiga}DEKLARASI I, N : integer alas, tinggi : real Procedure HitungLuasSegitiga{menghitung luas segitiga dengan rumus : L = (alas x tinggi)/2}{K.awal : sembarang}{K.akhir : luas segitiga tercetak}DEKLARASIluas : realALGORITMA Luas (alas * tinggi) / 2 Write(luas)ALGORITMA read(N) { tentukan banyaknya segitiga } for I 1 to N do read(alas, tinggi HitungLuasSegitiga endfor

Menggunakan variabel Global atau variabel LokalBila suatu peubah (variabel) digunakan di seluruh bagian program (baik program utama maupun prosedur), maka deklarasikanlah peubah tsb secara Global.Bila suatu peubah (variabel) hanya digunakan di dalam prosedur, maka deklarasikanlah peubah tsb secara Lokal.Gunakan peubah global sedikit mungkinPenggunaan variabel lokal membuat program lebih eleganPenggunaan variabel lokal dapat meminimumkan usaha pencarian kesalahan yg disebabkan oleh nama-nama tsb.

ParameterProsedur yg baik adalah prosedur yg independen dari program utama/ program yg memanggilnya.Prosedur yg baik tidak menggunakan peubah-peubah global di dalam prosedur.Jika program utama perlu mengomunikasikan nilai peubah Global ke dalam prosedur, maka gunakanlah PARAMETER.

Parameter - nextPenggunaan parameter adalah mekanisme pertukaran informasi antara prosedur dengan yang memaggilnya (program utama maupun subprogram lainnya).Prosedur dengan parameternya (Parameter Formal) dapat diakses dg cara memanggil namanya dari program yg memanggilnya yg disertai dg parameter dari program yg memanggil tsb (Parameter Aktual).Contoh: NamaProsedur(parameter aktual)Tiap parameter aktual berpasangan dg paramater formal yg bersesuaian

Parameter - nextKetika prosedur dipanggil, parameter aktual berkoresponden satu-satu dengan parameter formal (parameter yg dideklarasikan pada bagian header prosedur)

Aturan korespondensi satu satuJumlah parameter aktual harus sama dengan jumlah parameter formal.Tiap parameter aktual harus bertipe sama dengan tipe parameter formal yg sesuai.Tiap parameter aktual harus diekspresikan dalam cara yg taat azas dg parameter formal yg bersesuaian, bergantung pada jenis parameter formal.

Jenis parameter formal yg disertakan di dalam prosedur :Parameter Masukan (input parameter) :Parameter yg nilainya berlaku sebagai masukan untuk prosedur.Parameter Keluaran (Output parameter):Parameter menampung keluaran yg dihasilkan oleh prosedur.Parameter masukan/keluaran (input/output parameter) :Parameter yg berfungsi sebagai masukan sekaligus keluaran bagi prosedur tsb.

Parameter masukanNilai parameter aktual diisikan ke dalam parameter formal yg sesuai.Perubahan nilai parameter di dalam badan prosedur tidak mengubah nilai parameter aktual.Nama parameter aktual boleh berbeda dg nama parameter formal yg sesuai

Contoh : paramater masukanProcedure HitungLuasSegitiga(input alas, tinggi : real){menghitung luas segitiga dengan rumus : L = (alas x tinggi)/2}{K.awal : alas dan tinggi sudah terdefinisi nilainya}{K.akhir : luas segitiga tercetak}DEKLARASIluas : realALGORITMA Luas (alas * tinggi) / 2 Write(luas)

Program utama yg memanggil nama prosedur:harus mendeklarasikan nama prosedur dan memanggilnya dg parameter aktual yg sesuai

PROGRAM Segitiga{menghitung luas N buah segitiga}DEKLARASI I, N : integer alas, tinggi : real Procedure HitungLuasSegitiga(input alas, tinggi : real){menghitung luas segitiga dengan rumus : L = (alas x tinggi)/2}{K.awal : alas dan tinggi sudah terdefinisi nilainya }{K.akhir : luas segitiga tercetak}DEKLARASIluas : realALGORITMA Luas (alas * tinggi) / 2 Write(luas)ALGORITMA read(N) { tentukan banyaknya segitiga } for I 1 to N do read(alas, tinggi HitungLuasSegitiga(alas,tinggi) endfor

nama parameter aktual tidak harus sama dengan nama parameter formal : yg dipentingkan adalah nilainyaPROGRAM Segitiga{menghitung luas N buah segitiga}DEKLARASI I, N : integer a, t : real Procedure HitungLuasSegitiga(input alas, tinggi : real){menghitung luas segitiga dengan rumus : L = (alas x tinggi)/2}{K.awal : alas dan tinggi sudah terdefinisi nilainya }{K.akhir : luas segitiga tercetak}DEKLARASIluas : realALGORITMA Luas (alas * tinggi) / 2 Write(luas)ALGORITMA read(N) { tentukan banyaknya segitiga } for I 1 to N do read(a, t) HitungLuasSegitiga(a,t) endfor

Parameter aktual boleh berupa ekspresi atau konstantaContoh :

HitungLuasSegitiga(a*0.2, t*0.1)

HitungLuasSegitiga(12, 6)

Parameter keluaranParameter keluaran dideklarasikan di dalam header prosedur, sebagaimana parameter masukanParameter keluaran dideklarasikan dengan keyword OUTPUT.Ketika prosedur yg mengandung parameter keluaran dipanggil, maka nama parameter aktual menggantikan (substitute) nama parameter formal yg bersesuaian.

Contoh : parameter keluaran-nextPROGRAM Segitiga{menghitung luas N buah segitiga}DEKLARASI I, N : integer a, t, L : real Procedure HitungLuasSegitiga(input alas, tinggi : real, output luas:real){menghitung luas segitiga dengan rumus : L = (alas x tinggi)/2}{K.awal : alas dan tinggi sudah terdefinisi nilainya }{K.akhir : luas segitiga tercetak}ALGORITMA Luas (alas * tinggi) / 2ALGORITMA read(N) { tentukan banyaknya segitiga } for I 1 to N do read(a, t) HitungLuasSegitiga(a, t, L) Write(L) endfor

Parameter masukan/keluaranProsedur harus dapat mengakomodasi baik masukan dari dan keluaran ke blok program pemanggilMaka gunakan parameter masukan/ keluaranBila parameter aktual diubah nilainya di dalam badan prosedur, maka sesudah pemanggilan prosedur nilai parameter aktual di titik pemanggilan juga berubahParameter masukan/keluaran dideklarasikan di dalam header prosedur dengan keyword INPUT/OUTPUTParameter aktual harus berupa peubah, tidak boleh berupa ekspresi atau konstanta

Contoh : parameter masukan/keluaranPROGRAM Cetak0Sampai10{ mencetak nilai dari 0 sampai 10 }

DEKLARASI x : integer procedure Inc(input/output x : integer) {menaikan nilai x sebesar 1} {K.Awal : x sudah terdefinisi nilainya} {K.Akhir : nilai x bertambah 1} DEKLARASI

ALGORITMA x x + 1

ALGORITMA X 0 repeat write(x) inc(x) until x > 10

Parameter masukan - parameter masukan/keluaran

PROGRAM xyzDEKLARASIa, b : integerProcedure tambah(input x,y:integer)DeklarasiAlgoritmax x + 4Y y +4write(nilai x dan y di akhir prosedur tambah:)Write( x=, x)Write( y=, y)ALGORITMAa 15B 10Write(nilai a dan b sebelum panggil prosedur tambah:)Write( a=, a)Write( b=, b)Tambah(a,b)Write(nilai a dan b sesudah panggil prosedur tambah:)Write( a=, a)Write( b=, b)

PROGRAM xyzDEKLARASIa, b : integerProcedure tambah(input/output x,y:integer)DeklarasiAlgoritmax x + 4Y y +4write(nilai x dan y di akhir prosedur tambah:)Write( x=, x)Write( y=, y)ALGORITMAa 15B 10Write(nilai a dan b sebelum panggil prosedur tambah:)Write( a=, a)Write( b=, b)Tambah(a,b)Write(nilai a dan b sesudah panggil prosedur tambah:)Write( a=, a)Write( b=, b)

Program dg prosedur atau tanpa prosedurDianjurkan menulis program yg modularProgram yg dipecah menjadi beberapa prosedur menunjukkan teknik pemrograman yg baik dan terstruktur

Prosedur dg parameter atautanpa parameterDianjurkan menulis prosedur dg parameterParameter dapat mengurangi kebutuhan penggunaan peubah (variabel) global

Parameter masukan atauparameter keluaranBila prosedur menghasilkan keluaran yg digunakan oleh program pemanggil, gunakan parameter keluaran untuk menampung keluaran tsb.Bila prosedur tidak menghasilkan keluaran, atau kalaupun menghasilkan keluaran tapi keluaran tsb hanya digunakan di dalam prosedur itu saja, maka gunakan parameter masukan.Bila prosedur menerima masukan sekaligus keluaran pada parameter yg sama, gunakan parameter masukan/keluaran.

Analisa kasus :menentukan jam berikutnya setelah ditambah satu detikTambah detik dengan 1, jika jumlah detik

Notasi Algoritma: menentukan jam berikutnya Program jamberikutnyaDeklarasiType jam : record

Notasi Algoritma : mencetak perjalan waktu terus menerus dg prosedur paramater masukan/keluaranProgram JamHidup{membuat jam hidup yg selalu bertambah 1 detik terus menerus sampai jam 00:00:00. Masukan jam dibaca dari piranti masukan (keyboard). Setiap pertambahan 1 detik, jam yg baru ditampilkan sebagai keluaran} DeklarasiType jam : record

FUNGSISub Program yg mempunyai tujuan/tugas spesifikFungsi dan prosedur adalah merupakan sub program yang ekivalenDalam beberapa masalah penggunaan salah satunya adalah hal yg lebih tepat.

FUNGSI-nextAdalah sub program yg memberikan/mengembalikan (return) sebuah nilai dari tipe tertentu (tipe dasar atau tipe bentukan)Fungsi di dalam program bersesuain dengan definisi fungsi di dalam matematika Contoh : a.f(x) = 2X2 + 5X 8 b. h(x,y) = 3x y +xy Dimana: f dan h adalah nama fungsi, sedangkan x dan y adalah parameter fungsi yg bersangkutan. Nilai yg diberikan oleh fungsi bergantung pada masukan parameter Misal : x=2, maka f(2) = 2*22 + 5*2 = 10 x=1, y=2, maka h(1,2) = 3*1 2+1*2=3

Nilai 10 dan 3 adalah nilai yang diberikan (return) oleh masing fungsi f dan fungsi h.

FUNGSI - nextParameter pada fungsi disebut juga dengan parameter formalParameter pada fungsi selalu merupakan sebagai parameter masukan yg digunakan oleh fungsi tsb untuk menghasilkan nilai.Fungsi tidak mempunyai parameter keluaran atau parameter masukan/ keluaran

FUNGSI - nextStruktur fungsi sama dengan Struktur prosedur (Header(judul), deklarasi, algoritma(badan fungsi))Fungsi diakses dengan memanggil nama fungsi tsb.dari program yg memanggilnya. (sama dengan prosedur).

Struktur fungsiFunction NamaFungsi(input deklarasi parameter, jika ada) tipe ( tipe nilai yg diberikan oleh fungsi){spesifikasi fungsi, menjelaskan apa yang dilakukan dan yang dikembalikan oleh fungsi}DEKLARASI{semua yg dipakai di dalam fungsi dan hanya berlaku di dalam fungsi didefinisikan di sini}ALGORITMA{badan fungsi, berisi instruksi-instruksi untuk menghasilkan nilai yg akan dikembalikan oleh fungsi} return ekspresi { pengembalian nilai yg dihasilkan fungsi }

Catatan : parameter formal selalu berjenis parameter masukan, sehingga parameter formal selalu diawal dengan keyword INPUTEkspresi : dapat berupa konstanta, peubah(variabel) atau sebuah rumus

Struktur fungsiFungsi untuk menghasilkan nilai f(x)=2x2+5x-8, x R

Function f(input x : real) real{mengembalikan nilai f(x) = 2x2+5x-8, x RDeklarasi{ tidak ada }Algoritma return 2*x*x + 5*x 8

______________________________________________Catatan : f adalah nama fungsi dengan tipe real x adalah paramater formal dengan tipe real 2*x*x + 5*x 8 : nilai yg dihasilkan oleh fungsi Return : mengembalikan hasil dari ekspresi 2*x*x + 5*x 8

KuisBuatlah contoh fungsi untuk meghitung nilai dengan dua parameter formal dengan tipe bilangan bulat

Fungsii untuk menentukan bilangan genap atau ganjilFunction Genap(input n : integer) boolean{ true jika n adalah bilangan genap, atau false jika tidak genap }

Deklarasi{ tidak ada }

Algoritma : return ( n mod 2 = 0 ) { ekspresi BOOLEAN }

Fungsi nama hari menggunakan peubah tanpa peubahFunction NamaHari(input har : integer) string{ mengembalikan nama hari berdasarkan nomor har}DEKLARASI nama : stringAlgoritma: case har 1: nama Senin 2: nama Selasa 3: nama Rabu 4: nama Kamis 5: nama Jumat 6: nama Sabtu 7: nama Minggu endcase

return nama

Function NamaHari(input har : integer) string{ mengembalikan nama hari berdasarkan nomor har}DEKLARASI { tidak ada }Algoritma: case har 1: return Senin 2: return Selasa 3: return Rabu 4: return Kamis 5: return Jumat 6: return Sabtu 7: return Minggu endcase

Fungsi untuk memeriksa kebenaran sandiFunction valid(input p : string) boolean{ true jika password p benar, atau false jika salah }Deklarasi const password = abc123 { sandi-lewat yg benar }Algoritma: return (p=password)

Pemanggilan FUNGSIFungsi di akses dengan cara memanggil namanya diikuti dengan parameter aktual (kalau ada)

Peubah NamaFungsi(parameter aktual, jika ada)

Pemanggilan FUNGSI : nextKarena fungsi menghasilkan nilai, maka:Nilai yang dikembalikan oleh fungsi ditampung di dalam sebuah peubah (variabel) yng bertipe sama dengan tipe fungsiContoh : y F(5) { y harus bertipe real } hh < Genap(m) {hh harus bertipe boolean; m harus sudah terdefinisi nilainya

Nilai yang dikembalikan oleh fungsi dapat langsung dimanipulasi.Contoh : write(F(5)) If Genap(m) then

Contoh : pemanggilan fungsiUntuk menampilkan tabel yang berisi nilai x dan f(x) di dalam selang[10,15] dengan delta X =0.2 : Dimana f(x)=2x2+5x-8, x R

output : ----------------------------- x f(x) ----------------------------- 10.0 242.0 10.2 251.08 10.4 14.8 15.0 ------------------------------

Contoh : pemanggilan fungsi - nextProgram TabelFungsi{program utama yg memperagakan cara pemanggilan fungsi f. program ini menampilkan tabel nilai-nilai x dan f(x) di dalam selang [10,15] dengan deltax = 0.2}Deklarasi x : real function f(input x : real) real { mengembalikan nilai f(x)=2x2+5x-8, x R} Deklarasi { tidak ada } Algoritma return 2*x*x + 5*x 8Algoritma: {buat header tabel} write(------------------------------) write( x f(x) ) write(------------------------------) x 10.0 while x < 15.0 do write(x, ,f(x)) x x + 0.2 endwhile {buat garis penutup} write(----------------------------)

Contoh : pemanggilan fungsi - nextProgram PeriksaSandi{memeriksa kebenaran sandi, dimana sandi dibaca dari keyboard, bil sandi salah, pemasukan sandi dapat diulang lagi maksimal 3 kali }Deklarasi Sandi : string { kata sandi yg dibaca dari keyboard } sah : boolean { true jika password benar, false jika password salah} i : integer { pencatat jumlah pembacaan sandi } function valid(input p : string) boolean { true jika password p benar, atau false jika salah } Deklarasi const password = abc123 { sandi-lewat yg benar } Algoritma: return (p=password) Algoritma: i 1 sah < false repeat read(sandi) if valid(sandi) then sah true else i i + 1 endif until (sah) or ( i > 3) if not sah then write(password salah, anda tidak punya hak mengakses sistem) endif

PROSEDUR atau FUNGSIFUNGSI digunakan apabila modul program mengembalikan sebuah nilaiPROSEDUR digunakan apabila modul program menghasilkan efek netto dari satu atau sekumpulan aksi

Mengubah fungsi menjadi prosedur: Menyatakan nilai yg dikembalikan (return value) oleh fungsi tsb dikonfersikan sebagai parameter keluaran pada prosedur

Fungsi

Function Maks(input a,b:integer)integerDeklarasiAlgoritma if a b then return a else return bendifProsedur

Function TentukanMaks(input a,b:integer, output maks :integer)DeklarasiAlgoritma if a b then maks a else maks bendif

Mengubah prosedur menjadi fungsi: Prosedur yg mempunyai satu buah parameter keluaran dapat ditulis sebagai fungsi dengan menyatakan parameter keluaran sebagai nilai yg dikembalikan oleh fungsi Prosedur

Procedure hitungrata2(input ndata:integer, output u: real)Deklarasi x: integer I : integer jumlah : integerAlgoritma: jumlah 0 for I 1 to Ndata do read (x) jumlah jumlah + x endfor

U jumlah/NdataFungsi

Procedure Rata2(input ndata:integer) realDeklarasi x: integer I : integer jumlah : integerAlgoritma: jumlah 0 for I 1 to Ndata do read (x) jumlah jumlah + x endfor

return jumlah/Ndata

RekursifFungsi RekursifFungsi rekursif adalah fungsi yang memanggil dirinya sendiri. Fungsi ini akan terus berjalan sampai kondisi berhenti terpenuhi. oleh karena itu dalam sebuah fungsi rekursif perlu terdapat 2 blok penting :BASIS : yaitu blok yang menjadi titik berhenti dari sebuah proses rekursi (memberi nilai yang terdefinisi pada fungsi rekursif)REKURENT: yaitu blok yang memanggil dirinya sendiri.

Pengertian REKURSIFSuatu proses dari suatu subprogram (prosedur atau fungsi) yang memanggil dirinya sendiri

Proses rekursifSuatu algoritma yg baik dan dapat membuat pemecahan masalah menjadi lebih mudah.Proses rekursif pengggunaan memori akan sangat besar, karena setiap kali suatu subprogram dipanggil, maka akan diperlukan sejumlah memori tambahan

Penulisan fungsi dan prosedur dengan rekursif :Algoritma rekursif harus dinyatakan dalam prosedur atau fungsi, karena hanya prosedur dan fungsi yg dapat dipanggil dalam sebuah program

Perlu diperhatikan adalah fungsi atau prosedur tsb harus mengandung suatu kondisi akhir dari suatu proses rekursiKondisi akhir diperlukan untuk mencegah terjadinya proses rekursif yg tidak akan ada hentinya (proses rekursif akan berjalan terus menerus tanpa berhenti).

Contoh:Procedure rekursifDeklarasiAlgoritma:Write(Informatika UHAMKA)rekursif

Kondisi pengakhiran suatu proses rekursif dapat dilakukan dengan memberikan konstruksi penyeleksian kondisi sehingga proses rekursif akan berhenti jika kondisi yg ditetapkan telah terpenuhi

Contoh:Procedur rekursifDeklarasiAlgoritma:If batas < 7 thenWrite (Informatika UHAMKA)Batas batas + 1Rekursifendif

Notasi algoritma :Program rekursiDeklarasiBatas : wordProsedur rekursifDeklarasiAlgoritma:If batas < 7 thenWrite(Informatika UHAMKA)Batas batas + 1RekursifEndifAlgoritma:Batas 0Rekursif

Contoh: untuk menampilkan suatu deret bilangan bulat positif N dari 0 sd. 10

Prosedur deret(input n word)DeklarasiAlgoritma:Write(N:3)If N < 10 thenDeret(N+1)endif Program urutDeklarasiN:wordProsedur deret(input n word)DeklarasiAlgoritma:Write(N:3)If N < 10 thenDeret(N+1)endifAlgoritma:N 0Deret(N)

Ide dasar dalam memecahkan suatu masalah dengan rekursif adalah sebagai berikut:

1. Tentukan kasus penyetop atau kasus dasar di mana pemanggilan rekursif tidak lagi diperlukan (karena solusinya sudah diperoleh) 2. Terapkan suatu langkah untuk menggiring kasus kompleks ke kasus penyetopnya dengan metode yang mencerminkan fungsinya

contoh : Masalah yang akan dipecahkan adalah memotong roti tawar tipistipis sampai habis. Jika masalah ini akan dipecahkan secara rekursif, maka solusinya adalah:1. Jika roti sudah habis atau potongannya sudah paling tipis, pemotongan roti selesai2. Jika roti masih bisa dipotong, potong tipis dari tepi roti tersebut, lalu lakukan prosedur 1 dan 2 untuk sisa potongannya.

Contoh fungsi rekursif misalnya adalah fungsi pangkat, faktorial, dan barisan fibonacci. Dalam fungsi pangkat xy , kita tahu bahwa semua bilangan selain 0, jika dipangkatkan dengan 0 nilainyasama dengan 1. Jika x dipangkatkan dengan y, dengan y lebih dari 0, maka hasilnya sama dengan x dikalikan dengan x dipangkatkan y 1. Jika dituliskan dalam notasi matematika definisinya adalah sebagai berikut: xy = 1, jika y=0 xy = x * xy-1, jika y > 0 Kita lihat di atas pada definisi y > 0, bentuk pemangkatan muncul kembali di sisi kanan. Itulah yangdisebut rekursif

Definisi rekursif selalu dimulai dengan kasus penyetop, penghenti, atau kasus dasar dari suatu permasalahan, dalam hal ini terjadi ketika nilai y = 0. Definisi rekursif yang lebih kompleks mengandung inti dari permasalahan yang akan dipecahkan, namun lebih sederhana. Dalam hal ini yang tadinya x dipangkatkan dengan y, kini bentuk pemangkatan menjadi lebih sederhana, yaitu y 1. Hal ini dimaksudkan untuk menggiring masalah kompleks ke kasus dasar atau penyetop rekursinya

Untuk x = 10 dan y = 0, hasil dari xy adalah 1. Untuk x = 10 dan y = 3 hasilnya dapat digambarkan sebagai berikut:

xy = 1, jika y=0xy = x * xy-1, jika y > 0

Algoritma PangkatFungsi PangkatRekursif(input x, y: integer): integer{mengembalikan nilai xy, y > 0 basis : xy = 1 jika y = 0 rekurens : xy = a x xy-1 }Deklarasi Algoritma:

if y = 0 then return 1else return x*PangkatRekursif(x, y-1) endif

Pangkat dalam Bahasa Pascalprogram pangkatrekursif;

uses wincrt;

var a, n: integer;

Function pangkat(a, n : integer ) : integer;

Begin If n = 0 then pangkat:= 1 Else pangkat:=a*pangkat(a,n-1);End;

begin a:=10; write('masukan pangkat:'); readln(n); writeln(a, pangkat ',n,' adalah: ',pangkat(a,n):10);end.

Procedure rekursifDeklarasiAlgoritma:Write(Informatika UHAMKA)rekursif

Program rekursiDeklarasiBatas : wordProsedur rekursifDeklarasiAlgoritma:If batas < 7 thenWrite(Informatika UHAMKA)Batas batas + 1RekursifEndifAlgoritma:Batas 0Rekursif

Program urutDeklarasiN:wordProsedur deret(input n word)DeklarasiAlgoritma:Write(N:3)If N < 10 thenDeret(N+1)endifAlgoritma:N 0Deret(N)

Menghitung nilai FAKTORIALFaktorial (0) = 1 : Nilai awal Faktorial (n) = n * faktorial(n-1) : Rekurentfaktorial (4) = 4 * faktorial (3) 3 * faktorial (2) 2 * faktorial (1) 1 * faktorial (0) 1 = 4 * 3 * 2 * 1 * 1 = 24 __________________________________________________function faktorial (input nilai : integer) : integer DEKLARASI

ALGORITMA: if nilai

Menghitung nilai FAKTORIAL-dalam bahasa PAscal

function faktorial (nilai : integer) : integer; begin if nilai

Pseudo-code - Bahasa Pascalfunction faktorial (input nilai : integer) : integer DEKLARASI

ALGORITMA: if nilai

Proses hitung faktorial dengan Prosedur program rekursiffaktorial;

uses wincrt;

var n:byte; f:longint;

procedure faktorial(N:byte; var hasil:longint); begin

if n

Fungsi - Prosedurfunction faktorial (nilai : integer) : integer; begin if nilai

Barisan FIBONANCIBarisan Fibonanci: F (0) = 0 F (1) = 1 F (n) = F ( n-1 ) + F (n-2); untuk n >1 ____________________________________________

Function fibonacci ( input n : integer ) : integer

Deklarasi

Algoritma:If n 0 then return 0 Else If n 1 then return 1 Else return fibonacci (n-1) + fibonacci (n-2) Endifendif

Bahasa pascalFunction fibonacci ( n : integer ) : integer; Begin If n = 0 then fibonacci := 0 Else If n := 1 then fibonacci := 1 Else fibonacci := fibonacci (n-1) + fibonacci (n-2); End;

Pseudo-code - Bahasa PascalFunction fibonacci ( input n : integer ) : integer

Deklarasi

Algoritma:If n 0 then return 0 Else If n 1 then return 1 Else return fibonacci (n-1) + fibonacci (n-2) Endifendif

Function fibonacci ( n : integer ) : integer;

Begin If n = 0 then fibonacci := 0 Else If n := 1 then fibonacci := 1 Else fibonacci := fibonacci (n-1) + fibonacci (n-2); End;

LatihanBuat Algoritma untuk menghitung deret S = 1+2+3+4+5+...+n menggunakan function rekursifBuatkanlah program dengan bahasa pascal lengkap untuk Algoritma di atas.

Array (Larik)Array yaitu yang berbaris-baris atau berderet-deret.Dalam pemrograman : deretan data yang mempunyai jenis atau tipe data yang sama.Nama Array mewakili deret data dia miliki.Contoh: A:array[1..5] of integerA adalah nama array

Definisi ArrayAdalah sebuah peubah (variabel) yang mempunyai struktur data yang dapat menyimpan lebih dari satu nilai yang sejenis (tipe data yang sama), setiap elemen diacu melalui indeksnya.Elemen array tersusun di memori secara berurutan (sekuensial), oleh sebab itu indeks array(larik) haruslah tipe data yang menyatakan keterurutan, misalnya integer atau karakter.

Elemen Array

I n d e k s

AI n d e k s

A1115822157331624417055163Elemen Array kosong Elemen Array yg sudah disi nilai A[1], A[2], A[3], A[4], A[5]

Variabel array vs variabel biasa

Variabel arrayVariabel biasaDapat menyimpan lebih dari satu nilai yg sejenis

Contoh:Deklarasi:A:array[1..5] of integer

Hanya dapat menyimpan satu nilai walaupun sejenis

Contoh :Deklarasi:A1 : integerA2 : integerA3 : integerA4 : integerA5 : integer

Deklarasi ArraySesuatu yang akan digunakan/dipakai dalam suatu program terlebih harus dideklarasikan Array (Larik) adalah struktur(susunan) data yg statis, artinya elemen larik harus sudah diketahui sebelum program dieksekusi. Jumlah elemen larik tidak dapat diubah (ditambah/dikurangi) selama pelaksanaan program (program running).Mendeklarasikan larik di dalam bagian deklarasi berarti :mendefinisikan banyaknya elemen larik (memesan tempat di memori)mendefinisikan tipe elemen larik (menetapkan tipe nilai yg dapat disimpan oleh larik (array).--> tipe data dapat berupa : tipe dasar/sederhana (integer, real, char, string, Boolean), tipe bentukan (tipe terstruktur :record)

Deklarasi Array -nextArray dari tipe data dasar :DEKLARASI :A : array[1.50] of integer NamaMhs : array[1..10] of string NilaiUjian : array[1..75} of realSebagai tipe bentukan :membuat/medefinisikan tipe dasar dengan nama sebuah tipe baru DEKLARASI : Type LarikInt : array[1..100] of integer { nama tipe baru} A:LarikInt {A adalah sebuah variable (peubah) array dg 100 elemen dan bertipe integer}

Deklarasi Array -nextSebagai sebuah konstanta :Mendefinisikan ukuran array (larik) sebagai sebuah konstantaDEKLARASI:Const max= 10N: array[1..max] of realI: integerALGORITMA :For i:=1 to max doread(n[i])Endfor

Deklarasi Array -nextSebagai tipe bentukan terstruktur (RECORD) :Tipe yang berbentuk rekaman (record), rekaman disusun oleh satu atau lebih field. Setiap field menyimpan data dari tipe dasar tertentu.DEKLARASI :Const NMaks = 100Type Mahasiswa : record< NIM : integer NAMA : String IPK : real >Type tabmhs : array[1..maks] of mahasiswaMhs : TabMhs Penulisan elemen mhs :Mhs[2] {elemen kedua dari array mhs}Mhs[2].NIM {mengacu field NIM dari elemen kedua dari array Mhs}Mhs[2].IPK {mengacu field IPK dari elemen kedua dari array Mhs} Pengsian Nilai per field :Mhs[i].NIM 102131002Mhs{i].NAMA BUDI UTOMOMhs[i].IPK 3.6

Menampilkan hasil per field :Output([Mhs[i].NIM, Mhs[i].NAMA, Mhs[i].IPK)

Acuan Elemen Array(Larik)Elemen Array diacu melalui indeksnya, Nilai Indeks harus terdefinisi.A[4] mengacu elemen ke 4 dari larik ANamaMhs[2] mengacu elemen ke 2 dari larik namaMhsA[i] mencau elemen ke-I dari larik A, asalkan nilai I sudah terdefinisi. Memanipulasi elemen array (larik) :A[4] 10NamaMhs[i] Achmad

Read(A[i]) If A[i] < 10 then A[i] A[i] + 10 Else .

Pemrosesan Array (Larik)Elemen array diproses secara beruntun melalu indeks yang terurut mulai dari elemen pertama sampai elemen terakhir.Skema umum pemrosesan array:PROGRAM ProsesArray

DEKLARASI:Const max= 10Type LarikInt : array[1..max] of integer

A : LarikIntI: integer {indeks Array}

ALGORITMA :For i:=1 to max do pemrosesan terhadap A[i])Endfor

Pemrosesan pengisian nilai, pembacaan, penulisan, komputasi, dan manipilasi lainnya.

Pengisian Elemen Array (Larik) :Secara Lansung :ContohA[i] 10Inisialisasi :For I 1 to n do A[i] IEndfor

Dengan pembacaan (dari keyboard) :Contoh :For I 1 to n do read(A[i])Endfor

Ukuran efektif Array (Larik)Jumlah elemen larik sudah ditentukan (statis), tapi belum tentu semua digunakan/dipakaiJumlah elemen yang dipakai itulah yang disebut dengan ukuran/jumlah efektif array.Ukuran efektif dapat dicatat di dalam peubah (variabel) tertentu, misalnya n.

tiga cara untuk menentukan jumlah elemen efektif dari array(Larik) :Jika Jumlah elemen efektif ditentukan di awalJika Jumkah elemen efektif diketahui di akhir pembacaanJika Jumlah elemen efektif baru diketahui di akhir pembacaan (variasi dari versi 2)

Jumlah elemen efektif ditentukan di awalProcedure BacaLarik(Output A : LarikInt, input n : integer) {Mengisi elemen-elemen larik A[1..n] dengan pembacaan}{K. Awal : n adalah jumlah elemen efektif larik, nilainya terdefinisi}{ K. Akhir : setelah pembacaan, seluruh elemen larik A berisi nilai-nilai yang dibaca dari piranti masukan (keyboard)}DEKLARASI i : integer {pencatat indeks larik }ALGORITMA for i 1 to n do read(A[i]) endfor

Jumlah elemen efektif diketahui di akhir pembacaan

Setiap kali selesai pembacaan satu buah elemen, akan dilakukan konfirmasi apakah masih ada lagi elemen larik yang akan dimasukkan, seperti statement di bawah ini :Write(Lagi? (y/t))JIka jawabnya y maka pembacaan dilanjutkan, jika t maka proses pembacaan dihentikan. Jumlah elemen yang dibaca di catat di dalam suatu variabel (peubah)

Procedure BacaLarik2(Output A: Larikint, Output n: integer){K. Awal : sembarang}{K. Akhir : sebanyak n buah elemen larik A berisi nilai-nilai yang dibaca; n berisi jumlah elemen larik yang diisi}DEKLARASIJawab : charALGORITMAN 0Repeat n n + 1Read(A[n])Write(Lagi? (y/t))Read(jawab)Until jawab = t

Jumlah elemen efektif baru diketahui di akhir pembacaan (variasi dari versi 2)

Proses pembacaan dianggap selesai jika nilai yang dibaca adalah suatu tanda, misalnya 9999.

Procedure BacaLarik3(output A, LArikint, output n : integr){mengisi elemen-elemen larik A[1..n] dg cara pembacaan. Akhir pembacaan ditandai jika nilai yang dibaca adalah 9999}{K.Awal : sembarang }K. Akhit : sebanyak n buah elemen larik A berisi nilai-nilai yang dibaca; n berisi jumlah larik yang diisi.}DEKLARASIx : integer {menyimpan sementara nilai yang di baca}ALGORITMA n 0 read(x) while x 9999 do n n +1 A[n] x read(x) endwhile {x = 9999}

Menghitung Nilai Rata-rataData yang sudah disimpan di dalam Larik, selanjutnya data tersebut dapat dimanipulasi

Procedure hitungRataRata(input A:Larikint, input n:integer)DEKLARASII : integerJumlah : realALGORITMAI 1 {dimulai dari elemen pertama}Jumlah 0 {jumlah total nilai mula mula} For i 1 to n do jumlah jumlah + A[i]EndforU jumlah/n

Notasi Algoritma hitung rata rataPROGRAM Rerata

DEKLARASIconst NMaks = 100typeLarikInt : array[1..NMaks] of integerA : LArikIntn : integeru : integer { nilai rata-rata } procedure BacaLarik1(output A : Larikint, input n :integer) { mengisi elemen larik A[1..n] dengan pembacaan }

procedure HitungRataRata(input A : LArikint, input n : integer. Output u : real) {menghitung nilai rata-rata larik A}

ALGORITMAread(n) {tentukan jumlah elemen larik yang akan digunakan }BacaLarik1(A, n)HitungRataRata(A, n, u)write(u)

Kapan menggunakan Larik (array):Untuk menyimpan sejumlah data yang bertipe sama.Untuk menghindari penggunaan nama-nama peubah(variabel) yang banyak.Agar penulisan program lebih efisien dalam penulisan kode programnya.

latihanBuatlah algoritma tanpa menggunakan prosedur (sub program) untuk menghitung nilai-nilai rata-rata dari data yang tersimpan pada elemen array(larik) yang bertipe integer. Konversikan algoritma tersebut ke dalam bahasa pascal.

ARRAY KONSTAN : Nilai yang terkandung di dalam sebuah array dapat bernilai konstan, artinya nilai-nilai tersebut tidak dapat diubah. mendeklarasikan array bersangkutan dengan kata kunci CONST.

Bentuk umumnya adalah sbb: Const NamaArray : array[IndekAwal..IndekAkhir] of tipe_data = (nilai1, nilai2, ...);

Bentuk umum array konstan

Const NamaArray : array[IndekAwal..IndekAkhir] of tipe_data = (nilai1, nilai2, ...)

Contoh :

Const A: array[1..5] of char = (A, B, C, D, E) Array A di atas bersifat konstan, maka nilai yang ada tidak digantikan dengan nilai lainnya.Contoh :A[1] V { SALAH, Karena elemen A[1] selalu bernilai A}A[2] W {SALAH, Karena elemen A[2] selalu bernilai B}A[3] X { SALAH, Karena elemen A[3] selalu bernilai C}A[4] Y {SALAH, Karena elemen A[4] selalu bernilai D}A[5] Z { SALAH, Karena elemen A[5] selalu bernilai E}

Algoritma penggunaan Array konstanProgram ArrayKonstan DEKLARASI :Const BULAN : array[1..12] of string = (Januari, Februari, Maret, April, Mei, Juni, Juli, Agustus, September, Oktober, Nopember, Desember)

noBulan : integer;

ALGORITMA : read(noBulan) write(BULAN[noBulan]);

MENCARI NILAI MAKSIMUM ARRAY :Nilai maksimum pada sebuah variabel Array adalah elemen array yang mempunyai nilai terbesar diantara elemen array lainnya.

1 2 3 4 5 6 7 8

Nilai maksimum adalah : 172 ada pada elemen A[5]

Kalau elemen larik sudah terurut baik secara ascending maupun descending, maka nilai maksimum langsung bisa diperoleh : Ascending pada elemen terakhir, Descending pada elemen pertama

Permasalahan muncul bila nilai elemen array tesusun secara acak, maka untuk mencari nilai maksimumnya harus mengunjungi seluruh elemen array.

A158157162169172155170163

Tiga versi algoritmauntuk mencari nilai maksimumCara 1 :1. Mengasumsikan nilai maksimum sementara (maks) adalah yang sangat kecil (misal: -9999).2. Selanjutnya array dikunjungi mulai dari elemen pertama, 3. setiap kali mengunjungi elemen array, bandingkan elemen tersebut dengan nilai maksimum sementara.4. Jika elemen array yang sedang dintinjau lebih besar dari nilai maksimum sementara, maka (maks) diganti dengan elemen tersebut.5. pada akhir kunjungan (setelah seluruh elemen array dikunjungi), nilai maksimum semntara menjadi nilai maksimum sebenarnya.

Ilustrasi untuk maks : -999 1 2 3 4 5 6 7 8

Asumsi : maks = -9999 (nilai maksimum sementara)

A[1] > maks? Ya maks A[1] (maks=158)A[2] >maks? Tidak maks tidak berubahA[3] > maks? Ya maks A[3] (maks=162)A[4] > maks? Ya maks A[4] (maks=169)A[5] >maks? Ya maks A[5] (maks=172)A[6] > maks? tidak maks tidak berubahA[7] > maks? tidak maks tidak berubahA[8] >maks? Tidak maks tidak berubah (proses pembandingan selesai)Didapat : maks = 172 (nilai maksimum array yang ditemukan)

A`158157162169172155170163

Algoritma untuk maks = -999Program NilaiMaksimumDEKLARASI :Const N = 8 A : array[1..N] of integer = (158, 157, 162, 169, 172, 155, 170, 163)I, maks : integer

ALGORITMA : Maks -9999 {nilai maksimum sementara} For i 1 to N do If A[i] > maks then Maks A[i] endif endfor Write(maks)

Cara 2: Mencari nilai Maksimal1. Nilai maksimum sementara diinisialisasikan dengan elemen pertama array.2. selanjutnya, arrray dikunjungi mulai dari elemen kedua3. setiap kali mengunjungi elemen array, bandingkan elemen tersebut dengan nilai maksimum sementara.4. jika elemen array yang sedang dintinjau lebih besar dari nilai maksimum sementara, maka (maks) diganti dengan elemen tersebut.5. pada akhir kunjungan (setelah seluruh elemen array dikunjungi), nilai maksimum sementara menjadi nilai maksimum sebenarnya.

Ilustrasi untuk maks : elemen pertama 1 2 3 4 5 6 7 8

Asumsi : maks = A[1] (nilai maksimum sementara, maks=158)

A[2] >maks? Tidak maks tidak berubahA[3] > maks? Ya maks A[3] (maks=162)A[4] > maks? Ya maks A[4] (maks=169)A[5] >maks? Ya maks A[5] (maks=172)A[6] > maks? tidak maks tidak berubahA[7] > maks? tidak maks tidak berubahA[8] >maks? Tidak maks tidak berubah (proses pembandingan selesai)Didapat : maks = 172 (nilai maksimum array yang ditemukan)

A`158157162169172155170163

Algoritma untuk maks = Elemen pertamaProgram NilaiMaksumumDEKLARASI :Const N = 8 A : array[1..N] of integer = (158, 157, 162, 169, 172, 155, 170, 163)I, maks : integer

ALGORITMA : Maks A[1] {nilai maksimum sementara} For i 2 to N do If A[i] > maks then Maks A[i] endif endfor Write(maks)

Cara 3: Mencari nilai MaksimalMencari nilai maksimal berdasarkan nomor indeks array.

Algoritma : idxMaks 1 for I 2 to n do if A[i] > A[idxMaks] then idxMak I endif endfor

Mencari Nilai Minimum Array (Larik)Mencari elemen larik yang mempunyai nilai terkecil di antara elemen larik lainnya. Konsepnya sama dengan Mencari nilai maksimum array

Latihan Buatlah algoritma untuk mencari nilai terbesar dari data yang sudah tersimpan pada elemen array, dimana nilai yang tersimpan pada elemen array tersebut di baca dari inputan eksternal (keyboard).Konversikan algoritma di atas ke dalam Bahasa Pascal

Menyalin Larik (Array)1 2 3 4 5 6 7 81 2 3 4 5 6 7 8

A`158157162169172155170163

B`

Algoritma Menyalin LarikProgram Salin

DEKLARASI:Const maks=100A:array[1..maks] of integerB:array[1..maks] of integerI,n : integer

ALGORITMA:Read(n) {menentukan jumlah elemen yang akan digunakan} {membaca nilai dari inputan eksternal (keyboard)}For I 1 to n do read(A[i])Endfor

{menyalin Larik A ke Larik B} for I 1 to n do B[i] A[i] endfor

{Menampilkan nilai elemen array B setelah dilakukan penaylinan dari elemen array A}For I 1 to n do write(B[i])endfor

Menguji kesamaan dua buah LarikDilakukan dengan membandingkan setiap elemen yang berpadanan pada ke dua larik tersebutJika ditemukan satu saja elemen yang tidak sama, maka dapat dipastikan dua buah larik tersebut tidak sama.Apabila semua elemen dari larik itu sama, maka dapat dikatakan dua buah larik itu sama.

Menguji kesamaan dua buah Larik - next1 2 3 4 5 1 2 3 4 5

A`123130140160180

B` 123130140160180

Algoritma menguji kesamaan larikProgram ujiDEKLARASIConst maks=5 A:array[1..maks] of integer=(123,130,140,160,180) B:array[1..maks] of integer=(123,130,140,160,180)I : integerSama : booleanALGORITMA: I 1Sama trueWhile (I maks) and (sama) do if A[i] = B[i] then I I + 1 {tinjau elemen berikutnya} else sama false endifEndwhile { I > maks or sama=false }{tampilkan hasil}If sama true then write(dua larik sama)Else write(dua larik berbeda)endif

ARRAY DUA DIMENSI (MATRIKS)Pengertian array dua dimensi :Array dua dimensi dapat dipandang sebagai gabungan array satu dimensi.Ilustrasi :Pandanglah tiga buah array satu dimensi yang dibuat dengan: A1[4], A2[4], A3[4] : dengan tipe data yang sama

ARRAY DUA DIMENSI (MATRIKS)-nextKetiga buah array satu dimensi di atas, dapat digabung menjadi satu, sehingga terbentuk sebuah array yang disebut array dua dimensi, yang dapat diilustrasikan sebagai berikut :

Dari ilustrasi diatas, terlihat array tersebut terdiri dari 3 baris, dan 4 kolom, dan jumlah elemennya = 3 x 4 = 12 elemen, karena terdiri dari baris (row) dan kolom (column) maka arrray dua dimensi sering disebut MATRIX.Karena sudah menjadi satu buah array, maka nama array hanya satu buah, Misalnya A[3] [4] yang maksudnya adalah terdiri barisnya ada 3, dan kolomnya ada 4.

Bentuk Umum Array Dua Dimensi

Array konstan untuk array dua dimensi (matriks)Cotoh:Array Dua Dimensi dengan matriks : 3 x 5, dengan tipe data integer dan char :

Mengisi Elemen Array Dua Dimensi (MATRIKS)Diketahui array dua dimensi : A : array[1..3, 1..4] of integer

Untuk keperluan praktis dan keragaman, indeks untuk baris dan kolom menggunakan variabel. Misal : i untuk baris dan J untuk kolom Algoritmanya : I 2 J 3 A[i, j] 17

Isi Elemen Matriks per baris atau per kolom

Pengisian semua elemen Matrikssecara baris perbaris :

Algoritmanya :N 1I 1While (i

Pengisian semua elemen Matrikssecara kolom perkolom :

Algoritmanya : X 1N XJ 1While (J

Mengisi Elemen Array Dua Dimensi, dengan Nilai yang diinput dari Keyboard :Misalnya Array Dua Dimensi dengan Matrik 3 x 5. isikan nilai kedalam elemen matrik tersebut.

Algoritmanya :I 1While (i

Latihan 1:diketahui matriks 3 x4 untuk array dua dimensi, Buatlah algoritma untuk melakukan inisialisasi nilai (nilai konstan) pada array dua dimensi tersebut dengan tipe data integer. Dan cetak/tampilkanlah nilai dari masing-masing elemen dari matriks tersebut di atas.Transformasikanlah Algoritma di atas ke dalam bahasa pemrogaram PASCAL.

Latihan 2:diketahui matriks 3 x4 untuk array dua dimensi, Buatlah algoritma dengan menginputkan nilai dari inputan eksternal (keyboard) ke dalam masing elemen matriks di atas dengan tipe data integer. Dan cetak/tampilkanlah nilai dari masing-masing elemen dari matriks tersebut.Transformasikanlah Algoritma di atas ke dalam bahasa pemrogaram PASCAL.

MENYALIN ISI ARRAY DUA DIMENSI

Algoritmanya :

For i=1 to i

MENGHITUNG TOTAL ISI ARRAY DUA DIMENSI Algoritmanya :TOT 0I 1 While (i

MENAMBAH ISI DUA BUAH ARRAY DUA DIMENSI Dua buah array Dua Dimensi yang dibuat A[3,4], dan B[3,4] dengan tipe data integer.

Algoritmanya :I 1While (i

MENGALIKAN ISI DUA BUAH ARRAY DUA DIMENSI :Dua buah array Dua Dimensi A[2,3] dan B[3,4] yang dibuat dengan tipe data integer :

Catatan :Syarat dua buah matriks dapat dikalikan adalah : Jumlah kolom matriks ke 1 harus sama dengan jumlah baris matriks ke 2.Sedangkan hasilnya adalah matriks ke 3, yaitu jumlah baris matriks ke 3 (matriks hasil) sama dengan jumlah baris matriks ke 1, dan jumlah kolomnya (matriks 3) sama dengan jumlah kolom matriks ke 2.

Perkalian matriks - nextContoh : A[2,3] x B[3,4] = c[2,4] Ilustrasi proses :2x3+4x2+3x3 =2x2+4x4+3x3 =2x5+4x6+3x2 =2x7+4x3+3x5 =

3x3+2x2+5x3 =3x2+2x4+5x3 =3x5+2x6+5x2 =3x7+2x3+5x5 =

Secara umum 8 persamaan di atas, dapat ditulis sebagai berikut : C[i,j] = (A[i,k] * b[k,j] ) Dimana : K dipakai untuk : COL pada array A dan ROW pada array B, dan untuk suatu nilai i dan j, nilai k bergerak 1 sd. 3

Latihan 1:diketahui matriks 3 x4 untuk array dua dimensi, Buatlah algoritma untuk menghitung nilai total dari matriks tersebut sedang nilai didapat dengan melakukan inisialisasi nilai (nilai konstan) pada array dua dimensi tersebut dengan tipe data integer. Dan cetak/tampilkanlah nilai total dari matriks di atas. Transformasikanlah Algoritma di atas ke dalam bahasa pemrogaram PASCAL.

Latihan 2:diketahui matriks A=2 x3 dan matrisk B=3x4, Buatlah algoritma untuk menghitung hasil perkalian dua buah matriks. Sedang nilai dari dua buah matriks tersebut didapat dengan melakukan inisialisasi nilai (nilai konstan) pada dua matriks tersebut dengan tipe data integer. Dan cetak/tampilkanlah hasil perkalian dua matriks tersebut. Transformasikanlah Algoritma di atas ke dalam bahasa pemrogaram PASCAL.

TUGAS (dikumpulkan minggu depan, 20 april 2011)Buatlah tiga jenis algoritma untuk menentukan hasil perkalian dari dua buah matriks. Dengan ketentuan sebagai berikut :Silahkan tentukan sendiri ukuran dari dua buah matriks tersebut. Tentukanlah nilai dari dua buah matriks tersebut dengan menggunakan inisialisasi atau inputan dari keyboard.Tipe data ke dua matriks tersebut adalah integer.

Konversikanlah tiga jenis algoritma di atas ke dalam bahasa pemrograman Pascal.

Algoritma PencarianProses pencarian adalah menemukan nilai (data) tertentu dalam sekumpulan data yang bertipe sama (tipe dasar atau tipe bentukan) larik (array)Pencarian (searching) merupakan proses yg mendasar dalam pengelohana data.Contoh: UPDATE, INSERT.

Spesifikasi Masalah Pencarian :Hasil/keluaran dari persoalan pencarian bergantung pada spesifikasi rinci dari persolan tersebut, seperti hasil/keluaran:Sebuah pesan (message) : ditemukan atau tidak ditemukan di dalam Larik.Contoh : write(ditemukan) atau write( tidak ditemukan) Indeks emelen Larik dari data/nilai yg ditemukan, jika tidak ditemukan indeks diisi dg harga khusus, misal:-1

Contoh: x= 76 idx=3, x=100 idx=-1Nilai boolean yg menyatakan status hasil pencarian : jika ada data/nilai ditemukan, maka peubah/variabel yg bertipe boolean diisi dg true, dan kalau tidak ketemu diisi dengan false.Contoh: x= 76 ketemu=true, x=100 ketemu= false

Pencarian untuk duplikasi data :Apabila data yang dicari terdapat lebih dari satu banyaknya, maka hanya data yang pertama kali ditemukan yang diacu, dan algoritma pencarian selesai.Contoh :

Larik A mempunyai dua buah nilai 42, maka algoritma selesai ketika nilai 42 pertama ditemukan, yaitu pada elemen ke-6, dan hasilnya adalah idx = 6, atau ketemu = true.Nilai 42 lainnya tidak dipertimbangkan lagi dalam pencarian.

metode pencarian data di dalam array diklasifikasikan menjadi dua, yaitu :Metode pencarian beruntun (sequantial search)Metode pencarian bagi dua/pencarian biner (binary search)

Metode pencarian beruntun (sequantial search)

Disebut juga dengan pencarian lurus (linear search)Proses membandingkan setiap elemen larik(array) satu persatu beruntun, mulai elemen pertama sampai elemen yg dicari ditemukan, atau seluruh elemen sudah diperiksa

Contoh : Metode pencarian beruntun (sequantial search)

Misalkan nilai yang dicari adalah 42Pemeriksaaan dilakukan terhadap elemen 60, 12, 76, 23, 11, 42 (ditemukan)Ternyata nilai ditemukan pada elemen ke 6 : Indek larik yang dikembalikan : idx 6Proses pencarian dihentikan.

Misalkan nilai yang dicari adalah 20Pemeriksaan dilakukan terhadap elemen 60, 12, 76, 23, 11, 42, 18, 42 (tidak ditemukan)Ternyata nilai tidak ditemukan di dalam array,Indeks larik yang dikembalikan : idx -1Proses pencarian dihentikan.

Dua Versi algoritmapencarian beruntun ( sequential search)Aksi pembandingan dilakukan sebagai kondisi pengulangan : Tidak menggunakan peubah (variabel) boolean dalam proses pencarian.Aksi pembandingan dilakukan di dalam badan pengulangan :menggunakan peubah (variabel) boolean dalam proses pencarian.

Versi 1:Aksi pembandingan dilakukan sebagai kondisi pengulangan : Hasil pencarian yg diinginkan: sebuah peubah boolean yg bernilai true bila nilai ditemukan atau bernilai false bila data/nilai tidak ditemukan

Algoritma :Setiap elemen array dibandingkan dengan nilai/data yg dicari mulai dari elemen pertama Aksi pembandingan dilakukan selama indeks array belum melebihi banyaknya elemen array (n) dan A[i] tidak sama dengan nilai/data yg dicari.Aksi pembandingan dihentikan, bila A[i] = nilai/data yang dicari atau i=n.Elemen terakhir A[i] diperiksa secara khusus.Keluaran yg dihasilkan adalah sebuah peubah boolean bernilai true jika data ditemukan, atau false jika data tidak ditemukan.

Algoritma versi 1: hasil pencarian sebuah variabel booleanProsedur :

Procedure cariberuntun(input A:larikint, input n: integer, input x:integer, output ketemu:boolean)Deklarasi : I : integerAlgoritma :I 1While(i

Algoritma lengkap u/ panggil prosedur : versi 1Program PencarianDeklarasi: const Nmaks = 100 type LarikInt : array[1..Nmaks] of integer A: LarikInt x:integer found : boolean n : integer Procedure bacalarik(output A:LarikInt, input n:integer) Deklarasi : I : integer Algoritma: for I 1 to n do read(A[i]) endfor Procedure cariberuntun(input A:larikint, input n: integer, input x:integer, output ketemu:boolean) Deklarasi : I : integer Algoritma : I 1 While(i

Versi 1:Aksi pembandingan dilakukan sebagai kondisi pengulangan : Hasil pencarian yg diinginkan: indeks elemen array (larik) yang mengandung nilai/data yang dicari.

Algoritma :Setiap elemen array dibandingkan dengan nilai/data yg dicari mulai dari elemen pertama Aksi pembandingan dilakukan selama indeks array belum melebihi banyaknya elemen array (n) dan A[i] tidak sama dengan nilai/data yg dicari.Aksi pembandingan dihentikan, bila A[i] = nilai/data yang dicari atau i=n.Elemen terakhir A[i] diperiksa secara khusus.Keluaran yg dihasilkan adalah sebuah peubah index (misal: idx) yang berisi indeks larik tempat data/nilai yang dicari ditemukan. jika data data tidak ditemukan, idx diisi dengan nilai -1.

Algoritma versi 1: hasil pencarian sebuah Indeks elemen arrayProsedur :

Procedure cariberuntun(input A:larikint, input n: integer, input x:integer, output idx: integer)Deklarasi : I : integerAlgoritma :I 1While(i

Kasus : versi 1menambah (append) nilai/data ke dalam larik (array)Tentukan atau lakukan pencarian apakah data/nilai tersebut sudah ada dalam array.Jika belum ada, maka nilai/data tersebut ditambahkan pada elemen ke n+1.Penambahan satu elemen baru tidak melampaui ukuran maksimal larik(array) (Nmaks).Setelah penambahan elemen baru, ukuran larik(array) efektif menjadi n+1.

Algoritma :penambah (append) nilai/data ke dalam larik (array)Program TambahelemenlarikDeklarasi: const Nmaks = 100 type LarikInt : array[1..Nmaks] of integer L: LarikInt x, idx, n :integer Procedure bacalarik(output A:LarikInt, input n:integer) Deklarasi : I : integer Algoritma: for I 1 to n do read(A[i]) endfor Procedure cariberuntun(input A:larikint, input n: integer, input x:integer, output idx:integer) Deklarasi : I : integer Algoritma : I 1 While(i

Versi 2: Aksi pembandingan dilakukan di dalam badan pengulangan :(bukan di awal pengulangan) Hasil pencarian yg diinginkan: sebuah peubah boolean yg bernilai true bila nilai ditemukan atau bernilai false bila data/nilai tidak ditemukanAlgoritma :Diperlukan sebuah peubah boolean untuk menyatakan apakah nilai sudah ditemukan.Peubah boolean (misal. Ketemu) diinisialisasi dg nilai false.Setiap elemen array dibandingkan dengan nilai/data yg dicari mulai dari elemen pertama Jika A[i] = nilai/data yang dicari, peubah Ketemu diisi dengan nilai true, pengulangan dihentikan.Sebaliknya, jika A[i] nilai yg dicari, pembandingan dilanjutkan untuk elemen berikutnya.Keluaran yg dihasilkan adalah nilai yg disimpan di peubah(variabel) ketemu.

Algoritma versi 2: hasil pencarian sebuah variabel booleanProsedur :

Procedure cariberuntun(input A:larikint, input n: integer, input x:integer, output ketemu:boolean)Deklarasi : I : integerAlgoritma :Ketemu falseI 1While(I n) and (not ketemu) do if A[i] = x then ketemu true {x ditemukan} else I I +1 endifEndwhile { I > n or ketemu }

Fungsi :

Function cariberuntun(input A:Larikint, input n:integer, input x :integer) booleanDeklarasi: I : integerAlgoritma:Ketemu false I 1 While(I n) and (not ketemu) do if A[i] = x then ketemu true {x ditemukan} else I I +1 endifEndwhile { I > n or ketemu } return ketemu

Algoritma versi 2: hasil pencarian sebuah indeks elemen larikProsedur :

Procedure cariberuntun(input A:larikint, input n: integer, input x:integer, output idx: integer)Deklarasi : I : integer ketemu : booleanAlgoritma :Ketemu falseI 1While(I n) and (not ketemu) do if A[i] = x then ketemu true {x ditemukan} else I I +1 endifEndwhile { I > n or ketemu } if ketemu true then idx 1 else idx -1 endif

Fungsi :

Function cariberuntun(input A:Larikint, input n:integer, input x :integer) integerDeklarasi: I : integer ketemu : booleanAlgoritma:Ketemu false I 1 While(I n) and (not ketemu) do if A[i] = x then ketemu true {x ditemukan} else I i +1 endifEndwhile { I > n or ketemu }if ketemu true then return 1 else return -1 endif

Kinerja AlgoritmaPencarian Beruntun (Sequential search)Data yg belum terurut :Secara umum pencarian LambatWaktu pencarian sebanding dengan jumlah elemen larikData yg sudah terurut :Dapat meningkatkan kinerja pencarianKarena dapat segera menyimpulkan bahwa data yg dicari tidak terdapat di dalam larik bila ditemukan elemen larik yg lebih besar dari data yg dicari

Pencarian beruntun data yg terurut

Metode pencarian bagidua (binary search)

Algoritma pencarian pada data terurut yang paling efisien (data harus sudah terurut)Digunakan untuk kebutuhan pencarian dg waktu yang cepat (tidak membaca dari awal sampai akhir)Mencari data dg cara membagi larik menjadi duaDalam proses pencarian diperlukan dua buah indeks larik, yaitu indeks terkecil (indeks ujung kiri larik) dan indeks terbesar (indeks ujung kanan larik).

Langkah-langkahpencarian bagiduaMisal indeks kiri = I, indeks kanan j :Bagi dua elemen larik pada elemen tengah. Elemen tengah adalah indeks k = ( I + j ) div 2Elemen tengah A[k] membagi larik menjadi dua bagian : bagian kiri A[i..k-1] dan bagian kanan A[k+1..j]Periksa apakah A[k] = x(data yg dicari),Jika ya pencarian selesai (x sudah ditemukan)Jika A[k] x, harus ditentukan apakah pencarian sebelah kiri atau kananJika A[k] < x, maka pencarian dilakukan pada larik sebelah kananJika A[k] > x, maka pencarian dilakukan pada larik sebelah kiri.Ulangi langkah 1

Ilustrasi pencarian bagidua :Misal data yang dicari adalah 22 :

Algoritma pencarian bagidua :

Penerapan pencarian bagidua dalam bahasa pascal Program CariBagiDua;Uses wincrt;Const A:array[1..14] of integer = (10, 12, 14, 15, 16, 18, 19, 20, 22, 24, 25, 26, 28, 29);Var Idxawal, idxakhir, k, x : integer; Ketemu : boolean;Begin Write('Masukkan nilai yang akan dicari : '); readln(x); {melakukan pencarian} Idxawal := 1; Idxakhir := 14; Ketemu := false; While (not ketemu) and (idxawal

Kinerja pencarian bagidua :Untuk kasus terburuk: x tidak diketemukan, atau x ditemukan setelah ukuran larik tinggal 1 elemen). ,misal banyaknya elemen larik=256, maka menghasilkan pembagian larik sebanyak 8 kali, sedang dengan pencarian beruntun melakukan pembandingan sebanyak 256 kali. Untuk larik yang terurut, algoritma pencarian bagi dua (binary search) jauh lebih cepat daripada algoritma pencarian beruntun (sequential search).

Algoritma pencarian beruntun atau pencarian bagidua?Sequential Search

Dapat digunakan baik untuk data yg belum terurut maupun data terurutKinerja lebih lambat

Binary Search

Hanya dapat digunakan untuk data yg terurut saja.

Kinerja lebih cepat

ALGORITMA PENGURUTAN (SORTING)Pengurutan (sorting) adalah proses mengatur sekumpulan objek menurut urutan atau susunan tertentu.Tersusun secara menurun (ascending):Misal : Array A dengan elemen NA[1] A[2] A[3] A[N]Tersusun secara menaik (descending) :Misal : Array A dengan elemen N A[1] A[2] A[3] A[N]

Jenis Metode Algoritma Pengurutan :Pengurutan Apung (Bubble Sort)Pertukaran elemenPengurutan Seleksi (Selection Sort)Pertukaran elemenPengurutan Sisip (Insertion Sort)Geser dan sisip elemenPengurutan Shell (Shell Sort)Geser dan sisip elemen

Semua algoritma pengurutan selalu melakukan operasi perbandingan elemen larik untuk mendapatkan urutan yg tepat.

Klasifikasi pengurutan :Pengurutan internal : Pengurutan untuk data yg disimpan di dalam memori komputer ( pengurutan Array / larik )Pengurutan eksternal :Pengurutan untuk data yg disimpan di dalam disk storage ( pengurutan arsip / file )

Pengurutan Apung (Bubble Sort)

Terinspirasi dari gelembung sabun (berat jenis gelembung lebih ringan dari berat jenis air)Dalam array yg terurut menaik, maka elemen larik yang paling kecil diapungkan dengan cara diletakan keujung kiri larik melalui proses pertukaran.

Algoritma pengurutan Apung (bubble sort)For I 1 to n-1 do for k n downto i+1 do if A[k] < A[k-1] then {pertukarkan A[k] dengan A[k-1]} temp A[k] A[k] A[k-1] A[k-1] temp endif endforendfor

Penarapan bubble sort dg Pascal :Program UrutBubble;Uses wincrt;Const N=6; A:array[1..N] of integer = (25, 27, 10, 8, 76, 21);Var i, k, temp : integer; Begin {menampilkan data sebelum proses pengurutan } Writeln(Data sebelum diurutkan); For i:=1 to N do begin Writeln(A[, i, ] = , A[i]); End; { melakukan proses pengurutan } For i:= 1 to N-1 do begin For k:=n downto i+1 do begin If A[k] < A[k-1] then begin Temp := A[k]; A[k] := A[k-1]; A[k-1] := temp; End; End; End; {menampilkan data setelah proses pengurutan} Writeln; Writeln(Data setelah diurutkan); For i := 1 to N do begin Writeln(A[, i, ] = , A[i]); End; End.

Kinerja pengurutan apung (bubble sort)Algoritma pengurutan yg tidak efisienKarena, banyaknya operasi pertukaran yg dilakukan setiap langkah pass (pengapungan)Waktu lama, maka jarang digunakanKelebihan, kesederhanaan dan mudah dipahami.

Pengurutan Seleksi (Selection Sort)

Adalah memilih elemen maksimum/ minimum dari LarikMenempatkan elemen maksimum/ minimum tersebut pada awal/akhir larik (elemen ujung)Elemen terujung tersebut diisolasi dan tidak disertakan pada proses selanjutnya.Proses yg sama diulang untuk elemen larik yg tersisaMemilih elemen maksimum/minimum berikutnya dan mempertukarkannya dengan elemen terujung larik sisa.

Algoritma pengurutan seleksi (selection sort)For i n downto 2 do {cari elemen maksimum pada A[1..i]} imaks 1 {indeks elemen pertama diasumsikan sebagai elemen maks sementara} maks A[1] {elemen maksimum} for j 2 to I do if A[j] > maks then imaks j maks A[j] endif endfor {pertukaran maks dengan A[i]} temp A[i] A[i] maks A[imaks] tempendfor

Penarapan Selection sort dg Pascal :Program Urut_seleksi;Uses wincrt;Const N=6; A:array[1..N] of integer = (25, 27, 10, 8, 76, 21);Var i, j, imaks,maks, temp : integer; Begin {menampilkan data sebelum proses pengurutan } Writeln('Data sebelum diurutkan'); For i:=1 to N do begin Writeln('A[', i, '] = ', A[i]); End; { melakukan proses pengurutan } For I := n downto 2 do begin {cari elemen maksimum pada A[1..i]} imaks := 1; {indeks elemen pertama diasumsikan sebagai elemen maks sementara} maks := A[1]; {elemen maksimum} for j := 2 to I do begin if A[j] > maks then begin imaks := j; maks := A[j]; end; end; {pertukaran maks dengan A[i]} temp := A[i]; A[i] := maks; A[imaks] := temp; end; {menampilkan data setelah proses pengurutan} Writeln; Writeln('Data setelah diurutkan'); For i := 1 to N do begin Writeln('A[', i, '] = ', A[i]); End; End.

Kinerja selection sortDibanding pengurutan apung (bubble sort) pengurutan seleksi memiliki kinerja lebih baik.Karena, pertukaran elemen hanya dilakukan sekali setiap pass (seleksi).Sehingga lama pengurutannya berkurang dibanding pengurutan gelembung (bubble sort).

Pengurutan sisip (insertion sort)Adalah metode pengurutan dengan cara menyisipkan elemen larik pada posisi yang tepat.Pencarian posisi yg tepat dilakukan dengan menyisir larik (array).Selama penyisiran dilakukan pergeseran elemen larik.

Metode penyusutan ini cocok untuk persoalan menyisipkan elemen baru ke dalam sekumpulan elemen larik yg sudah terurut.

Algoritma pengurutan Sisip (insertion sort)Deklarasi :I : integer { pencacah pass (melewati 1 kali larik) }J : integer { pencacah untuk penelusuran/penyisiran larik }Y : integer { peubah bantu agar A[k] sebagai posisi yg tepat untuk disisipkan tidak ditimpa selama pergeseran} Ketemu : boolean { untuk menyatakan posisi penyisipan ditemukan }

Algoritma :{ elemen A[1] dianggap sudah terurut}For I 2 to n do { mulai dari pass 2 sampai pass N } y A[i] { cari posisi yg tepat untuk y di dalam A[1..i-1] sambil menggeser } j j -1 ketemu false

while ( j 1 ) and (not ketemu) do if y < A[j] then A[ j + 1] A [ j ] { geser } j j 1 else ketemu true endif endwhile { J < 1 or ketemu } A[ j + 1 ] y { sisipkan y pada tempat yang sesuai }

endfor

Contoh :Diketahui Larik dengan n=5 dibawah ini yg belum terurut, larik (array) ini akan diurut menaik (Ascending) dengan metode pengurutan sisip (insertion sort) :

Langkah - langkah:Asumsikan : elemen y = A[1] = 29 dianggap sudah terurutPass 2 : ( I = 2)Y = 27 (angka yg akan disisipkan)J = i-1 (mulai penyisiran)J = 2-1= 1Y < A[J] (bandingkan)27 < 29 yesA[J+1] = 29 (geser)A[2] = 29J = J 1 ( penyisiran )J = 1-1 = 0 (batas penyisiran) A[j+1] = y A[1] = 27 (menempatkan angka yg akan disisipkan di tempat yg sesuai)Hasil sortir setelah Pass 2 adalah:

Langkah langkah - next: Pass 3 : ( I = 3)Y = 10 (angka yg akan disisipkan)J = i-1 (mulai penyisiran)J = 3-1= 2Y < A[J] (bandingkan)10 < 29 yesA[J+1] = A[j] (geser)A[3] = A[2]A[3] = 29J = J 1 ( penyisiran )J = 2-1 = 1Y < A[j] (bandingkan)10 < A[1]10 < 27 yes A[j+1] = A[j]A[2] =A[1]A[2] = 27J = j 1 (penyisiran)J = 1 1 = 0 (batas penyisiran)A[j+1] = y A[1] = 10 (menempatkan angka yg akan disisipkan di tempat yg sesuai)

Langkah langkah - next: Pass 4 : ( I = 4)Y = 8 (angka yg akan disisipkan)J = i-1 (mulai penyisiran)J = 4-1= 3Y < A[J] (bandingkan)8 < 29 yesA[J+1] = A[j] (geser)A[4] = A[3]A[4] = 29J = J 1 ( penyisiran )J = 3-1 = 2Y < A[j] (bandingkan)8 < A[2]8 < 27 yes A[2+1] = A[2]A[3] =A[2]A[2] = 27J = j 1 (penyisiran)J = 2 1 = 1Y < A[j] (bandingkan)8 < A[1]8 < 10 yesA[J+1] = A[j] (geser)A[2] = A[1]A[2] = 10J = j 1 (penyisiran) J = 1 1 = 0 (batas penyisiran)A[j+1] = y A[1] = 8 (menempatkan angka yg akan disisipkan di tempat yg sesuai)

Langkah langkah - next: Pass 5 : ( I = 5)Y = 76 (angka yg akan disisipkan)J = i-1 (mulai penyisiran)J = 5-1= 4Y < A[J] (bandingkan)76 < 29 noKetemu = true (posisi penyisipan ditemukan)L[j+1] = yA[5] = 76 (menempatkan angka yg akan disisipkan di tempat yg sesuai)

Kinerja insertion sort Banyaknya operasi pergeseran yg diperlukan dalam mencari posisi yg tepat untuk elemen larik.(kelemahan)Pengrutan sisip kurang bagus untuk larik yg berukuran besar atau volume data yg besar.Metode penyusutan ini cocok untuk persoalan menyisipkan elemen baru ke dalam sekumpulan elemen larik yg sudah terurut.

Arsip Beruntun (Sequential File)Pendahuluan :Rekaman atau record adalah data yang bertipe samaMisalnya : ada beberapa data yg terdiri dari bagian-bagian tertentu seperti data nilai mahasiswa pada satu mata kuliah yg terdiri dari NIM, NAMA, NILAI

Contoh :

Gambar di atas ada tiga buah rekaman yg memiliki kolom nim, nama, dan nilaiSebuah baris dari setiap kolom disebut dg rekaman (record).Dalam sebuah arsip beruntun (sequential file) biasanya terdiri dari banyak rekaman.Sebuah rekaman (record) dapat terdiri dari beberapa kolom data tergantung dari kebutuhan.

Pengertian Arsip Beruntun (Sequential File)Adalah sebuah arsip (file) yang berisi kumpulan rekaman (record) dengan kolom-kolom data tertentu sesuai dg kebutuhan.Dalam arsip beruntun nama-nama kolom tidak ikut disimpan di dalam fileFile hanya berisi kumpulan rekaman saja

Contoh :

EOF (end of file) : akhir dari sebuah file (contoh : xxxxxxx xxx x). Merupakan akhir dari sebuah arsip (File).Rekaman penanda akhir file disebut dg dummy artinya elemen data yg ditambahkan tapi sebenarnya bukan bagian dari data.Dummy biasa digunakan untuk memudahkan suatu proses.

Operasi pada Arsip BeruntunPada dasarnya Arsip beruntun adalah file yg dapat ditulisi untuk menyimpan data.Operasi yg dilakukan terhadap file yaitu : - menulisi file dan membaca file.

Membuat Arsip BeruntunYg perlu diperhatikan untuk membuat sebuah arsip beruntun adalah :Menulis rekaman yg ingin ditulis( sebuah arsip beruntun yg tidak kosong harus berisi satu atau lebih rekaman yg memiliki tipe nilai sama).Menulis rekaman dummy sebagai akhir pembacaan.Jika sebuah arsip beruntun diangap sebagai arsip kosong maka minimal ada satu buah rekaman dummy sebagai akhir rekaman.

Pendeklarasian Arsip dalam AlgoritmaSebelum melakukan pemrosesan arsip beruntun, arsip tersebut harus dideklarasikan terlebih dahulu.

DEKLARASI arsip : file of tipe rekaman Tipe rekaman dapat berupa tipe dasar (integer, real, char, boolean, string) atau tipe terstruktur (record).Setiap rekaman di dalam arsip beruntun harus bertipe sama, baik tipe dasar maupun tipe betukan.

Tipe bentukan :

DEKLARASI type nama tipe arsip : file of tipe rkaman arsip : nama tipe arsip

Contoh-contoh pendeklarasian arsip beruntunArsip (file) Bil yg berisi sekumpulan bilangan bulat.Setiap rekaman adalah bilangan bulat DEKLARASI Bil : file of integer

Contoh-contoh pendeklarasian arsip beruntun - nextArsip Mhs yg berisi data mahasiswa (nim, nama, nilai).Setiap rekaman di dalam arsip Mhs bertipe terstruktur (record).

DEKLARASI { tipe rekaman} Type Datamhs : record < nim : integer nama : string nilai : char > { arsip } Mhs : file of Datamhs

Fungsi Pustaka untuk arsip beruntunUntuk pemrosesan arsip perlu mendefinisikan beberapa intruksi baku (fungsi yg sudah tersedia).Instruksi baku itu dinyatakan sebagai fungsi/prosedur pustaka (library function).Sejumlah intruksi baku untuk pemrosesan arsip beruntun adalah: open, fread, fwrite, close, eof.

openFungsi :Membuka asip beruntun untuk siap dibaca/ ditulis.Setelah memanggil fungsi ini, penunjuk arsip (file pointer) akan menunjuk ke karakter pertama di awal arsipSebuah arsip beruntn yg dibuka (open) hanya bisa untuk masukan (dibaca) saja atau sebagai keluaran (ditulis) saja, tidak sekaligus keduanya (dibaca dan ditulis).

Contoh : open(Mhs, 1) { arsip Mhs dibuka untuk dibaca } open(Bil, 2) { arsip Bil dibuka untuk ditulis } open(Kar, 1) { arsip Kar dibuka untuk dibaca }

FreadFungsi :Membaca rekaman yang sekarang sedang ditunjuk oleh pointer.Contoh : Fread(Mhs, RekMhs) { RekMhs bertipe DataMhs } Fread(Bil, I) { I bertipe integer } Fread(Kar, ch) { ch bertipe karakter }

Andai pointer pembacaan sekarang sedang menunjuk ke awal rekaman ke-2, maka hasil perintah Fread adalah : RekMhs berisi

Selanjutnya, pointer akan menunjuk ke awal rekaman ke-3, dan siap untuk membaca rekaman tersebut.

FwriteFungsi :Menulis rekaman ke dalam arsip beruntun.Contoh :RekMhs.Nim 456087RekMhs.Nama AndiRekMhs.Nilai AFwrite(Mhs, RekMhs) {simpan RekMhs ke arsip Mhs}

Fwrite(Bil, 765) {menuliskan nilai 765 ke arsip Bil}Fwrite(Kar, B) { menuliskan karakter B ke arsip Kar }

CloseFungsi :Menutup Arsip yang sudah dibuka.

Contoh : close(Mhs) { menutup arsip Mhs } close(Bil) close(Kar)

Arsip sudah ditutup, tidak dapat diproses lagi.

EOF (end of file)Fungsi :Mendeteksi akhir arsip.

Membuat Arsip BeruntunArsip hanya dapat diproses jika sudah terdefinisi isinya.Langkah pembuatan arsip beruntun :Menyiapkan arsip untuk perekaman (menggunakan perintah open dg kode=2)Membaca data yg akan direkam (misalnya dari piranti masukan (keyboard))Menuliskan data tersebut ke dalam arsip (perintah Fwrite).Jika sebuah arsip sudah selesai diisi, arsip tersebut ditutup dengan perintah Close

Contoh Algoritma membuat arsip beruntunProgram BuatArsipBilanganBulat{ contoh program yg memperagakan ara menyimpan data ke dalam arsip, data dibaca dari papan ketik, tanda akhir arsip adalah 9999}DEKLARASI Bil : File of integer {arsip bilangan bulat}N : integer {banyaknya bilangan bulat}I : integer { pencacah penguangan }X : integer { variabel bilangan bulat yg dibaca dari keyboard}ALGORITMA : open(Bil, 2) {buka arsip Bil untuk perekaman} read(n)For I 1 to n do read(x) Fwrite(Bil, x) { rekam bilangan bulat ke arsip Bil }

EndforClose(Bil) {tutup arsip Bil}

Contoh Algoritma membuat arsip beruntun - nextProgram BuatArsipMahasiswa{ mebuat arsip data mahasiswa, data mahasiwadari papan ketik, pembacaan data diakhiri bila NIM yg dimasukkan adalah 9999}

DEKLARASIType DataMhs : record Msiswa : DataMhs { variabel untuk menampung pembacaan data mahasiswa}

Mhs : file of DataMhs { arsip data mahasiswa } ALGORITMA : open(Mhs, 2) {buka arsip Mhs untuk perekaman} read(Msiswa.NIM) { baca NIM mahasiswa pertama, mungkin 9999}

While (Msiswa.NIM 9999) do read(Msiswa.Nama, Msiswa.Nilai) Fwrite(Mhs, Msiswa) { rekam Msiswa ke dalam arsip Mhs } read(Msiswa.NIM)Endwhile{ Msiswa.NIM = 9999}Close(Mhsl) {tutup arsip Mhs}

Membaca Arsip beruntunLangkah-langkah :Menyiapkan arsip untuk pembacaan (perintah Open dengan kode=1).Setiap kali akan membaca suatu rekaman (record) harus dipastikan bahwa tanda akhir arsip (eof) belum dicapai.Rekaman (record) dibaca satu per satu dari rekaman pertama hingga rekaman yg diinginkan atau seluruh rekaman selesai dibaca.Karena jumlah data dalam arsip tidak diketahui, maka gunakanlah konstruksi while-do

Skema umum membaca arsip beruntunProgram pembacaan arsipDEKLARASI : type rekaman : TipeRekaman Arsip : file of rekaman rek : rekamanAlGORITMA:InisialisasiOpen(Arsip, 1) {buka arsip untuk dibaca}

While not EOF(arsip) do fread(Arsip, rek) proses rekEndwhile { EOF(arsip) }TerminasiClose(arsip)

Contoh : pembacaan data dari arsipPROGRAM BacaArsipBilanganBulatDEKLARASI : bil : File of integer x : integer { peubah rekaman }ALGORITMA : open(bil, 1) {baca arsip bil untuk pembacaan} while not EOF(bil) do fread(arsip, x) {baca rekaman pertama} Write(x) endwhile { EOF(bil) }Close(bil) {tutup arsip bil}

Contoh pembacaan : menghitung jumlah mahasiswa yang mempunyai IP > 2.0PROGRAM BacaArsipIPDEKLARASI :Type DataMhs : record RekMhs : DataMhsMhs : File of DataMhsJumlah : integer {variabel (peubah) untuk menampung jumlah IP >2.0}ALGORITMA : jumlah 0 open(Mhs, 1) {buka arsip Mhs untuk pembacaan} while not EOF(mhs) do fread(Mhs, RekMhs) { baca data }

if RekMhs.IP > 2.0 then Jumlah Jumlah + 1 endif endwhile { EOF (Mhs) }Close(Mhs) { tutup arsip Mhs}

Contoh pembacaan : mencari data mahasiswa yg mempunyai IP tertinggi PROGRAM cariIPTertinggiDEKLARASI :Type DataMhs : record RekMhs : DataMhsMhs : File of DataMhsMaks : real {variabel (peubah) untuk menampung IP tertinggi}ALGORITMA : Maks -9999 open(Mhs, 1) {buka arsip Mhs untuk pembacaan} while not EOF(mhs) do fread(Mhs, RekMhs) { baca data } if RekMhs.IP > maks then maks RekMhs.IP endif endwhile { EOF (Mhs) }Close(Mhs) { tutup arsip Mhs}{cetak data mahasiswa yang mempunyai IP tertinggi} Write(NIM :, RekMhs.NIM) Write(NAMA :, RekMhs.Nama) Write(IP :, RekMhs.IP)

Manyalin Arsip (file)Menggandakan Arsip (file) backup filePenyalian (copy) dapat dilakukan terhadapseluruh rekaman (record) atau hanya rekaman (record) tertentu saja.

Menyalin seluruh rekamanALGORITMA :Open (Mhs1, 1) { buka arsip Mhs1 untuk pembacaan } Open (Mhs2, 2) { buka arsip Mhs2 untuk penulisan }

While not EOF(Mhs1) do fread(Mhs1, RekMhs) { baca rekaman dari arsip Mhs1 } Fwrite(Mhs2, RekMhs) { salin Rekmhs ke arsip Mhs2}Endwhile

Close(Mhs1)Close(Mhs2)

Menyalin sebagian data dari arsip(menyalin data mahasiswa yang IP-nya di atas 2.0ALGORITMA :Open (Mhs1, 1) { buka arsip Mhs1 untuk pembacaan } Open (Mhs2, 2) { buka arsip Mhs2 untuk penulisan } While not EOF(Mhs1) do fread(Mhs1, RekMhs) { baca rekaman dari arsip Mhs1 } if RekMhs.IP > 2.0 then Fwrite(Mhs2, RekMhs) { salin Rekmhs dg IP > 2.0 ke arsip Mhs2} endifEndwhileClose(Mhs1)Close(Mhs2)

Manggabung (merge) dua ArsipMenyalin isi dua buah arsip ke dalam sebuah arsip baruDilakukan dg cara penyambungan (concatenation), yaitu menyalin isi arsip yg kedua setelah isi arsip pertama.

Contoh :

Algoritma Penggabungan ArsipALGORITMA : Open(Mhs1, 1) Open(Mhs2, 1) Open(Mhs3, 2)While not EOF(Mhs1) do fread (Mhs1, RekMhs) Fwrite(Mhs3, RekMhs)Endwhile

While not EOF(Mhs2) do fread(Mhs2, RekMhs) fwrite(Mhs3, RekMhs)EndwhileClose(Mhs1)Close(Mhs2)Close(Mhs3)

Penerapan dg Pascal (cari IP tertinggi dalam Arsip)Program CariIPTertinggi;Uses wincrt; Type DataMhs : record NIM : integer; Nama : string; IP : real; end;varRekMhs : DataMhs;mRekMhs : DataMhs;Mhs : File of DataMhs;Maks : real;Begin assign(Mhs, data.dat); rewrite(Mhs); write(NIM : ); readln(RekMhs.NIM); while (RekMhs .nim 9999) do begin write(Nama :); readln(RekMhs.nama); write(IP :); readln(RekMhs.IP); write(Mhs, RekMhs); write(NIM :); readln(RekMhs.NIM); end; close(Mhs);Assign(Mhs, data.dat); reset(Mhs);Maks :=0.0;While not EOF(Mhs) do begin read(Mhs, RekMhs); if RekMhs.IP > maks then begin maks :=RekMhs.IP; mRekmhs := RekMhs; end; end;Close(Mhs); { tutup arsip Mhs}{cetak data mahasiswa yang mempunyai IP tertinggi}Assign(Mhs, data.dat);Reset(Mhs); Write(NIM :, mRekMhs.NIM); Write(NAMA :, mRekMhs.Nama); Write(IP :, mRekMhs.IP:4:2);Close(mhs);end.

Tugas dikumpulkan minggu depan (29 Juni 2011)Buatlah Algoritma lengkap untuk penggabungan 2 buah Arsip (File) data Mahasiswa dengan ketentuan :Arsip (File) pertama berisi 5 Rekaman (record).Arsip (File) kedua berisi 3 rekaman (record)Data Mahasiswa tersebut terdiri dari NIM, NAMA dan IPKArsip (File) Gabungan disimpan pada Arsip (File) ketigaBuatlah Program Komputer dengan Bahasa Pascal untuk Algoritma di atas.

**dada*dada*dada*dada****Antar nilai dipisah dg space, antar rekaman dipisah dengan new line