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
NamaMhs:array[1..12] of string
NilaiUjian:array[0..74] of real
A , NamaMhs, NilaiUjian adalah nama 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.
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 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
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)

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}

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

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
.

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.

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


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

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

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}

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

A 158 157 162 169 172 155 170 163
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.
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.
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)
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)
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.
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)
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)
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 elemen larik yang mempunyai nilai
terkecil di antara elemen larik lainnya.
Konsepnya sama dengan Mencari nilai
maksimum array
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
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
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
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.
A
`
123 130 140 160 180
B
`
123 130 140 160 180
1 2 3 4 5
1 2 3 4 5
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
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


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.
Cotoh:
Array Dua Dimensi dengan matriks : 3 x 5, dengan
tipe data integer dan char :

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







Algoritmanya :
N 1
I 1
While (i<=3)
J 1
While ( j<= 4)
A[i, j] N
N++
J++
Endwhile
I++
Endwhile













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







Algoritmanya :

For i=1 to i<= 3 do
For j=1 to j <=4 do
B[i,j] A[i,j]
Endfor
Endfor
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 )
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
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.

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

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


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.
1. Metode pencarian beruntun (sequantial
search)
2. Metode pencarian bagi dua/pencarian biner
(binary 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




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

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

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


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.

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

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.

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

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

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

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

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



Misal data yang dicari adalah 22 :

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.

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

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

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

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


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.

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

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




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

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:


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)








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)








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)








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.


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









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.


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.


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

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.

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

Arsip (file) Bil yg berisi sekumpulan bilangan
bulat.
Setiap rekaman adalah bilangan bulat
DEKLARASI
Bil : file of integer


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


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.

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


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
}
Fungsi :
Menutup Arsip yang sudah dibuka.

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

Arsip sudah ditutup, tidak dapat diproses
lagi.

Fungsi :
Mendeteksi akhir arsip.
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
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}


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}


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


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)


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



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)



Menggandakan Arsip (file) backup file
Penyalian (copy) dapat dilakukan terhadap
seluruh rekaman (record) atau hanya
rekaman (record) tertentu saja.
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)
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)
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.
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)
Program CariIPTertinggi;
Uses wincrt;
Type DataMhs : record
NIM : integer;
Nama : string;
IP : real;
end;
var
RekMhs : DataMhs;
Mhs : File of DataMhs;
Begin
assign(Mhs, data.dat);
rewrite(Mhs);
write(NIM : ); readln(RekMhs.NIM);
while (RekMhs .nim <> 9999) do
begin
write(NIM : ); readln(RekMhs.nim);
write(Nama :);
readln(RekMhs.nama);
write(IP :); readln(RekMhs.IP);
end;
close(Mhs);
Assign(Mhs, data.dat);
reset(Mhs);
While (RekMhs.NIM <> 999) do
begin
read(Mhs, RekMhs);
if RekMhs.IP > maks then
begin
maks :=RekMhs.IP;
end;
end;
Close(Mhs); { tutup arsip Mhs}
{cetak data mahasiswa yang mempunyai IP
tertinggi}
Write(NIM :, RekMhs.NIM);
Write(NAMA :, RekMhs.Nama);
Write(IP :, RekMhs.IP);
end.





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.