PEMROGRAMAN MODULAR

adalah 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
PROGRAM A
SUBPROGRAM A1 SUBPROGRAM A2 SUBPROGRAM A3
SUBPROGRAM A21 SUBPROGRAM A22
ILUSTRASI
DEKLARASI
A, B, Temp : integer
ALGORITMA
{ 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 subprogram
DEKLARASI
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 FUNGSI
Struktur setiap subprogram tersebut pada
hakekatnya sama , yaitu :
Nama modul (subprogram)
Bagian deklarasi
Algoritma (intruksi yg akan dilaksanakan)
Perbedaan penggunaannya dalam bahasa
pemrograman Pascal :
Prosedur merupakan modul(subprogram) yg
melakukan aktifitas tertentu tanpa adanya
pengembalian nilai
Fungsi terdapat pengembalian nilai




PROSEDUR
Dalam bahasa pemrograman
Prosedur 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 PROSEDUR
JUDUL (header) nama prosedur dan
deklarasi parameter(kalau ada)
DEKLARASI mengumumkan nama-
nama dan tipe data
ALGORITMA badan prosedur
(instruksi)


*sama dengan struktur ALGORITMA

Nama Prosedur
Nama yang unik
Sebaiknya diawali dengan kata kerja
karena prosedur berisi suatu aktifitas
Misalnya: HitungLuas, Tukar, CariMaks,
Tulis, dll.
Parameter
Adalah 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
PROSEDUR
Procedure 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 keharusan
Contoh :
Procedure HitungLuasSegitiga
{menghitung luas segitiga dengan rumus : L = (alas x tinggi)/2}
{K.awal : sembarang}
{K.akhir : luas segitiga tercetak}
DEKLARASI
Alas, tinggi, luas : real
ALGORITMA
Read(alas, tinggi)
Luas (alas * tingg) / 2
Write(luas)

Pemanggilan Prosedur
Prosedur bukan program yg beridiri sendiri
Prosedur 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}
DEKLARASI
Alas, tinggi, luas : real
ALGORITMA
Read(alas, tinggi)
Luas (alas * tinggi) / 2
Write(luas)
ALGORITMA
HitungLuasSegitiga


KUIS
BUATLAH NOTASI ALGORITMA UNTUK
MELAKUKAN PEMANGGILAN
PROSEDUR LUASSEGITIGA
SEBANYAK 3 X
Nama Global dan Nama Lokal
Nama 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 GLOBAL
Nama Peubah (variabel) luas variabel LOKAl
PROGRAM 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}
DEKLARASI
luas : real
ALGORITMA
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 Lokal
Bila 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 mungkin
Penggunaan variabel lokal membuat program
lebih elegan
Penggunaan variabel lokal dapat
meminimumkan usaha pencarian kesalahan yg
disebabkan oleh nama-nama tsb.


Parameter
Prosedur 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 - next
Penggunaan 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 - next
Ketika prosedur dipanggil, parameter
aktual berkoresponden satu-satu dengan
parameter formal (parameter yg
dideklarasikan pada bagian header
prosedur)
Aturan korespondensi satu satu
Jumlah 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 masukan
Nilai 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 masukan
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}
DEKLARASI
luas : real
ALGORITMA
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}
DEKLARASI
luas : real
ALGORITMA
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 nilainya
PROGRAM 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}
DEKLARASI
luas : real
ALGORITMA
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 konstanta
Contoh :

HitungLuasSegitiga(a*0.2, t*0.1)

HitungLuasSegitiga(12, 6)
Parameter keluaran
Parameter keluaran dideklarasikan di dalam
header prosedur, sebagaimana parameter
masukan
Parameter 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-next
PROGRAM 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) / 2
ALGORITMA
read(N) { tentukan banyaknya segitiga }
for I 1 to N do
read(a, t)
HitungLuasSegitiga(a, t, L)
Write(L)
endfor

Parameter masukan/keluaran
Prosedur harus dapat mengakomodasi baik
masukan dari dan keluaran ke blok program
pemanggil
Maka gunakan parameter masukan/ keluaran
Bila parameter aktual diubah nilainya di dalam
badan prosedur, maka sesudah pemanggilan
prosedur nilai parameter aktual di titik
pemanggilan juga berubah
Parameter masukan/keluaran dideklarasikan di
dalam header prosedur dengan keyword
INPUT/OUTPUT
Parameter aktual harus berupa peubah, tidak
boleh berupa ekspresi atau konstanta
Contoh : parameter masukan/keluaran
PROGRAM 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 xyz
DEKLARASI
a, b : integer
Procedure tambah(input x,y:integer)
Deklarasi
Algoritma
x x + 4
Y y +4
write(nilai x dan y di akhir prosedur
tambah:)
Write( x=, x)
Write( y=, y)
ALGORITMA
a 15
B 10
Write(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 xyz
DEKLARASI
a, b : integer
Procedure tambah(input/output
x,y:integer)
Deklarasi
Algoritma
x x + 4
Y y +4
write(nilai x dan y di akhir prosedur
tambah:)
Write( x=, x)
Write( y=, y)
ALGORITMA
a 15
B 10
Write(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 prosedur
Dianjurkan menulis program yg modular
Program yg dipecah menjadi beberapa
prosedur menunjukkan teknik
pemrograman yg baik dan terstruktur

Prosedur dg parameter atau
tanpa parameter
Dianjurkan menulis prosedur dg parameter
Parameter dapat mengurangi kebutuhan
penggunaan peubah (variabel) global
Parameter masukan atau
parameter keluaran
Bila 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 detik
1. Tambah detik dengan 1, jika jumlah detik <60, tetapi jika
jumlah detik = 60 maka set detik kembali menjadi nol(0)
dan tambahkan 1 ke menit.
2. pertambahan menit dengan 1,jika jumlah menit <60,
tetapi jika jumlah menit = 60, maka set menit kembali
menjadi 0(nol) dan tambahkan 1 ke jam.
3. Pertambahan jam dengan 1, jika jumlah jam <24, tetapi
jika jumlah jam = 24, maka set jam kmbali menjadi
0(nol).
Contoh :
14:27:31 +1detik 14:27:(31+1)=14:27:32
15:36:59 +1detik 5:36:(59+1)=15:(36+1):00=15:37:00
10:59:59 +1deti 10:59+(59+1)= 10:(59+1):00
=(10+1):00:00=11:00:00
23:59:59 +1detik 00:00:00

Notasi Algoritma: menentukan jam berikutnya
Program jamberikutnya
Deklarasi
Type jam : record <hh:integer {0..23}
mm:integer {0..59}
ss : integer {0..59}
J :jam
ALGORITMA
Read(j.hh, j.mm, j.ss) {baca jam}
if J.ss +1 < 60 then
J.ss j.ssm +1
else
J.ss 0
if J.mm + 1 < 60 then
J.mm J.mm + 1
else
J.mm 0
If J.hh + 1 < 24 then
J.hh J.hh + 1
else
j.hh 0
endif
endif
endif
Write(J.hh, J.mm, J.ss) {jam yang baru}





Notasi Algoritma : mencetak perjalan waktu terus menerus
dg prosedur paramater masukan/keluaran
Program 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}
Deklarasi
Type jam : record <hh:integer {0..23}
mm:integer {0..59}
ss : integer {0..59}
J :jam
Procedure JamBerikutnya(input/output J : Jam)
{Menaikkan jam J dengan satu detik }
ALGORITMA
Read(J.hh, J.mm, J.ss) {baca jam awal}
Repeat
write(J.hh, J.mm, J.ss) {cetak jam sekarang}
JamBerikutnya(J)
Until (J.hh = 0) and (J.mm =0) and (J.ss = 0)
write(J.hh, J.mm, J.ss) {cetak jam 00:00:00}
FUNGSI
Sub Program yg mempunyai tujuan/tugas
spesifik
Fungsi dan prosedur adalah merupakan
sub program yang ekivalen
Dalam beberapa masalah penggunaan
salah satunya adalah hal yg lebih tepat.
FUNGSI-next
Adalah 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) = 2X
2
+ 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*2
2
+ 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 - next
Parameter pada fungsi disebut juga
dengan parameter formal
Parameter 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 - next
Struktur 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 fungsi
Function 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 INPUT
Ekspresi : dapat berupa konstanta, peubah(variabel) atau sebuah rumus
Struktur fungsi
Fungsi untuk menghasilkan nilai f(x)=2x
2
+5x-8, x R


Function f(input x : real) real
{mengembalikan nilai f(x) = 2x
2
+5x-8, x R
Deklarasi
{ 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
Kuis
Buatlah contoh fungsi untuk meghitung
nilai dengan dua parameter formal dengan
tipe bilangan bulat
Fungsii untuk menentukan bilangan genap
atau ganjil
Function 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 peubah
Function NamaHari(input har :
integer) string
{ mengembalikan nama hari
berdasarkan nomor har}
DEKLARASI
nama : string
Algoritma:
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 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)
Pemanggilan FUNGSI
Fungsi di akses dengan cara memanggil
namanya diikuti dengan parameter aktual
(kalau ada)

Peubah NamaFungsi(parameter aktual, jika ada)
Pemanggilan FUNGSI : next
Karena fungsi menghasilkan nilai, maka:
Nilai yang dikembalikan oleh fungsi ditampung di
dalam sebuah peubah (variabel) yng bertipe sama
dengan tipe fungsi
Contoh : 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 fungsi
Untuk menampilkan tabel yang berisi nilai x dan f(x) di dalam
selang[10,15] dengan delta X =0.2 :
Dimana f(x)=2x
2
+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 - next
Program 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)=2x
2
+5x-8, x R}
Deklarasi
{tidak ada }
Algoritma
return 2*x*x + 5*x 8
Algoritma:
{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 - next
Program 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 FUNGSI
FUNGSI digunakan apabila modul
program mengembalikan sebuah nilai
PROSEDUR 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)integer
Deklarasi
Algoritma
if a b then
return a
else
return b
endif
Prosedur

Function TentukanMaks(input
a,b:integer, output maks
:integer)
Deklarasi
Algoritma
if a b then
maks a
else
maks b
endif

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 : integer
Algoritma:
jumlah 0
for I 1 to Ndata do
read (x)
jumlah jumlah + x
endfor

U jumlah/Ndata
Fungsi

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

return jumlah/Ndata

Rekursif
Fungsi Rekursif
Fungsi 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 REKURSIF
Suatu proses dari suatu subprogram
(prosedur atau fungsi) yang memanggil
dirinya sendiri

Proses rekursif
Suatu 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 rekursi
Kondisi akhir diperlukan untuk mencegah terjadinya proses rekursif
yg tidak akan ada hentinya (proses rekursif akan berjalan terus
menerus tanpa berhenti).

Contoh:
Procedure rekursif
Deklarasi
Algoritma:
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 rekursif
Deklarasi
Algoritma:
If batas < 7 then
Write (Informatika UHAMKA)
Batas batas + 1
Rekursif
endif

Notasi algoritma :
Program rekursi
Deklarasi
Batas : word
Prosedur rekursif
Deklarasi
Algoritma:
If batas < 7 then
Write(Informatika UHAMKA)
Batas batas + 1
Rekursif
Endif
Algoritma:
Batas 0
Rekursif

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

Prosedur deret(input n word)
Deklarasi
Algoritma:
Write(N:3)
If N < 10 then
Deret(N+1)
endif

Program urut
Deklarasi
N:word
Prosedur deret(input n
word)
Deklarasi
Algoritma:
Write(N:3)
If N < 10 then
Deret(N+1)
endif
Algoritma:
N 0
Deret(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 selesai
2. 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 x
y
, kita tahu bahwa semua
bilangan selain 0, jika dipangkatkan dengan 0 nilainya
sama 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:

x
y
= 1, jika y=0
x
y
= x * x
y-1
, jika y > 0
Kita lihat di atas pada definisi y > 0, bentuk
pemangkatan muncul kembali di sisi kanan. Itulah yang
disebut 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 x
y
adalah 1.
Untuk x = 10 dan y = 3 hasilnya dapat
digambarkan sebagai berikut:



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



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

Algoritma:

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

Pangkat dalam Bahasa Pascal
program 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 rekursif
Deklarasi
Algoritma:
Write(Informatika UHAMKA)
rekursif

Program rekursi
Deklarasi
Batas : word
Prosedur rekursif
Deklarasi
Algoritma:
If batas < 7 then
Write(Informatika
UHAMKA)
Batas batas + 1
Rekursif
Endif
Algoritma:
Batas 0
Rekursif

Program urut
Deklarasi
N:word
Prosedur deret(input n
word)
Deklarasi
Algoritma:
Write(N:3)
If N < 10 then
Deret(N+1)
endif
Algoritma:
N 0
Deret(N)

Menghitung nilai FAKTORIAL
Faktorial (0) = 1 : Nilai awal
Faktorial (n) = n * faktorial(n-1) : Rekurent
faktorial (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 <= 0 then return 1
else
return nilai*faktorial (nilai-1)
endif



Menghitung nilai FAKTORIAL-dalam bahasa PAscal

function faktorial (nilai : integer) : integer;
begin
if nilai <= 0 then faktorial := 1
else faktorial := nilai * faktorial (nilai-1)
end;

Var
N : integer;
Begin
Write(Berapa faktorial ? );
Readln(N);
Writeln(N, faktorial = ,faktorial(N));
End.


Pseudo-code - Bahasa Pascal
function faktorial (input nilai :
integer) : integer

DEKLARASI

ALGORITMA:
if nilai <= 0 then return 1
else
return nilai*faktorial (nilai-1)
endif

function faktorial (nilai : integer) :
integer;

begin
if nilai <= 0 then
faktorial := 1
else
faktorial := nilai*faktorial (nilai-1)
end;



Proses hitung faktorial dengan Prosedur
program rekursiffaktorial;

uses wincrt;

var
n:byte;
f:longint;

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

if n <= 1 then
hasil:=1
else
begin
faktorial(n-1, hasil);
hasil:= N*hasil;
end;
end;
begin
write('Faktorial yg dihitung ?'); readln(N);
faktorial(N,f);
writeln('faktorial ',N,' adalah:', f);
end.
Fungsi - Prosedur
function faktorial (nilai : integer) :
integer;
begin
if nilai <= 0 then faktorial := 1
else faktorial := nilai * faktorial
(nilai-1)
end;

Var
N : integer;
Begin
Write(Berapa faktorial ? );
Readln(N);
Writeln(N, faktorial = ,faktorial(N));
End.

procedure faktorial(N:byte; var
hasil:longint);
begin
if n <= 1 then
hasil:=1
else
begin
faktorial(n-1, hasil);
hasil:= N*hasil;
end;
end;
begin
write('Faktorial yg dihitung ?');
readln(N);
faktorial(N,f);
writeln('faktorial ',N,' adalah:', f);
end.

Barisan FIBONANCI
Barisan 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)
Endif
endif
Bahasa pascal
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;

Pseudo-code - Bahasa Pascal
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)
Endif
endif

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;

Latihan
1. Buat Algoritma untuk menghitung
deret S = 1+2+3+4+5+...+n menggunakan
function rekursif
2. Buatkanlah 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 integer
A adalah nama array
Definisi Array
Adalah 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


A
I
n
d
e
k
s


A
1 1
158
2 2
157
3 3
162
4 4
170
5 5
163
Elemen Array kosong Elemen Array yg sudah
disi nilai
A[1], A[2], A[3], A[4], A[5]

Variabel array vs variabel biasa
Variabel array Variabel biasa
Dapat 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 : integer
A2 : integer
A3 : integer
A4 : integer
A5 : integer
Deklarasi Array
Sesuatu 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 -next
Array dari tipe data dasar :
DEKLARASI :
A : array[1.50] of integer
NamaMhs : array[1..10] of string
NilaiUjian : array[1..75} of real
Sebagai 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 -next
Sebagai sebuah konstanta :
Mendefinisikan ukuran array (larik) sebagai
sebuah konstanta
DEKLARASI:
Const max= 10
N: array[1..max] of real
I: integer
ALGORITMA :
For i:=1 to max do
read(n[i])
Endfor
Deklarasi Array -next
Sebagai 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 = 100
Type Mahasiswa : record<
NIM : integer
NAMA : String
IPK : real >
Type tabmhs : array[1..maks] of mahasiswa
Mhs : 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 102131002
Mhs{i].NAMA BUDI UTOMO
Mhs[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 A
NamaMhs[2] mengacu elemen ke 2 dari larik namaMhs
A[i] mencau elemen ke-I dari larik A, asalkan nilai I sudah
terdefinisi.
Memanipulasi elemen array (larik) :
A[4] 10
NamaMhs[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= 10
Type LarikInt : array[1..max] of integer

A : LarikInt
I: 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 :
Contoh
A[i] 10
Inisialisasi :
For I 1 to n do
A[i] I
Endfor

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/dipakai
Jumlah 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) :
1. Jika Jumlah elemen efektif ditentukan di
awal
2. Jika Jumkah elemen efektif diketahui di
akhir pembacaan
3. Jika Jumlah elemen efektif baru
diketahui di akhir pembacaan (variasi
dari versi 2)


Jumlah elemen efektif ditentukan di awal
Procedure 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}
DEKLARASI
Jawab : char
ALGORITMA
N 0
Repeat
n n + 1
Read(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.}
DEKLARASI
x : 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-rata
Data yang sudah disimpan di dalam Larik, selanjutnya
data tersebut dapat dimanipulasi


Procedure hitungRataRata(input A:Larikint, input n:integer)
DEKLARASI
I : integer
Jumlah : real
ALGORITMA
I 1 {dimulai dari elemen pertama}
Jumlah 0 {jumlah total nilai mula mula}
For i 1 to n do
jumlah jumlah + A[i]
Endfor
U jumlah/n

Notasi Algoritma hitung rata rata
PROGRAM Rerata

DEKLARASI
const
NMaks = 100
type
LarikInt : array[1..NMaks] of integer
A : LArikInt
n : integer
u : 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}

ALGORITMA
read(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.
latihan
Buatlah 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 konstan
Program 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.
A 158 157 162 169 172 155 170 163
Tiga versi algoritma
untuk mencari nilai maksimum
Cara 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
A
`
158 157 162 169 172 155 170 163
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 berubah
A[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 berubah
A[7] > maks? tidak maks tidak berubah
A[8] >maks? Tidak maks tidak berubah

(proses pembandingan selesai)
Didapat : maks = 172 (nilai maksimum array yang ditemukan)
Algoritma untuk maks = -999
Program NilaiMaksimum
DEKLARASI :
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 Maksimal
1. Nilai maksimum sementara diinisialisasikan dengan
elemen pertama array.
2. selanjutnya, arrray dikunjungi mulai dari elemen kedua
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 sementara menjadi nilai
maksimum sebenarnya.
Ilustrasi untuk maks : elemen pertama
A
`
158 157 162 169 172 155 170 163
1 2 3 4 5 6 7 8

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

A[2] >maks? Tidak maks tidak berubah
A[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 berubah
A[7] > maks? tidak maks tidak berubah
A[8] >maks? Tidak maks tidak berubah

(proses pembandingan selesai)
Didapat : maks = 172 (nilai maksimum array yang ditemukan)
Algoritma untuk maks = Elemen pertama
Program NilaiMaksumum
DEKLARASI :
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 Maksimal
Mencari 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)
A
`
158 157 162 169 172 155 170 163
B
`

1 2 3 4 5 6 7 8
1 2 3 4 5 6 7 8
Algoritma Menyalin Larik
Program Salin

DEKLARASI:
Const maks=100
A:array[1..maks] of integer
B:array[1..maks] of integer
I,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 Larik
Dilakukan dengan membandingkan setiap
elemen yang berpadanan pada ke dua
larik tersebut
Jika 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 - next
A
`
123 130 140 160 180
B
`
123 130 140 160 180
1 2 3 4 5
1 2 3 4 5
Algoritma menguji kesamaan larik
Program uji
DEKLARASI
Const 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 : integer
Sama : boolean
ALGORITMA:
I 1
Sama true
While (I maks) and (sama) do
if A[i] = B[i] then
I I + 1 {tinjau elemen berikutnya}
else
sama false
endif
Endwhile
{ 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)-next
Ketiga 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 Matriks
secara baris perbaris :







Algoritmanya :
N 1
I 1
While (i<=3)
J 1
While ( j<= 4)
A[i, j] N
N++
J++
Endwhile
I++
Endwhile
Pengisian semua elemen Matriks
secara kolom perkolom :













Algoritmanya :
X 1
N X
J 1
While (J <= 4)
i 1
While ( i <= 3)
A[i, j] N
N+4
i++
Endwhile
X++
NX
J++
Endwhile
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 1
While (i<=3)
J 1
While ( j<= 5)
Read(nilai)
A[i, j] nilai
J++
Endwhile
I++
endwhile
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<= 3 do
For j=1 to j <=4 do
B[i,j] A[i,j]
Endfor
Endfor
MENGHITUNG TOTAL ISI ARRAY DUA DIMENSI
Algoritmanya :
TOT 0
I 1
While (i<=3) do
J 1
While (J <= 4) do
TOT TOT + A[i,j]
J++
Endwhile
I++
Endwhile
Write (TOT )
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 1
While (i <= 3 ) do
J 1
While ( J <= 4 ) do
C[i,j] A[i,j] + B[i,j]
J++
Endwhile
I++
Endwhile
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 - next
Contoh :

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 Pencarian
Proses 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=-1
Nilai 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 :
1. Metode pencarian beruntun (sequantial
search)
2. 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 42
Pemeriksaaan dilakukan terhadap elemen 60, 12, 76, 23, 11, 42
(ditemukan)
Ternyata nilai ditemukan pada elemen ke 6 :
Indek larik yang dikembalikan : idx 6
Proses pencarian dihentikan.

Misalkan nilai yang dicari adalah 20
Pemeriksaan 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 -1
Proses pencarian dihentikan.
Dua Versi algoritma
pencarian 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 boolean
Prosedur :

Procedure cariberuntun(input
A:larikint, input n: integer, input
x:integer, output
ketemu:boolean)
Deklarasi :
I : integer
Algoritma :
I 1
While(i<n) and (A[i] x) do
I I +1
Endwhile
If A[i] = x then
ketemu true {x
ditemukan}
Else
ketemu false {x tidak ada
dalam larik A}
endif

Fungsi :

Function cariberuntun(input
A:Larikint, input n:integer, input
x :integer) boolean
Deklarasi:
I : integer
Algoritma:
I 1
While(i<n) and (A[i] x) do
I I +1
Endwhile
If A[i] = x then
return true {x ditemukan}
Else
return false {x tidak ada dalam
larik A}
endif

Algoritma lengkap u/ panggil prosedur : versi 1
Program Pencarian
Deklarasi:
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<n) and (A[i] x) do
I I +1
Endwhile
If A[i] = x then
ketemu true {x ditemukan}
Else
ketemu false {x tidak ada dalam larik A}
Endif
ALGORITMA :
read(n)
bacaLarik(A,, n)
read (x)
cariberuntun(A, n, x, found)
if found = true then
write(x, ditemukan)
else
write(x, tidak ditemukan)
endif


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 array
Prosedur :

Procedure cariberuntun(input
A:larikint, input n: integer, input
x:integer, output idx: integer)
Deklarasi :
I : integer
Algoritma :
I 1
While(i<n) and (A[i] x) do
I I +1
Endwhile
If A[i] = x then
idx i {x ditemukan}
Else
idx -1 {x tidak ada dalam
larik A}
endif

Fungsi :

Function cariberuntun(input
A:Larikint, input n:integer, input
x :integer) integer
Deklarasi:
I : integer
Algoritma:
I 1
While(i<n) and (A[i] x) do
I I +1
Endwhile
If A[i] = x then
return i {x ditemukan}
Else
return -1 {x tidak ada dalam
larik A}
endif

Kasus : versi 1
menambah (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 Tambahelemenlarik
Deklarasi:
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<n) and (A[i] x) do
I I +1
Endwhile
If A[i] = x then
idx i {x ditemukan}
Else
idx -1 {x tidak ada dalam larik A}
Endif
ALGORITMA :
read(n)
bacaLarik(A,, n)
read (x)
cariberuntun(A, n, x, idx)
if idx -1 then
write(x, sudah terdapat di dalam larik)
else
n n + 1 { naikkan ukuran larik }
A[n] x { tambahkan nilai x}
endif

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 ditemukan
Algoritma :
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 boolean
Prosedur :

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

Fungsi :

Function cariberuntun(input
A:Larikint, input n:integer, input x
:integer) boolean
Deklarasi:
I : integer
Algoritma:
Ketemu false
I 1
While(I n) and (not ketemu) do
if A[i] = x then
ketemu true {x ditemukan}
else
I I +1
endif
Endwhile
{ I > n or ketemu }
return ketemu
Algoritma versi 2: hasil pencarian sebuah indeks elemen larik
Prosedur :

Procedure cariberuntun(input A:larikint,
input n: integer, input x:integer,
output idx: integer)
Deklarasi :
I : integer
ketemu : boolean
Algoritma :
Ketemu false
I 1
While(I n) and (not ketemu) do
if A[i] = x then
ketemu true {x ditemukan}
else
I I +1
endif
Endwhile
{ 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)
integer
Deklarasi:
I : integer
ketemu : boolean
Algoritma:
Ketemu false
I 1
While(I n) and (not ketemu) do
if A[i] = x then
ketemu true {x ditemukan}
else
I i +1
endif
Endwhile
{ I > n or ketemu }
if ketemu true then
return 1
else
return -1
endif

Kinerja Algoritma
Pencarian Beruntun (Sequential search)
Data yg belum terurut :
Secara umum pencarian Lambat
Waktu pencarian sebanding dengan jumlah
elemen larik
Data yg sudah terurut :
Dapat meningkatkan kinerja pencarian
Karena 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
dua
Dalam proses pencarian diperlukan dua buah
indeks larik, yaitu indeks terkecil (indeks ujung
kiri larik) dan indeks terbesar (indeks ujung
kanan larik).

Langkah-langkah
pencarian bagidua
Misal indeks kiri = I, indeks kanan j :
1. Bagi dua elemen larik pada elemen tengah. Elemen
tengah adalah indeks k = ( I + j ) div 2
Elemen tengah A[k] membagi larik menjadi dua bagian :
bagian kiri A[i..k-1] dan
bagian kanan A[k+1..j]
2. 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 kanan
Jika A[k] < x, maka pencarian dilakukan pada larik sebelah
kanan
Jika A[k] > x, maka pencarian dilakukan pada larik sebelah kiri.
3. 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 <= idxakhir) do begin
K := (idxawal + idxakhir) div 2;
If A[k] = x then
Ketemu := true
else
If A[k] < x then
Idxawal := k+1
else
Idxakhir := k-1;
End;
{memeriksa, ketemu atau tidak }
If ketemu then
Writeln(x, 'ditemukan pada indeks ke-', k)
else begin
Writeln(x, ' tidak ditemukan');
End.

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

1. Dapat digunakan
baik untuk data yg
belum terurut
maupun data terurut
2. Kinerja lebih lambat

Binary Search

1. Hanya dapat
digunakan untuk
data yg terurut saja.

2. 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 N
A[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 elemen
Pengurutan Seleksi (Selection Sort)
Pertukaran elemen
Pengurutan Sisip (Insertion Sort)
Geser dan sisip elemen
Pengurutan 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
endfor
endfor
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 efisien
Karena, banyaknya operasi pertukaran yg
dilakukan setiap langkah pass
(pengapungan)
Waktu lama, maka jarang digunakan
Kelebihan, kesederhanaan dan mudah
dipahami.
Pengurutan Seleksi (Selection Sort)

Adalah memilih elemen maksimum/ minimum
dari Larik
Menempatkan 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
tersisa
Memilih 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] temp
endfor


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 sort
Dibanding 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 terurut
Pass 2 : ( I = 2)
Y = 27 (angka yg akan disisipkan)
J = i-1 (mulai penyisiran)
J = 2-1= 1
Y < A[J] (bandingkan)
27 < 29 yes
A[J+1] = 29 (geser)
A[2] = 29
J = 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= 2
Y < A[J] (bandingkan)
10 < 29 yes
A[J+1] = A[j] (geser)
A[3] = A[2]
A[3] = 29
J = J 1 ( penyisiran )
J = 2-1 = 1
Y < A[j] (bandingkan)
10 < A[1]
10 < 27 yes
A[j+1] = A[j]
A[2] =A[1]
A[2] = 27
J = 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= 3
Y < A[J] (bandingkan)
8 < 29 yes
A[J+1] = A[j] (geser)
A[4] = A[3]
A[4] = 29
J = J 1 ( penyisiran )
J = 3-1 = 2
Y < A[j] (bandingkan)
8 < A[2]
8 < 27 yes
A[2+1] = A[2]
A[3] =A[2]
A[2] = 27
J = j 1 (penyisiran)
J = 2 1 = 1
Y < A[j] (bandingkan)
8 < A[1]
8 < 10 yes
A[J+1] = A[j] (geser)
A[2] = A[1]
A[2] = 10
J = 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= 4
Y < A[J] (bandingkan)
76 < 29 no
Ketemu = true (posisi penyisipan ditemukan)
L[j+1] = y
A[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 sama
Misalnya : 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 nilai
Sebuah 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 file
File 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 Beruntun
Pada dasarnya Arsip beruntun adalah file
yg dapat ditulisi untuk menyimpan data.
Operasi yg dilakukan terhadap file yaitu :
- menulisi file dan
membaca file.

Membuat Arsip Beruntun
Yg 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
Algoritma
Sebelum 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 beruntun
Arsip (file) Bil yg berisi sekumpulan
bilangan bulat.
Setiap rekaman adalah bilangan bulat
DEKLARASI
Bil : file of integer


Contoh-contoh pendeklarasian arsip beruntun - next
Arsip 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 beruntun
Untuk 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.

open
Fungsi :
Membuka asip beruntun untuk siap dibaca/ ditulis.
Setelah memanggil fungsi ini, penunjuk arsip (file pointer)
akan menunjuk ke karakter pertama di awal arsip
Sebuah 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 }
Fread
Fungsi :
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 <004,Shalahudin,B>

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


Fwrite
Fungsi :
Menulis rekaman ke dalam arsip beruntun.
Contoh :
RekMhs.Nim 456087
RekMhs.Nama Andi
RekMhs.Nilai A
Fwrite(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 }
Close
Fungsi :
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 Beruntun
Arsip 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 beruntun
Program 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 }

Endfor
Close(Bil) {tutup arsip Bil}


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

DEKLARASI
Type DataMhs : record <Nim :Integer, Nama : String, Nilai : Char>
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 beruntun
Langkah-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 beruntun
Program pembacaan arsip
DEKLARASI :
type rekaman : TipeRekaman
Arsip : file of rekaman
rek : rekaman
AlGORITMA:
Inisialisasi
Open(Arsip, 1) {buka arsip untuk dibaca}

While not EOF(arsip) do
fread(Arsip, rek)
proses rek
Endwhile
{ EOF(arsip) }
Terminasi
Close(arsip)


Contoh :
pembacaan data dari arsip
PROGRAM BacaArsipBilanganBulat
DEKLARASI :
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.0
PROGRAM BacaArsipIP
DEKLARASI :
Type DataMhs : record
<NIM : integer
Nama : string
IP : real
>
RekMhs : DataMhs
Mhs : File of DataMhs
Jumlah : 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 cariIPTertinggi
DEKLARASI :
Type DataMhs : record <NIM : integer
Nama : string
IP : real >
RekMhs : DataMhs
Mhs : File of DataMhs
Maks : 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 file
Penyalian (copy) dapat dilakukan terhadap
seluruh rekaman (record) atau hanya
rekaman (record) tertentu saja.
Menyalin seluruh rekaman
ALGORITMA :
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.0
ALGORITMA :
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}
endif
Endwhile
Close(Mhs1)
Close(Mhs2)
Manggabung (merge) dua Arsip
Menyalin isi dua buah arsip ke dalam
sebuah arsip baru
Dilakukan dg cara penyambungan
(concatenation), yaitu menyalin isi arsip yg
kedua setelah isi arsip pertama.
Contoh :
Algoritma Penggabungan Arsip
ALGORITMA :
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)
Endwhile
Close(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;
var
RekMhs : 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
IPK
Arsip (File) Gabungan disimpan pada Arsip (File)
ketiga
Buatlah Program Komputer dengan Bahasa
Pascal untuk Algoritma di atas.