P. 1
Algritma&Pemrograman 2 TI Genap UPDATE April2012 E Rizal

Algritma&Pemrograman 2 TI Genap UPDATE April2012 E Rizal

|Views: 952|Likes:
Dipublikasikan oleh RHa Tag Inginn DCintailagii

More info:

Published by: RHa Tag Inginn DCintailagii on Apr 24, 2012
Hak Cipta:Attribution Non-commercial

Availability:

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

12/27/2012

pdf

text

original

Sections

  • PEMROGRAMAN MODULAR
  • STRUKTUR POHON
  • ILUSTRASI
  • PROSEDUR
  • STRUKTUR PROSEDUR
  • Nama Prosedur
  • Parameter
  • KUIS
  • Nama Global dan Nama Lokal
  • Parameter - next
  • Aturan korespondensi satu satu
  • Parameter masukan
  • Contoh : paramater masukan
  • Parameter keluaran
  • Parameter masukan/keluaran
  • FUNGSI
  • Kuis
  • Pemanggilan FUNGSI
  • PROSEDUR atau FUNGSI
  • Rekursif
  • Pengertian REKURSIF
  • Proses rekursif
  • Algoritma Pangkat
  • Bahasa pascal
  • Array (Larik)
  • Definisi Array
  • Ukuran efektif Array (Larik)
  • latihan
  • ARRAY KONSTAN :
  • Cara 2: Mencari nilai Maksimal
  • Cara 3: Mencari nilai Maksimal
  • Latihan 1:
  • Latihan 2:
  • Algoritma Pencarian
  • Kinerja pencarian bagidua :
  • Klasifikasi pengurutan :
  • Pengurutan sisip (insertion sort)
  • Contoh :
  • Arsip Beruntun (Sequential File)
  • Operasi pada Arsip Beruntun
  • open
  • Close
  • Membuat Arsip Beruntun
  • Membaca Arsip beruntun
  • Manyalin Arsip (file)
  • Manggabung (merge) dua Arsip
  • Tugas

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)

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

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 .Dua bentuk pemrogram modular : PROSEDUR dan FUNGSI • Struktur setiap subprogram tersebut pada hakekatnya sama .

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 namanama dan tipe data • ALGORITMA  badan prosedur (instruksi) *sama dengan struktur ALGORITMA .

dll. CariMaks. Tukar. . Tulis.Nama Prosedur • Nama yang unik • Sebaiknya diawali dengan kata kerja karena prosedur berisi suatu aktifitas – Misalnya: HitungLuas.

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 aktual menggantikan parameter formal. • Parameter formal : – Parameter yg dideklarasikan di dalam bagian header prosedur itu sendiri. • Tiap-tiap parameter aktual berpasangan dengan parameter formal yg bersesuain (berkorespondasi satu satu) .Parameter dibedakan menjadi dua : • Parameter aktual (argumen) : – Parameter yg disertakan pada waktu pemanggilan prosedur (parameter yg ada pada program/algoritma utama). • Ketika prosedur dipanggil.

K. berisi urutan instruksi} . jika ada) {spesifikasi prosedur.awal : keadaan sebelum prosedur dilaksanakan.Notasi algoritma untuk PROSEDUR Procedure NamaProsedur(deklarasi parameter. 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 penjelasan tentang apa yg dilakukan oleh prosedur ini.

Pendeklarasian Parameter dalam prosedur bukanlah keharusan Contoh : Procedure HitungLuasSegitiga {menghitung luas segitiga dengan rumus : L = (alas x tinggi)/2} {K.akhir : luas segitiga tercetak} DEKLARASI Alas.awal : sembarang} {K. tinggi) Luas  (alas * tingg) / 2 Write(luas) . tinggi. luas : real ALGORITMA Read(alas.

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

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

KUIS • BUATLAH NOTASI ALGORITMA UNTUK MELAKUKAN PEMANGGILAN PROSEDUR LUASSEGITIGA SEBANYAK 3 X .

peubah(variabel). .Nama Global dan Nama Lokal • Nama Lokal : Nama-nama (Konstanta. tipe. tipe. dll) yang dideklarasikan di dalam prosedur (termasuk parameter. dll) yang dideklarasikan di dalam program utama. (dapat dikenal/digunakan dibagian manapun dalam program (progam utama maupun prosedur). peubah(variabel). jika ada). (hanya dikenal/digunakan dalam lingkup (scope) prosedur tersebut • Nama Global : Nama-nama (Konstanta.

N : integer alas.PROGRAM Segitiga {menghitung luas N buah segitiga} DEKLARASI I.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.awal : sembarang} {K. tinggi : real Procedure HitungLuasSegitiga {menghitung luas segitiga dengan rumus : L = (alas x tinggi)/2} {K. tinggi  variabel GLOBAL Nama Peubah (variabel) luas  variabel LOKAl . tinggi HitungLuasSegitiga endfor _______________________________________________________________ Nama Peubah (variabel) I. N. alas.

maka deklarasikanlah peubah tsb secara Global. • Bila suatu peubah (variabel) hanya digunakan di dalam prosedur.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 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.

• Jika program utama perlu mengomunikasikan nilai peubah Global ke dalam prosedur. maka gunakanlah PARAMETER.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.

Contoh: NamaProsedur(parameter aktual) • Tiap parameter aktual berpasangan dg paramater formal yg bersesuaian . • 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).Parameter .next • Penggunaan parameter adalah mekanisme pertukaran informasi antara prosedur dengan yang memaggilnya (program utama maupun subprogram lainnya).

Parameter .next • Ketika prosedur dipanggil. parameter aktual berkoresponden satu-satu dengan parameter formal (parameter yg dideklarasikan pada bagian header prosedur) .

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

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

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

Contoh : paramater masukan Procedure HitungLuasSegitiga(input alas.akhir : luas segitiga tercetak} DEKLARASI luas : real ALGORITMA Luas  (alas * tinggi) / 2 Write(luas) . tinggi : real) {menghitung luas segitiga dengan rumus : L = (alas x tinggi)/2} {K.awal : alas dan tinggi sudah terdefinisi nilainya} {K.

tinggi HitungLuasSegitiga(alas. tinggi : real Procedure HitungLuasSegitiga(input alas. N : integer alas.tinggi) endfor .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 : real) {menghitung luas segitiga dengan rumus : L = (alas x tinggi)/2} {K.awal : alas dan tinggi sudah terdefinisi nilainya } {K.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.

t) HitungLuasSegitiga(a. N : integer a.t) endfor .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. tinggi : real) {menghitung luas segitiga dengan rumus : L = (alas x tinggi)/2} {K. t : real Procedure HitungLuasSegitiga(input alas.awal : alas dan tinggi sudah terdefinisi nilainya } {K.nama parameter aktual tidak harus sama dengan nama parameter formal : yg dipentingkan adalah nilainya PROGRAM Segitiga {menghitung luas N buah segitiga} DEKLARASI I.

1) • HitungLuasSegitiga(12. t*0. 6) .Parameter aktual boleh berupa ekspresi atau konstanta Contoh : • HitungLuasSegitiga(a*0.2.

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

L : real Procedure HitungLuasSegitiga(input alas. output luas:real) {menghitung luas segitiga dengan rumus : L = (alas x tinggi)/2} {K. tinggi : real. t. N : integer a.Contoh : parameter keluaran-next PROGRAM Segitiga {menghitung luas N buah segitiga} DEKLARASI I.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. L) Write(L) endfor . t) HitungLuasSegitiga(a.

tidak boleh berupa ekspresi atau konstanta .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.

Akhir : nilai x bertambah 1} DEKLARASI ALGORITMA xx+1 ALGORITMA X0 repeat write(x) inc(x) until x > 10 .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.

a) Write(„ b=„. x) Write(„ y=„. a) Write(„ b=„. b) PROGRAM xyz DEKLARASI a. a) Write(„ b=„. y) ALGORITMA a  15 B  10 Write(„nilai a dan b sebelum panggil prosedur tambah:‟) Write(„ a=„.Parameter masukan - parameter masukan/keluaran PROGRAM xyz DEKLARASI a. b) Tambah(a.y:integer) Deklarasi Algoritma xx+4 Y  y +4 write(„nilai x dan y di akhir prosedur tambah:‟) Write(„ x=„.y:integer) Deklarasi Algoritma xx+4 Y  y +4 write(„nilai x dan y di akhir prosedur tambah:‟) Write(„ x=„. y) ALGORITMA a  15 B  10 Write(„nilai a dan b sebelum panggil prosedur tambah:‟) Write(„ a=„.b) Write(„nilai a dan b sesudah panggil prosedur tambah:‟) Write(„ a=„. b) Tambah(a. b : integer Procedure tambah(input x. b) . a) Write(„ b=„.b) Write(„nilai a dan b sesudah panggil prosedur tambah:‟) Write(„ a=„. b : integer Procedure tambah(input/output x. x) Write(„ y=„.

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 .

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

pertambahan menit dengan 1. 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 .jika jumlah menit <60. tetapi jika jumlah jam = 24. maka set jam kmbali menjadi 0(nol). tetapi jika jumlah detik = 60 maka set detik kembali menjadi nol(0) dan tambahkan 1 ke menit. 3. Pertambahan jam dengan 1. jika jumlah jam <24. 2. jika jumlah detik <60. tetapi jika jumlah menit = 60. maka set menit kembali menjadi 0(nol) dan tambahkan 1 ke jam.Analisa kasus :menentukan jam berikutnya setelah ditambah satu detik 1. Tambah detik dengan 1.

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

hh. Setiap pertambahan 1 detik.. J..59} J :jam Procedure JamBerikutnya(input/output J : Jam) {Menaikkan jam J dengan satu detik } ALGORITMA Read(J.mm..mm =0) and (J.ss) {baca jam awal} Repeat write(J. J.hh.59} ss : integer {0.ss = 0) write(J. J. J.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).ss) {cetak jam sekarang} JamBerikutnya(J) Until (J. jam yg baru ditampilkan sebagai keluaran} Deklarasi Type jam : record <hh:integer {0.mm.hh. J.ss) {cetak jam 00:00:00} . J.hh = 0) and (J.23} mm:integer {0.mm.

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) = 2X2 + 5X – 8 b. sedangkan x dan y adalah parameter fungsi yg bersangkutan.2) = 3*1 – 2+1*2=3 Nilai 10 dan 3 adalah nilai yang diberikan (return) oleh masing fungsi f dan fungsi h. maka f(2) = 2*22 + 5*2 = 10 x=1. h(x. y=2. maka h(1.y) = 3x – y +xy Dimana: f dan h adalah nama fungsi. Nilai yg diberikan oleh fungsi bergantung pada masukan parameter Misal : x=2.

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 .

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

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. peubah(variabel) atau sebuah rumus . sehingga parameter formal selalu diawal dengan keyword INPUT Ekspresi : dapat berupa konstanta.Struktur fungsi Function NamaFungsi(input deklarasi parameter. jika ada)  tipe ( tipe nilai yg diberikan oleh fungsi) {spesifikasi fungsi.

x€ R 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 – 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 .Struktur fungsi • Fungsi untuk menghasilkan nilai f(x)=2x2+5x-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 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  „Jum‟at‟ 6: nama  „Sabtu‟ 7: nama  „Minggu‟ endcase return nama tanpa peubah 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  „Jum‟at‟ 6: return  „Sabtu‟ 7: return  „Minggu‟ endcase .

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

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 … .

2 251.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)=2x2+5x-8.4 … … … … … 14.0 10.08 10. x€ R • output : ----------------------------x f(x) ----------------------------10.0 242.0 … ------------------------------ .8 … 15.

15] dengan deltax = 0.next Program TabelFungsi {program utama yg memperagakan cara pemanggilan fungsi f. ‘ ‘.2 endwhile {buat garis penutup} write(‘----------------------------’) .2} Deklarasi x : real function f(input x : real)  real { mengembalikan nilai f(x)=2x2+5x-8.f(x)) x  x + 0. program ini menampilkan tabel nilainilai x dan f(x) di dalam selang [10. 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.Contoh : pemanggilan fungsi .0 do write(x.0 while x < 15.

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. bil sandi salah. dimana sandi dibaca dari keyboard. pemasukan sandi dapat diulang lagi maksimal 3 kali } Deklarasi Sandi : string { kata sandi yg dibaca dari keyboard } sah : boolean { true jika password benar. anda tidak punya hak mengakses sistem’) endif . false jika password salah} i : integer { pencatat jumlah pembacaan sandi } function valid(input p : string)  boolean { true jika password p benar.Contoh : pemanggilan fungsi .next Program PeriksaSandi {memeriksa kebenaran sandi.

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. output maks :integer) Deklarasi Algoritma if a ≥ b then maks  a else maks  b endif .b:integer)integer Deklarasi Algoritma if a ≥ b then return a else return b endif • Prosedur Function TentukanMaks(input a.b: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 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 .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 • Fungsi Procedure hitungrata2(input ndata:integer.

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 .

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

Contoh: Procedure rekursif Deklarasi Algoritma: Write(„Informatika UHAMKA‟) rekursif .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).

• 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) .

Terapkan suatu langkah untuk menggiring kasus kompleks ke kasus penyetopnya dengan metode yang mencerminkan fungsinya . Tentukan kasus penyetop atau kasus dasar di mana pemanggilan rekursif tidak lagi diperlukan (karena solusinya sudah diperoleh) 2.• Ide dasar dalam memecahkan suatu masalah dengan rekursif adalah sebagai berikut: 1.

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

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

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

Untuk x = 10 dan y = 3 hasilnya dapat digambarkan sebagai berikut: • xy = 1. jika y > 0 . jika y=0 xy = x * xy-1.Untuk x = 10 dan y = 0. hasil dari xy adalah 1.

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 1 else return x*PangkatRekursif(x.Algoritma Pangkat Fungsi PangkatRekursif(input x. y-1) endif .

var a.pangkat(a.n. End. write('masukan pangkat:').' adalah: '.n):10). end.„ pangkat '. Function pangkat(a. . readln(n). Begin If n = 0 then pangkat:= 1 Else pangkat:=a*pangkat(a.n-1).Pangkat dalam Bahasa Pascal program pangkatrekursif. n: integer. begin a:=10. n : integer ) : integer. writeln(a. uses wincrt.

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 .

. End. Begin Write(„Berapa faktorial ? „).Menghitung nilai FAKTORIAL-dalam bahasa PAscal function faktorial (nilai : integer) : integer.‟ faktorial = „. Var N : integer.faktorial(N)). Writeln(N. Readln(N). begin if nilai <= 0 then faktorial := 1 else faktorial := nilai * faktorial (nilai-1) end.

begin if nilai <= 0 then faktorial := 1 else faktorial := nilai*faktorial (nilai-1) end.Pseudo-code function faktorial (input nilai : integer) : integer DEKLARASI ALGORITMA: if nilai <= 0 then return 1 else return nilai*faktorial (nilai-1) endif .Bahasa Pascal function faktorial (nilai : integer) : integer. .

' adalah:'. var n:byte. . end. writeln('faktorial '.Proses hitung faktorial dengan Prosedur program rekursiffaktorial. begin if n <= 1 then hasil:=1 else begin faktorial(n-1. f).N. readln(N).f). procedure faktorial(N:byte. hasil:= N*hasil. uses wincrt. hasil). f:longint. end. end. begin write('Faktorial yg dihitung ?'). var hasil:longint). faktorial(N.

‟ faktorial = „. begin write('Faktorial yg dihitung ?'). Begin Write(„Berapa faktorial ? „).Fungsi function faktorial (nilai : integer) : integer. End. Writeln(N. end. writeln('faktorial '. begin if n <= 1 then hasil:=1 else begin faktorial(n-1. readln(N). faktorial(N. end. . end.faktorial(N)). . Readln(N).' adalah:'.f). Var N : integer. hasil).Prosedur procedure faktorial(N:byte. hasil:= N*hasil. f).N. var hasil:longint). begin if nilai <= 0 then faktorial := 1 else faktorial := nilai * faktorial (nilai-1) end.

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 .Barisan FIBONANCI • Barisan Fibonanci: F (0) = 0 F (1) = 1 F (n) = F ( n-1 ) + F (n-2).

End.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). .

Pseudo-code 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.

Latihan 1. Buat Algoritma untuk menghitung deret S = 1+2+3+4+5+... Buatkanlah program dengan bahasa pascal lengkap untuk Algoritma di atas. .+n menggunakan function rekursif 2.

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

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

Elemen Array I n d e k s I n d e k s A 1 2 3 4 5 Elemen Array kosong A 1 158 2 157 3 162 4 170 5 163 Elemen Array yg sudah disi nilai A[1]. A[2]. A[4]. A[5] . A[3].

5] of integer Variabel biasa Hanya dapat menyimpan satu nilai walaupun sejenis Contoh : Deklarasi: A1 : integer A2 : integer A3 : integer A4 : integer A5 : integer .Variabel array vs variabel biasa Variabel array Dapat menyimpan lebih dari satu nilai yg sejenis Contoh: Deklarasi: A:array[1..

real. artinya elemen larik harus sudah diketahui sebelum program dieksekusi. Boolean).Deklarasi Array • Sesuatu yang akan digunakan/dipakai dalam suatu program terlebih harus dideklarasikan • Array (Larik) adalah struktur(susunan) data yg statis. char. string. tipe bentukan (tipe terstruktur :record) . 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.

..50] of integer NamaMhs : array[1.Deklarasi Array -next • Array dari tipe data dasar : DEKLARASI : A : 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 ..

rekaman disusun oleh satu atau lebih field.NAMA  „BUDI UTOMO‟ Mhs[i]..IPK {mengacu field IPK dari elemen kedua dari array Mhs} Pengsian Nilai per field : Mhs[i].NIM  102131002 Mhs{i]. DEKLARASI : Const NMaks = 100 Type Mahasiswa : record< NIM : integer NAMA : String IPK : real > Type tabmhs : array[1. Mhs[i].NAMA.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].6 Menampilkan hasil per field : Output([Mhs[i].Deklarasi Array -next • Sebagai tipe bentukan terstruktur (RECORD) : – Tipe yang berbentuk rekaman (record).IPK  3. Setiap field menyimpan data dari tipe dasar tertentu.IPK) .NIM. Mhs[i].

asalkan nilai I sudah terdefinisi.Acuan Elemen Array(Larik) • Elemen Array diacu melalui indeksnya. – 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. Nilai Indeks harus 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 .

dan manipilasi lainnya.. komputasi. pembacaan. . • Skema umum pemrosesan array: PROGRAM ProsesArray DEKLARASI: Const max= 10 Type LarikInt : array[1. penulisan.max] of integer A : LarikInt I: integer {indeks Array} ALGORITMA : For i:=1 to max do pemrosesan terhadap A[i]) Endfor • Pemrosesan  pengisian nilai.Pemrosesan Array (Larik) • Elemen array diproses secara beruntun melalu indeks yang terurut mulai dari elemen pertama sampai elemen terakhir.

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.

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

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 .n] dengan pembacaan} {K.Jumlah elemen efektif ditentukan di awal Procedure BacaLarik(Output A : LarikInt. Akhir : setelah pembacaan. input n : integer) {Mengisi elemen-elemen larik A[1.. nilainya terdefinisi} { K. Awal : n adalah jumlah elemen efektif larik.

Jumlah elemen yang dibaca di catat di dalam suatu variabel (peubah) Procedure BacaLarik2(Output A: Larikint. jika „t‟ maka proses pembacaan dihentikan. Output n: integer) {K. 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’ . 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. Akhir : sebanyak n buah elemen larik A berisi nilai-nilai yang dibaca. Awal : sembarang} {K.Jumlah elemen efektif diketahui di akhir pembacaan • Setiap kali selesai pembacaan satu buah elemen.

Akhit : sebanyak n buah elemen larik A berisi nilai-nilai yang dibaca. output n : integr) {mengisi elemen-elemen larik A[1.Jumlah elemen efektif baru diketahui di akhir pembacaan (variasi dari versi 2) • Proses pembacaan dianggap selesai jika nilai yang dibaca adalah suatu tanda. n berisi jumlah larik yang diisi. Procedure BacaLarik3(output A..} 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} . LArikint. misalnya 9999.n] dg cara pembacaan. Akhir pembacaan ditandai jika nilai yang dibaca adalah 9999} {K.Awal : sembarang } K.

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 . selanjutnya data tersebut dapat dimanipulasi Procedure hitungRataRata(input A:Larikint.Menghitung Nilai Rata-rata • Data yang sudah disimpan di dalam Larik.

n] dengan pembacaan } procedure HitungRataRata(input A : LArikint. Output u : real) {menghitung nilai rata-rata larik A} ALGORITMA read(n) {tentukan jumlah elemen larik yang akan digunakan } BacaLarik1(A.. n) HitungRataRata(A. input n : integer. u) write(u) ..NMaks] of integer A : LArikInt n : integer u : integer { nilai rata-rata } procedure BacaLarik1(output A : Larikint.Notasi Algoritma – hitung rata rata PROGRAM Rerata DEKLARASI const NMaks = 100 type LarikInt : array[1. input n :integer) { mengisi elemen larik A[1. n.

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

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]);

. maka untuk mencari nilai maksimumnya harus mengunjungi seluruh elemen array. maka nilai maksimum langsung bisa diperoleh : Ascending  pada elemen terakhir.MENCARI NILAI MAKSIMUM ARRAY : Nilai maksimum pada sebuah variabel Array adalah elemen array yang mempunyai nilai terbesar diantara elemen array lainnya. Descending  pada elemen pertama Permasalahan muncul bila nilai elemen array tesusun secara acak. A 158 157 162 169 172 155 170 163 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.

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

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 A[2] >maks? Tidak A[3] > maks? Ya A[4] > maks? Ya A[5] >maks? Ya A[6] > maks? tidak A[7] > maks? tidak A[8] >maks? Tidak         maks  A[1] (maks=158) maks tidak berubah maks  A[3] (maks=162) maks  A[4] (maks=169) maks  A[5] (maks=172) maks tidak berubah maks tidak berubah maks tidak berubah (proses pembandingan selesai) Didapat : maks = 172 (nilai maksimum array yang ditemukan) .

172. 157.Algoritma untuk maks = -999 Program NilaiMaksimum DEKLARASI : Const N = 8 A : array[1. 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) . 162. 169. 155. 170.N] of integer = (158. 163) I..

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

maks=158) A[2] >maks? Tidak A[3] > maks? Ya A[4] > maks? Ya A[5] >maks? Ya A[6] > maks? tidak A[7] > maks? tidak A[8] >maks? Tidak        maks tidak berubah maks  A[3] (maks=162) maks  A[4] (maks=169) maks  A[5] (maks=172) maks tidak berubah maks tidak berubah maks tidak berubah (proses pembandingan selesai) Didapat : maks = 172 (nilai maksimum array yang ditemukan) .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.

162.Algoritma untuk maks = Elemen pertama Program NilaiMaksumum DEKLARASI : Const N = 8 A : array[1.. 170.N] of integer = (158. 163) I. 157. 172. 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) . 169. 155.

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. • Konversikan algoritma di atas ke dalam Bahasa Pascal . dimana nilai yang tersimpan pada elemen array tersebut di baca dari inputan eksternal (keyboard).

Menyalin Larik (Array) A ` B ` 1 2 3 4 5 6 7 8 158 157 162 169 172 155 170 163 1 2 3 4 5 6 7 8 .

Algoritma Menyalin Larik Program Salin DEKLARASI: Const maks=100 A: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 ..maks] of integer B:array[1..

. • Apabila semua elemen dari larik itu sama.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. maka dapat dikatakan dua buah larik itu sama.

Menguji kesamaan dua buah Larik .next 123 130 140 160 180 A ` 1 2 3 4 5 B ` 123 130 140 160 180 1 2 3 4 5 .

Algoritma menguji kesamaan larik Program uji DEKLARASI Const maks=5 A:array[1.maks] of integer=(123.160..130..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 .140.maks] of integer=(123.140.160.180) B:array[1.130.

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

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

j]  N N++ J++ Endwhile I++ Endwhile .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+4 i++ Endwhile X++ NX J++ 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.

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 . dengan Nilai yang diinput dari Keyboard : • • • Misalnya Array Dua Dimensi dengan Matrik 3 x 5.Mengisi Elemen Array Dua Dimensi.

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

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

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 .

j] J++ Endwhile I++ Endwhile Write (TOT ) .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]  A[i.4]. • Algoritmanya : I 1 While (i <= 3 ) do J 1 While ( J <= 4 ) do C[i.MENAMBAH ISI DUA BUAH ARRAY DUA DIMENSI • Dua buah array Dua Dimensi yang dibuat A[3. dan B[3.j] J++ Endwhile I++ Endwhile .4] dengan tipe data integer.j] + B[i.

• Sedangkan hasilnya adalah matriks ke 3. yaitu jumlah baris matriks ke 3 (matriks hasil) sama dengan jumlah baris matriks ke 1.MENGALIKAN ISI DUA BUAH ARRAY DUA DIMENSI : • Dua buah array Dua Dimensi A[2. dan jumlah kolomnya (matriks 3) sama dengan jumlah kolom matriks ke 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.

dan untuk suatu nilai i dan j. dapat ditulis sebagai berikut : C[i.Perkalian matriks . 3 .next • Contoh : A[2.j] ) Dimana : K dipakai untuk : COL pada array A dan ROW pada array B. nilai k bergerak 1 sd.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.3] x B[3.k] * b[k.j] = ∑ (A[i.

. • Transformasikanlah Algoritma di atas ke dalam bahasa pemrogaram PASCAL. 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.Latihan 1: • diketahui matriks 3 x4 untuk array dua dimensi.

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

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

.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. INSERT. – Contoh: UPDATE.

x=100  idx=-1 – Nilai boolean yg menyatakan status hasil pencarian : jika ada data/nilai ditemukan. x=100  ketemu= false .Spesifikasi Masalah Pencarian : Hasil/keluaran dari persoalan pencarian bergantung pada spesifikasi rinci dari persolan tersebut. maka peubah/variabel yg bertipe boolean diisi dg true. • Contoh : write(„ditemukan‟) atau write(„ tidak ditemukan‟) – Indeks emelen Larik dari data/nilai yg ditemukan. jika tidak ditemukan indeks diisi dg harga khusus. dan kalau tidak ketemu diisi dengan false. misal:-1 • Contoh: x= 76 idx=3. seperti hasil/keluaran: – Sebuah pesan (message) : ditemukan atau tidak ditemukan di dalam Larik. • Contoh: x= 76 ketemu=true.

Pencarian untuk duplikasi data : • Apabila data yang dicari terdapat lebih dari satu banyaknya. dan hasilnya adalah idx = 6. dan algoritma pencarian selesai. Contoh : • Larik A mempunyai dua buah nilai 42. . maka algoritma selesai ketika nilai 42 pertama ditemukan. atau ketemu = true. • Nilai 42 lainnya tidak dipertimbangkan lagi dalam pencarian. maka hanya data yang pertama kali ditemukan yang diacu. yaitu pada elemen ke-6.

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

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

76. 12. 23. 76. 42. 23. 18.Contoh : Metode pencarian beruntun (sequantial search) Misalkan nilai yang dicari adalah 42 • Pemeriksaaan dilakukan terhadap elemen 60. 12. 11. . • Indeks larik yang dikembalikan : idx  -1 • Proses pencarian dihentikan. Misalkan nilai yang dicari adalah 20 • Pemeriksaan dilakukan terhadap elemen 60. 42 (ditemukan) • Ternyata nilai ditemukan pada elemen ke 6 : • Indek larik yang dikembalikan : idx  6 • Proses pencarian dihentikan. 11. 42 (tidak ditemukan) • Ternyata nilai tidak ditemukan di dalam array.

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

• Keluaran yg dihasilkan adalah sebuah peubah boolean bernilai true jika data ditemukan. .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. • Elemen terakhir A[i] diperiksa secara khusus. bila A[i] = nilai/data yang dicari atau i=n. atau false jika data tidak ditemukan.

Algoritma versi 1: hasil pencarian  sebuah variabel boolean • Prosedur : • Fungsi : Procedure cariberuntun(input A:larikint. 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 . input n:integer. input n: 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 Function cariberuntun(input A:Larikint. input x:integer.

Nmaks] of integer A: LarikInt x:integer found : boolean n : integer Procedure bacalarik(output A:LarikInt. input x:integer. found) if found = true then write(x... x. n. 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. input Deklarasi : I : integer Algoritma: for I  1 to n do read(A[i]) endfor n:integer) Procedure cariberuntun(input A:larikint. n) read (x) cariberuntun(A. input n: integer. „ tidak ditemukan‟) endif • .Algoritma lengkap u/ panggil prosedur : versi 1 Program Pencarian Deklarasi: const Nmaks = 100 type LarikInt : array[1. „ ditemukan‟) else write(x.

• Elemen terakhir A[i] diperiksa secara khusus. . • Aksi pembandingan dihentikan. idx diisi dengan nilai -1. • Keluaran yg dihasilkan adalah sebuah peubah index (misal: idx) yang berisi indeks larik tempat data/nilai yang dicari ditemukan.Versi 1: Aksi pembandingan dilakukan sebagai kondisi pengulangan : • Hasil pencarian yg diinginkan: indeks elemen array (larik) yang mengandung nilai/data yang dicari. bila A[i] = nilai/data yang dicari atau i=n. 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. jika data data tidak ditemukan.

input n: integer. input x:integer. input n: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 Function cariberuntun(input A:Larikint.Algoritma versi 1: hasil pencarian sebuah Indeks elemen array • Prosedur : • Fungsi : Procedure cariberuntun(input A:larikint. 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. • Penambahan satu elemen baru tidak melampaui ukuran maksimal larik(array) (Nmaks). . ukuran larik(array) efektif menjadi n+1. • Jika belum ada. maka nilai/data tersebut ditambahkan pada elemen ke n+1. • Setelah penambahan elemen baru.

x.. idx.Nmaks] of integer L: LarikInt x. input n: integer. input Deklarasi : I : integer Algoritma: for I  1 to n do read(A[i]) endfor n:integer) Procedure cariberuntun(input A:larikint. 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 :integer Procedure bacalarik(output A:LarikInt.Algoritma : penambah (append) nilai/data ke dalam larik (array) Program Tambahelemenlarik Deklarasi: const Nmaks = 100 type LarikInt : array[1. n) read (x) cariberuntun(A. input x:integer.. „ sudah terdapat di dalam larik‟) else n  n + 1 { naikkan ukuran larik } A[n]  x { tambahkan nilai x} endif . n. idx) if idx ≠ -1 then write(x.

• Sebaliknya. pembandingan dilanjutkan untuk elemen berikutnya. peubah Ketemu diisi dengan nilai true. pengulangan dihentikan. • Setiap elemen array dibandingkan dengan nilai/data yg dicari mulai dari elemen pertama • Jika A[i] = nilai/data yang dicari.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. jika A[i] ≠ nilai yg dicari. • Peubah boolean (misal. . • Keluaran yg dihasilkan adalah nilai yg disimpan di peubah(variabel) ketemu. Ketemu) diinisialisasi dg nilai false.

input n: integer. input x:integer.Algoritma versi 2: hasil pencarian  sebuah variabel boolean • Prosedur : • Fungsi : Procedure cariberuntun(input A:larikint. 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 . 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 } Function 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 Function cariberuntun(input A:Larikint.Algoritma versi 2: hasil pencarian  sebuah indeks elemen larik • Prosedur : • Fungsi : Procedure cariberuntun(input A:larikint. input n:integer. 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). .

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

Ilustrasi pencarian bagidua : Misal data yang dicari adalah 22 : .

Algoritma pencarian bagidua : .

readln(x). k. x : integer.. End. Ketemu := false. 24. 22. End. 20. 18. 25. Var Idxawal. k) else begin Writeln(x. 14. 26. . ' tidak ditemukan'). 'ditemukan pada indeks ke-'. {melakukan pencarian} Idxawal := 1. ketemu atau tidak } If ketemu then Writeln(x. While (not ketemu) and (idxawal <= idxakhir) do begin K := (idxawal + idxakhir) div 2. Begin Write('Masukkan nilai yang akan dicari : '). 15.14] of integer = (10.Penerapan pencarian bagidua dalam bahasa pascal Program CariBagiDua. Const A:array[1. {memeriksa. Uses wincrt. idxakhir. 16. 19. If A[k] = x then Ketemu := true else If A[k] < x then Idxawal := k+1 else Idxakhir := k-1. 29). Ketemu : boolean. Idxakhir := 14. 28. 12.

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

Dapat digunakan baik untuk data yg belum terurut maupun data terurut 2. 2.Algoritma pencarian beruntun atau pencarian bagidua? Sequential Search Binary Search 1. Kinerja lebih lambat 1. Kinerja lebih cepat . Hanya dapat digunakan untuk data yg terurut saja.

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 ) .

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

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 .

Begin {menampilkan data sebelum proses pengurutan } Writeln(„Data sebelum diurutkan‟). A[k-1] := temp. Const N=6. A[i]). „] = „.. Var i. 27. Uses wincrt. End.N] of integer = (25. End. i. For i:=1 to N do begin Writeln(„A[„. 8. A[i]). „] = „. End. 21). { 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]. {menampilkan data setelah proses pengurutan} Writeln.Penarapan bubble sort dg Pascal : Program UrutBubble. End. End. Writeln(„Data setelah diurutkan‟). For i := 1 to N do begin Writeln(„A[„. 76. End. k. . 10. A:array[1. A[k] := A[k-1]. temp : integer. i.

maka jarang digunakan • Kelebihan.Kinerja pengurutan apung (bubble sort) • Algoritma pengurutan yg tidak efisien • Karena. . banyaknya operasi pertukaran yg dilakukan setiap langkah pass (pengapungan) • Waktu lama. 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. .

i]} imaks  1 {indeks elemen pertama diasumsikan sebagai 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]} elemen maks sementara} temp  A[i] A[i]  maks A[imaks]  temp endfor .Algoritma pengurutan seleksi (selection sort) For i n downto 2 do {cari elemen maksimum pada A[1..

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

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. • Selama penyisiran dilakukan pergeseran elemen larik. • Pencarian posisi yg tepat dilakukan dengan menyisir larik (array). . Metode penyusutan ini cocok untuk persoalan menyisipkan elemen baru ke dalam sekumpulan elemen larik yg sudah terurut.

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 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.

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: .

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 .

• 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) Langkah – langkah .next: 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) .

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

NILAI . NAMA.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.Contoh : • Gambar di atas ada tiga buah rekaman yg memiliki kolom nim. • Sebuah rekaman (record) dapat terdiri dari beberapa kolom data tergantung dari kebutuhan. . • Dalam sebuah arsip beruntun (sequential file) biasanya terdiri dari banyak rekaman. dan nilai • Sebuah baris dari setiap kolom disebut dg rekaman (record).

Rekaman penanda akhir file disebut dg dummy artinya elemen data yg ditambahkan tapi sebenarnya bukan bagian dari data. 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). . Dummy biasa digunakan untuk memudahkan suatu proses.Pengertian Arsip Beruntun (Sequential File) • • • Adalah sebuah arsip (file) yang berisi kumpulan rekaman (record) dengan kolom-kolom data tertentu sesuai dg kebutuhan. Merupakan akhir dari sebuah arsip (File).

.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.

• Jika sebuah arsip beruntun diangap sebagai arsip kosong maka minimal ada satu buah rekaman dummy sebagai akhir rekaman.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.

Tipe bentukan : DEKLARASI type nama tipe arsip : file of tipe rkaman arsip : nama tipe arsip . boolean. Setiap rekaman di dalam arsip beruntun harus bertipe sama.Pendeklarasian Arsip dalam Algoritma • Sebelum melakukan pemrosesan arsip beruntun. char. arsip tersebut harus dideklarasikan terlebih dahulu. real. baik tipe dasar maupun tipe betukan. string) atau tipe terstruktur (record). DEKLARASI arsip : file of tipe rekaman • • • Tipe rekaman dapat berupa tipe dasar (integer.

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

nilai). nama.Contoh-contoh pendeklarasian arsip beruntun . DEKLARASI { tipe rekaman} Type Datamhs : record < nim : integer nama : string nilai : char > { arsip } Mhs : file of Datamhs .next • Arsip Mhs yg berisi data mahasiswa (nim. • Setiap rekaman di dalam arsip Mhs bertipe terstruktur (record).

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

Contoh : open(Mhs. 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. Setelah memanggil fungsi ini. 2) { arsip Bil dibuka untuk ditulis } open(Kar. 1) { arsip Mhs dibuka untuk dibaca } open(Bil. tidak sekaligus keduanya (dibaca dan ditulis). 1) { arsip Kar dibuka untuk dibaca } .open • Fungsi : Membuka asip beruntun untuk siap dibaca/ ditulis.

‟Shalahudin‟. . RekMhs) { RekMhs bertipe DataMhs } Fread(Bil.Fread • Fungsi : Membaca rekaman yang sekarang sedang ditunjuk oleh pointer. I) { I bertipe integer } Fread(Kar. Contoh : Fread(Mhs. dan siap untuk membaca rekaman tersebut. maka hasil perintah Fread adalah : RekMhs berisi <004.‟B‟> Selanjutnya. ch) { ch bertipe karakter } Andai pointer pembacaan sekarang sedang menunjuk ke awal rekaman ke-2. pointer akan menunjuk ke awal rekaman ke-3.

RekMhs) {simpan RekMhs ke arsip Mhs} Fwrite(Bil.Nilai  „A‟ Fwrite(Mhs.Nama  „Andi‟ RekMhs.Fwrite • Fungsi : Menulis rekaman ke dalam arsip beruntun.Nim  456087 RekMhs. Contoh : RekMhs. 765) {menuliskan nilai 765 ke arsip Bil} Fwrite(Kar. „B‟) { menuliskan karakter B ke arsip Kar } .

. tidak dapat diproses lagi. Contoh : close(Mhs) { menutup arsip Mhs } close(Bil) close(Kar) Arsip sudah ditutup.Close • Fungsi : Menutup Arsip yang sudah dibuka.

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). • 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 . • Setiap kali akan membaca suatu rekaman (record) harus dipastikan bahwa tanda akhir arsip (eof) belum dicapai.

rek) proses rek Endwhile { EOF(arsip) } Terminasi Close(arsip) . 1) {buka arsip untuk dibaca} While not EOF(arsip) do fread(Arsip.Skema umum membaca arsip beruntun Program pembacaan arsip DEKLARASI : type rekaman : TipeRekaman Arsip : file of rekaman rek : rekaman AlGORITMA: Inisialisasi Open(Arsip.

x) {baca rekaman pertama} Write(x) endwhile { EOF(bil) } Close(bil) {tutup arsip bil} .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.

0} ALGORITMA : jumlah  0 open(Mhs.Contoh pembacaan : menghitung jumlah mahasiswa yang mempunyai IP > 2. RekMhs) { baca data } if RekMhs.IP > 2.0 then Jumlah  Jumlah + 1 endif endwhile { EOF (Mhs) } Close(Mhs) { tutup arsip Mhs} .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. 1) {buka arsip Mhs untuk pembacaan} while not EOF(mhs) do fread(Mhs.

IP > maks then maks  RekMhs.Nama) Write(„IP :‟. 1) {buka arsip Mhs untuk pembacaan} while not EOF(mhs) do fread(Mhs.NIM) Write(„NAMA :‟.IP endif endwhile { EOF (Mhs) } Close(Mhs) { tutup arsip Mhs} {cetak data mahasiswa yang mempunyai IP tertinggi} Write(„NIM :‟. RekMhs.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. RekMhs. RekMhs.IP) . RekMhs) { baca data } if RekMhs.

.Manyalin Arsip (file) • Menggandakan Arsip (file)  backup file • Penyalian (copy) dapat dilakukan terhadap – seluruh rekaman (record) atau hanya – rekaman (record) tertentu saja.

RekMhs) { baca rekaman dari arsip Mhs1 } Fwrite(Mhs2.Menyalin seluruh rekaman ALGORITMA : Open (Mhs1. RekMhs) { salin Rekmhs ke arsip Mhs2} Endwhile Close(Mhs1) Close(Mhs2) . 2) { buka arsip Mhs2 untuk penulisan } While not EOF(Mhs1) do fread(Mhs1. 1) { buka arsip Mhs1 untuk pembacaan } Open (Mhs2.

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

yaitu menyalin isi arsip yg kedua setelah isi arsip pertama.Manggabung (merge) dua Arsip • Menyalin isi dua buah arsip ke dalam sebuah arsip baru • Dilakukan dg cara penyambungan (concatenation). .

Contoh : .

RekMhs) Endwhile While not EOF(Mhs2) do fread(Mhs2.Algoritma Penggabungan Arsip ALGORITMA : Open(Mhs1. RekMhs) Endwhile Close(Mhs1) Close(Mhs2) Close(Mhs3) . RekMhs) Fwrite(Mhs3. 2) While not EOF(Mhs1) do fread (Mhs1. RekMhs) fwrite(Mhs3. 1) Open(Mhs3. 1) Open(Mhs2.

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

– 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. .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).

You're Reading a Free Preview

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