SILABUS

MATAKULIAH : LOGIKA DAN ALGORITMA

SEMESTER : 1
BEBAN KREDIT : 3 SKS (SATUAN KREDIT SEMESTER)

MATERI
1. Introduksi
2. Dasar-dasa Algoritma dan Pemrograman
3. Simbol Flowchart
4. Struktur dan Deklarasi
5. Input dan Output Statemen
6. Struktur Kontrol
7. Sub Program
 Fungsi
 Procedure
8. Array
9. Recursive
10. Sorting
11. Search

Kepustakaan
1. Suryadi H.S. & Agus Sumin “Pengantar Algoritma dan Pemrograman”
Penerbit Gunadarma.
2. Ir. Yuniar Supardi “Pascal and Flowchart lewat praktek” Penerbit
Dinastindo.
3. B.J Possen ”Programming Flowcharting for Business data Processing”
John willy & sons New York 1978.
4. Yay singelman “Business Programming Logic, Prentice Hall
Englewood Cliffs, New Yersey. 1982.

1 Logika dan Algoritma

Algoritma adalah : Uraian metode penyelesaian masalah terlengkap. Atau suatu intruksi /
langkah-langkah yang logis yang dapat diselesaikan dalam waktu
tertentu dan sesuai dengan hasil yang dikehendaki.

Algoritma ini yang akan kita terjemahkan ke dalam bahasa pemrograman tertentu yang
kita pilih berdasarkan kesesuaian dengan permasalahan (bisnis, teknik, ilmiah dll).

Syarat-syarat Algoritma yang baik:

1. Adanya Input
2. Adanya Output
3. Harus terdefinisi
4. Logis (dapat dikerjakan)
5. Efisien (Cepat dan Praktis)

Struktur-struktur pernyataan dalam Algoritma:

1. Input, read (masukan, baca)
2. Operator : +, /,-,*,SQRT (Akar), SQR (Pangkat), Mod (Modulus) = sisa bagi, Int
(Integer) = Pembulatan.

Contoh Mod(Modulus)

A=5
B=2
C = 5 MOD 2
=1

A = 10
B=2
C = 10 MOD 2
=0

Contoh Int (Integer) = Pembulatan

A=5
B=2
C = Int (A/B)
=2
3. Operator Logika : OR, NOT, …, AND (Spt : <, >, + , <=, >= )

AND
A B A AND B
1 1 1
1 0 0
OR
0 1 0
0
A 0
B 0 B
A OR
1 1 1
1 0 1
0 1 1
0 0 0 2 Logika dan Algoritma
NOT
A NOT A
1 0
0 1

FLOWCHART

Flow = Arah, Jalur, Arus

Chart = Diagram, Simbol

Flowchart adalah teknik penyusunan instruksi untuk penulisan program komputer

terstruktur dengan menggunakan gambar-gambar atau simbol-simbol.

Flowchart digunakan untuk memecahkan masalah yang mengalir sesuai dengan logika
sehingga bisa dibuat solusi dari suatu masalah.

Karakterisitik Flowchart
1. Flowchart bersifat grafis atau menggunakan gambar-gambar sebagai simbol atau
lambang untuk suatu jenis pekerjaan, tugas atau fungsi tertentu.
2. Perintah bersifat esensial, yaitu hanya perintah yang penting-penting saja yang
digambarkan dalam flowchart.
3. Flowchart efektik untuk merancang program terstruktur.

Symbol

3 Logika dan Algoritma

 Start

Baca A, B
Read

C=A+B

Tampilkan C

STOP

Simbol Dasar

Start / Stop

Input / Output

Proses data

Aliran proses

Menyambung pada halaman yang sama

Logika dan Algoritma

4 Menyambung pada halaman yang berbeda
Menyambung
Kondisi (Decision)
pada halaman yang sama
Setiap gambar melambangkan tugas yang harus dilakukan komputer, misalnya tugas
untuk mencetak (print), membaca data (read), memilih salah satu (if) dan lain-lain (lihat
himpunan gambar dihalaman terdahulu);

Setiap gambar berisi informasi lebih lanjut tentang tugas yang harus dikerjakan
komputer.
Informasi lanjut ini dapat berupa:
a) Konstanta;
b) Variabel;
c) Ekspresi (expression); atau
d) Pernyataan (statement).

Pernyataan

Pernyataan (statement) adalah sebuah kalimat sederhana yang kita tuliskan (didalam
gambar/simbol) sebagai panduan kerja komputer.
Pernyataan ini bisa berupa:
1. Pernyataan sederhana, yang hanya berisi:
a) Konstanta; atau
b) Variable;
2. Pernyataan aritmetika;
3. Pernyataan kondisional; atau
4. Pernyataan logika.

Contoh pernyataan:
a. 101 (pernyataan sederhana: konstanta)
b. NIM (pernyataan sederhana: variabel)
c. Nilai = UTS + UAS (pernyataan aritmetika)

5 Logika dan Algoritma

 d. Nilai > 60 (pernyataan kondisional)
e. True (pernyataan logika)

Konstanta

Konstanta (berasal dari kata contant yang berarti tetap) adalah bilangan atau kharakter
atau string yang nilainya tetap/tidak berubah. Konstanta dikelompokkan kedalam:
1. Konstanta numerik, adalah angka-angka 0 s/d 9 serta kombinasinya, contoh 2004;
Konstanta numerik sendiri dikelompokkan lagi kedalam:
a) Konstanta bilangan bulat (integer); dan
b) Konstanta bilangan pecahan (real);
2. Kontanta alphamerik, adalah salah satu huruf dalam alfabed dan kharakter
penghubung seperti spasi, garis bawah, dll., yang diapit tanda petik, contoh “A” ;
dan
3. String, kombinasi untaian konstanta alphamerik dengan konstanta numerik yang
diapit tanda petik, contoh “Abad 21”;
4. Bolean, adalah konstanta dengan nilai TRUE atau FALSE.

Contoh Konstanta

Contoh gambar flowchart dengan pernyataan didalamnya, beserta arti:

Komputer disuruh mencetak angka 2007 (konstanta

2007 numerik);

“Selamat Pagi” Komputer disuruh mencetak “Selamat Pagi” (konstanta

string);

Variabel

Variabel adalah label atau nama yang ditetapkan terhadap data. Harap dibedakan variabel
dari data. Sebagai contoh, “Cirebon” adalah data dalam bentuk string. Data lainnya
(misalnya) adalah “Sumedang”. Jadi “Cirebon” dan “Sumedang” adalah data.

6 Logika dan Algoritma

Terhadap kedua data ini, dan data nama kota lainnya ditetapkan/ diberikan label “Nama-
Kota”. Dengan demikian Nama-Kota adalah variabel atau label atau nama terhadap
kelompok data ini.
Contoh variabel lainnya yang sering kita lihat/dengar adalah NIM, Nama, Alamat, Kota,
Kode Pos, No-telpon, No-HP dan seterusnya;

Flowcharting Series
Contoh variabel dalam gambar flowchart dan arti:

Komputer akan mencetak “Cirebon” dikertas printer

apabila sesaat sebelum komputer melakukan pencetakan
“Nama-Kota” (isi) variable Nama-Kota, variable tsb ‘berisi’ data
“Cirebon”;

Komputer disuruh mencetak data yang diberi label

(variabel) Nama, apabila data yang tersimpan dibalik
“Nama” label tersebut adalah “Ali Topan” maka “Ali Topan” akan
dicetak di printer;

Kegunaan Variabel

Untuk apa menggunakan variabel ?

Variabel diperlukan untuk mengefisienkan penulisan program komputer, karena
disamping sifat program yang memang harus efisien, program-program yang lebih efisien
tersebut lebih bergengsi dari program-program lainnya.
Program digunakan untuk memandu komputer dalam mengolah data. Komputer memiliki
kemampuan luar biasa dalam pengolahan data tersebut. Komputer dengan mudah
menelan 1.000.000 bilangan atau lebih banyak dari itu.

Variabel (penugasan)
Variabel dikaitkan kepada data (diberi nilai) dengan cara penugasan (assignment).
Contoh:
NIM = 200103021 variabel NIM ‘berisi’ data 200103021
Nama = “Ali Topan” variable Nama ‘berisi’ data “Ali Topan”
Mhs-Aktif? = True variable Mhs-Aktif? ‘berisi’ data True
Operator Logika

Operator logika terdiri dari:

and untuk penggabungan dua konstanta atau konstanta dan variabel-logika;
or untuk pemilihan salah satu nilai logika dari dua konstanta atau konstanta dan
variable-logika; dan

7 Logika dan Algoritma

not untuk pembalikan nilai sebuah variabel logika.
Catatan:
penggunaan operator logika dan hasil dapat dilihat dalam tabel kebenaran dihalaman
belakang.

Pernyataan Logika

Contoh pernyataan Logika dalam gambar flowchart dan arti:

Gambar ini berarti variabel Cuti-Akademik?

Cuti-Akademik? = FALSE ‘diberi’ nilai FALSE.
NIM-Valid?

Gambar ini berarti komputer akan mengevaluasi

Ya nilai variabel NIM-Valid?, jika hasilnya TRUE
NIM-
Valid? maka komputer akan mengerjakan tugas berikutnya
yang ditunjuk panah ‘Ya’, atau sebaliknya
Tidak komputer akan mengerjakan tugas yang ditunjuk
panah ‘Tidak’.

Operator Aritmatika

Operator arithmetika terdiri dari:

+ untuk penjumlahan dua ekspresi yang mengapit operator ini;
- untuk pengurangan;
* untuk pengalian;
/ untuk pembagian; dan
** untuk pemangkatan (pangkat).

Operator Kondisional

< untuk pembandingan ‘lebih kecil dari’;

<= untuk pembandingan ‘lebih kecil atau sama dengan’;
= untuk pembandingan ‘sama dengan’;
> untuk pembandingan ‘lebih besar dari’;
>= untuk pembandingan ‘lebih besar atau sama dengan’; dan
<> untuk pembandingan ‘tidak sama dengan’.

BAHAN AJAR ALGORITMA DAN PEMROGRAMAN

DEFINISI ALGORITMA:

Tidak 8 Logika dan Algoritma

 ALGORITMA adalah suatu urutan langkah-langkah (Steps) yang disusun
secara logis untuk menyelesaikan masalah dengan menggunakan komputer, dengan
criteria sebagai berikut :
1. Setiap langkah/step harus jelas dan pasti (Definite)
2. Diperbolehkan tanpa ada input tetapi minimal harus ada 1 output.
3. Jumlah langkah harus berhingga atau dengan kata lain harus ada stopping
criteria.

Penyajian suatu algoritma:

Algoritma dapat disajikan dalam dua cara:

1. Secara tulisan
- Struktur bahasa /diskripsi
- Pseducode

2. Teknik gambar(Flowchart)

Simbol symbol dalam flowchart:

Terminal/ Proses (awal/akhir)

Input/output

Proses

Titik keputusan

Arah arus

Sambungan dalam satu hal.

Sambungan lain halaman.

Contoh:

1. Masalah menghitung Luas dan keliling lingkaran

Misal : input =R, output = L dan K,
Proses : L = pi* r2
dan K = 2 * pi * r
Algoritmanya:

9 Logika dan Algoritma

 Secara Struktur bahasa:
1. Tetapkan nilai pi = 3.14
2. Bacalah nilai R (jari-jari)
3. Hitung luas(L)
4. Hitung keliling(K)
5. Tulis L dan K
Secara Pseudocode:
1. pi 3.14
2. input R
3. L pi* r2
4. K 2 * pi * r
5. Output L dan K

2. Masalah menentukan Faktor Persekutuan Besar (FPB) menggunakan

algoritma Euclid.

Langkah-langkah yang digunakan dalam algoritma Euclid adalah:

a. Diberikan dua buah bilangan bulat positif misalnya m dan n dengan m>n.
b. Bagilah m dengan n, misalnya hasilnya adalah r.
c. Apabila r = 0 ,maka stop dan hasilnya adalah bahwa r itu sendiri merupakan FPB
dari m dan n.
d. Jika r  0 maka lanjutkan ke langkah selanjutnya yaitu ganti m dengan n dan n
dengan r, kemudian ulangi dari langkah (b) demikian selanjutnya.
Contoh:
Carilah FPB dari 36 dan 20:
m 36
a. 1. = , mempunyai sisa r = 16,
n 20
2. r = 16  0
3. m = 20 dan n = 16
m 20
b. 1. = mempunyai sisa r = 4,
n 16
2. r = 4  0
3. m =16 dan n = 4
m 16
c. 1.  mempunyai sisa r = 0,
n 4
2. r = 0,
Jadi FPB( 36, 20) = 4.
3. Masalah Program Selisih waktu.
Algoritma sederhana :
1. Baca jam Mulai
2. Baca jam selesai
3. Hitung selisih jam/ waktu
Perbaikan algoritma :

10 Logika dan Algoritma

 Untuk mengatasi masalah selisih waktu maka semua nilai waktu yang diperoleh,
semuanya diubah ke dalam satuan detik sehingga diharapkan tidak akan ditemui nilai
negatif dalam perhitungan selisih.
Algoritma Psedocode:
Mulai :
1. Input( jam1, menit1,detik1)
2. Input( jam2, menit2,detik2)
3. Delta I jam1*3600 + menit1*60 + detik1
4. Delta II jam2*3600 + menit2*60 + detik2
5. Delta Delta II – Delta I
6. Selisih jam Delta div 3600
7. Menit Delta mod 3600
8. Selisih menit menit div 60
 Selish detik menit mod 60
9. Output(Selisih jam, Selisih menit,Selisih detik)

PEMROGRAMAN PASCAL

STRUKTUR PROGRAM
1. Judul program (opsional)
Format : { judul program } atau program_nama program;

2. Deklarasi program:
Var {Variabel program}
Const {Constanta program}
Label {Label}
Funct {Function}
Procedure {Prosedur program}
Catatan :
Deklarasi program bersifat opsional khusus, artinya jika diperlukan maka
harus ada dalam program dan apabila tidak diperlukan maka boleh tidak
dicantumkan. Deklarasi program termasuk identifier (pengenal), yaitu kata-kata
yang diciptakan oleh pemrogram untuk mengidentifikasi sesuatu.
Syarat identifier:
a) Harus diawali oleh alphabet
b) Huruf besar/ kecil yang digunakan dianggap sama
c) Penyusun dari sebuah identifier tidak boleh berupa: tanda baca, tanda
relasi, symbol arithmatik, karakter khusus atau reserved word
d) Tidak boleh dipisahkan dengan spasi, apabila hendak dipisahkan maka
menggunakan tanda ( _ )
e) Panjang identifier tidak dibatasi tetapi sebaiknya gunakan se-efektif
mungkin.

3. Program Utama
Diawali dengan Begin dan diakhiri dengan End.

11 Logika dan Algoritma

TIPE DATA DALAM TURBO PASCAL
Tipe data berfungsi membatasi jangkauan data ynag akan dilaksanakan.
Macam-macam tipe data:
a) Tipe data Standard, terdiri atas :
- Ordinal
- Non-ordinal
b) Tipe data Terstruktur
c) Tipe data Pointer

Tipe Data Standard

I. Tipe Ordinal
Pada tipe data ini akan berlaku operasi-operasi:
- Predesessor (Pred), berfungsi memberikan nilai kembalian berupa nilai
predesessor (urutan sebelumnya) dari suatu nilai ordinal.
- Successor (Succ), berfungsi memberikan nilai successor (urutan
berikutnya) dari suatu nilai ordinal.

a) Tipe Integer
Operator-operator yang berlaku pada tipe data integer, yaitu :
- Operator arithmatik : +, - , *, /, div, mod
- Operator logic : <, = , > , <= , >= , <>
Tipe data integer masih dibagi menjadi 5 tipe:
Shortint (1 byte bertanda) Byte (1 byte tak bertanda)
Integer (2 byte bertanda) Word (2 byte tak bertanda)
Longint (4 bytebertanda)
Catatan : Semua tipe integer adalah tipe Ordinal.

b) Tipe Real
Dibagi menjadi 5 macam, yaitu :
Real (6 byte) Extended (10 byte)
Single (4 byte) Comp (8 byte)
Double (8 byte)

c) Tipe Char (Karakter)

Char adalah semua tombol yang terdapat pada keyboard atau lebih lengkapnya
semua karakter yang terdapat pada kode ASCII.
Catatan : Apabila char ingin dijadikan sebagai konstanta maka karakter yang
dimasukkan harus diapit dengan tanda kutipsatu. Dan apabila karakter
itu berupa tanda kutip satu maka harus diapit dengan dua tanda kutip
satu.

d) Tipe Boolean
Mempunyai nilai benar /salah. Operator yang penghubung untuk tipe Boolean
adalah : = , <> , > , < , >= , <= , IN

12 Logika dan Algoritma

 Boolean akan menghasilkan False jika nilai = 0 dan akan menghasilkan True jika
nilai = 1.

e) Tipe Enumerated (terbilang)

Bentuk umum :
Type
Nama = (Pengenal 1, pengenal 2,…, pengenal n);
Contoh:
Type
Jawa Tengah = ( Semarang, Tegal, Kendal, Demak) ;
Sehingga dengan fungsi berikut :
Ord(Semarang) = 0
Ord(Tegal) =1
Dan seterusnya…………………..

f) Tipe Subrange
Bentuk umum :
Constanta1..Constanta2

Contoh :
0..99 ;
-128..127 ;
II. Real
Ada beberapa macam tipe real
1. Single
2. Real
3. Double
4. Extended

STRUKTUR PEMROGRAMAN/ STRUKTUR KONTROL :

Ada tiga macam struktur pemrograman yaitu :

1. Runtutan/ Sequential
2. Seleksi/ Conditional
3. Perulangan/ Repetition/ Looping
1. SEQUENTIAL/ RUNTUTAN
Berfungsi mengontrol program sehingga berjalan secara berurutan.
Program dibaca dari mulai perintah yang pertama dituliskan kemudian turun ke
perintah selanjutnya demikian seterusnya sampai pada akhir perintah. Secara umum
program akan dibaca oleh compailer secara terurut.
Contoh :

Program_Selisih_Jam;
Uses crt;
var j1,j2,m1,m2,d1,d2,B1,B2,J,M,S,Delta,sisa: integer;

13 Logika dan Algoritma

 begin
clrscr;
write('Baca jam mulai =');readln(j1,m1,d1);
writeln;
write('Baca jam selesai =');readln(j2,m2,d2);
B1:= 3600 * j1 + 60 * m1 + d1;
B2:= 3600 * j2 + 60 * m2 + d2;
Delta:= B2 - B1;
J:= Delta div 3600;
sisa:= Delta mod 3600;
M:= sisa div 60;
S:= sisa mod 60;
write('Selisih jam =',J);
writeln;
write('Selisih menit =',M);
writeln;
write('Selisih detik =',S);readln;
end.

Hasil Run program:

Baca jam mulai = 3 23 29
Baca jam selesai = 4 30 27
Selisih jam = 1
Selisih menit = 6
Selisih detik =58
Catatan : Tanda (:= ) disebut sebagai Operator Penugasan.

2. SELECTION/ CONDITION

Sistem kontrol ini memungkinkan programmer untuk membuat program

yang dapat memilih satu langkah di antara sejumlah langkah untuk dikerjakan.
Dalam Turbo Pascal disediakan 2 buah struktur kontrol seleksi, yaitu:
a. Struktur IF……THEN…..
b. Struktur CASE…OF…
a). Struktur IF
Merupakan struktur kontrol di mana suatu aksi dilaksanakan berdasarkan kondisi
logikanya (benar atau salah). Bentuk umum :
if (kondisi) then aksi ;
{Jika kondisi benar maka aksi akan dilaksanakan dan sebaliknya }
if (kondisi) then aksi1 else aksi2 ;
{Jika kodisi benar maka aksi1 diaksanakan, jika kondisi salah
maka aksi2 akan dilaksanakan}
if (kondisi1) then aksi1 else
if (kondisi2) then aksi2 else
……………………..
if (kondisi-n) then aksi-n ;

14 Logika dan Algoritma

 {Jika kondisi1 benar maka aksi1 dilaksanakan tanpa membaca
kondisi2 dan seterusnya. Jika kondisi1 salah maka aksi2
dilaksanakan tanpa membaca aksi3 dan selanjutnya. Demikian
seterusnya}
if (kondisi1) then aksi1 ;
if (kondisi2) then aksi2 ;
……………………….
if (kondisi-n) then aksi-n ;
{Masing-masing kondisi akan dibaca dan aksi akan tetap dilaksa-
kan. Jadi masing-masing struktur terpisah satu dengan yang lain}
Contoh program :
program_menghitung_akar_kwadrat:
uses crt;
var A,B,C:integer;
x1,x2,D:real;
begin
clrscr;
write('Baca koofisien:');readln(A,B,C);writeln;
writeln(A,'x*x + (',B,') x +',C);
if A=0 then writeln('Bukan persamaan kwadrat') else
begin
D:=(B*B) - (4*A*C);
writeln('Determinannya :',D:2:2);readln;
if D>0 then
begin
writeln('Persamaan kwadrat mempunyai 2 akar yang berbeda');

x1:= (-B + sqrt(D))/(2*A);

x2:= (-B - sqrt(D))/(2*A);
writeln('Akar-akarnya adalah:',x1:2:2,'dan',x2:2:2);
end else
if D=0 then
begin
writeln('Persamaan kwadrat mempunyai akar yang sama'
x1:= -B/(2*A);
x2:= -B/(2*A);
writeln('Akar-akanya adalah:',x1:2:2);
end else
writeln('Tidak memiliki akar riil');
end;
readln;
end.

Hasil Run Program :

-Baca koofisien: 1 -4 4

15 Logika dan Algoritma

 1x*x + (-4) x +4
Determinannya :0.00

Persamaan kwadrat mempunyai akar yang sama

Akar-akanya adalah:2.00

-Baca koofisien: 1 -5 6

1x*x + (-5) x +6
Determinannya :1.00

Persamaan kwadrat mempunyai 2 akar yang berbeda

Akar-akarnya adalah:3.00dan2.00

-Baca koofisien: 1 3 4

1x*x + (3) x +4
Determinannya :-7.00

Tidak memiliki akar riil

Program_Konversi_nilai:
Uses Crt;
var Nilai : Byte;
begin
clrscr;
write('Baca nilai :');readln(Nilai);
if nilai>=80 then write('Nilai = A') else
if nilai>=65 then write('Nilai = B') else
if nilai>=41 then write('Nilai = C') else
if nilai>=26 then write('Nilai = D') else
write('Nilai = E');
readln;
end.

Hasil Run Program :

Baca nilai : 90 Baca nilai :55
Nilai = A Nilai = C
Baca nilai :75 Baca nilai :25
Nilai = B Nilai = E

b). Struktur CASE…OF..

16 Logika dan Algoritma

 Merupakan peluasan dari struktur IF. Karena kalau dalam struktur IF
hanya disediakan dua pilihan (berdasarkan kondisi logikanya) maka dalam
struktur Case ..of dimungkinkan untuk memilih satu pilihan di antara banyak
pilihan yang ada. Bentuk umumnya :
Case var.pilih of atau Case var.pilih of
Pilih1 : aksi1 ; pilih1 : aksi1 ;
Pilih2 : aksi2 ; pilih2 : aksi2 ;
……………. ; ……………. ;
pilih-n : aksi-n ; pilih-n : aksi n;
else aksi-n+1
end; end;
Catatan : Ekspresi yang digunakan dalam statemen Case adalah yang mempunyai
tipe ordinal yaitu dengan batas antara (-32768 s/d 32767). Sehingga tipe lain
seperti integer yang bertipe longint, tipe string atau word tidak boleh digunakan.
Contoh program :
Program_Konversi_nilai2;
Uses Crt;
Var Nilai : integer;
begin
Clrscr;
write('Baca nilai =');readln(Nilai);
Case Nilai of
0..25 : writeln('Nilainya = E');
26..39 : writeln('Nilainya = D');
40..64 : writeln('Nilainya = C');
65..79 : writeln('Nilainya = B');
80..100: writeln('Nilainya = A');
else
writeln('Tidak ada nilai yang dimaksud');
end;readln;
end.

Catatan : Program ini akan memberikan nilai yang sama persis dengan yang
menggunakan struktur IF.

3. PERULANGAN/ LOOPING/ REPETITION

Dalam membuat suatu program kadang-kadang diinginkan agar program

tersebut mampu memproses hal yang sama secara berulang-ulang sampai ditemukan
suatu nilai tertentu yang diinginkan atau mencapai batas yang telah ditentukan. Untuk
itu maka Turbo Pascal telah menyediakan suatu struktur perulangan yang

17 Logika dan Algoritma

memudahkan untuk melakukan proses tersebut, sehingga kode-kode dalam program
menjadi lebih sederhana. Ada beberapa struktur perulangan, yaitu :
- Struktur FOR….DO….
- Struktur WHILE…DO……
- Struktur REPEAT…UNTIL….

a). Struktur FOR

Ada 2 jenis struktur FOR, yaitu :
- Ascendant (Naik)
- Descendant (Turun)
Naik
Format : For count := awal to akhir do aksi/ blok aksi ;
Catatan : - awal <= akhir
- Variabel count akan naik satu setelah menyelesaikan aksi
Turun
Format : For count := awal downto akhir do aksi1/ blok aksi ;
Catatan : - awal >= akhir
- Variabel count akan turun satu setelah menyelesaikan aksi
Struktur FOR hanya dpat digunakan pada cacah perulangan yang
diketahui (berapa kali perulangan tersebut akan dilakukan).

Contoh program :

Program Latihan: Program Latihan 2:

uses Crt; uses Crt;
var N,i,j :integer; var N, I, j, data : integer;

begin begin
clrscr; clrscr;
write('Baca nilai : ');readln(N); write(‘Baca nilai:’);
for i:= 1 to N do readln(N);Data:=N;
begin for i:=1 to N do
for j:=1 to i do begin
write(i:3); for j:=1 to N do
writeln; write(data:3);
end; writeln;
readln; data := data -1;
end. end;

End.
Hasil Run Program : Hasi Run Program :
Baca nilai : 7 Baca nilai : 7
1 7
2 2 6 6
3 3 3 5 5 5
4 4 4 4 4 4 4 4

18 Logika dan Algoritma

 5 5 5 5 5 3 3 3 3 3
6 6 6 6 6 6 2 2 2 2 2 2
7 7 7 7 7 7 7 1 1 1 1 1 1 1

b). Struktur WHILE .. DO..

Format : While (kondisi) do Aksi/blok aksi

Kondisi: Ekspresi Boolean
Pengecekan untuk melakukan perulangan dilakukan pada awal proses dan
perulangan akan dikerjakan selama kondisi benar. Oleh karena itu, perlu adanya
suatu proses yang dapat mengontrol kondisi agar dapat menghentikan proses.

Contoh program :

uses crt;
var i:integer;
begin
clrscr;
write('Masukkan angka :');readln(i);
while i<5 do
begin
write('Matematika UGM');
i:=i+1;
end;
readln;
end.

Hasil Run program :

Masukkan angka :1
Matematika UGMMatematika UGMMatematika UGMMatematika UGM
Matematika UGM

Keterangan :
Program di atas akan dilaksanakan jika angka yang kita masukkan kurang
dari atau sama dengan lima. Dan dalam program di atas yang bertugas
menghentikan perulangan adalah proses i:= i+1; sebab jika tidak ada statement
itu, apabila angka yang kita masukkan benar <= 5 maka program akan berulang
sampai tak hingga banyak.
Catatan :
Struktur perulangan while..do dapat digunakan untuk melakukan
perulangan baik yang diketahui maupun yang tidak diketahui jumlah
perulangannya.

c). Struktur REPEAT..UNTIL..

Format : Repeat aksi/ blok aksi until (kondisi) ;
(kondisi) di sini berupa Boolean.

19 Logika dan Algoritma

 Perulangan dilakukan terus-menerus hingga diperoleh kondisi bernilai benar.
Dalam hal inipun diperlukan adanya kondisi yang dapat mengontrol program agar
program dapat berhenti namun berbeda dengan while do yang kontrolnya
ditempatkan pada awal proses, maka repeat until kontrolnya diletakkan pada
akhir proses.

Contoh program :

PROGRAM CONTOH_REPEAT;
Uses crt;
var
n,tot,x: integer;
Mean: real;
begin
clrscr;
tot:=0;
n:=0;
write ('Baca data :');readln(x);
repeat
tot:= tot + x;
n:= n + 1;
write('Data lagi :');readln(x);
until x=0;
end.

Hasil Run Program :

Baca data :12
Data lagi :3
Data lagi :4
Data lagi :5
Data lagi :0
{setelah dimasukkan nol maka pembacaan akan berhenti dan akan kembali ke
menu awal}

TIPE DATA LARIK ( ARRAY )

Array atau larik terdiri atas bagian-bagian komponen yang memiliki tipe data
sama. Dalam penyimpanannya array selalu mempunyai jumlah komponen yang tetap
yang ditunjukkan oleh indeksnya. Dimana indeks ini harus merupada data dengan tipe
ordinal artinya mempunyai urutan tertentu.

20 Logika dan Algoritma

Ada 2 cara untuk mendeklarasikan larik yaitu :
1. Sebagai tipe data baru
Type
Larik=Array[1..n] of datatype ;
Var x : larik ;

2. Langsung sebagai variabel

Var x : Array[1..n] of datatype ;

Mengakses Data larik :

Cara mengakses data larik adalah dengan menunjukkan :
Nama_Larik[no.indeks] ;
Misal : x[1]  berarti kita mengakses data larik x pada no.indeks ke-1.

Keuntungan :
Menggunakan data larik adalah bahwa kita tidak akan kehilangan nilai dari suatu
data.

Kelemahan :
Saat ditentukan suatu variable bertipe data array maka ia akan langsung
mengambil tempat pada memory penyimpanannya sesuai dengan tipe data yang
digunakan pada array, baik nantinya semua komponen pada array itu digunakan ataupun
tidak.

Dalam pemrograman kadang kita menghadapi masalah saat kita akan

mendeklarasikan suatu matriks dengan adanya tipe data array maka masalah itu dapat
diselesaikan, yaitu dengan menggunakan array dengan dimensi dua atau lebih yang
kemudian dikenal dengan array dimensi banyak.
Pendeklarasian :

Type
Nama_Array = Array[tipe-indeks1,tipe-indeks2] of tipe data ;

Contoh :
Type
Matriks = Array[1..10, 1..10] of integer ;
Berarti matriks itu akan mempunyai dimensi (10x10), namun itu hanya batas atas
dari indeks yang dipesan dalam memori penyimpanan (di atas itu tidak akan disimpan),
sedangkan apabila nantinya kita hanya memasukkan jumlah baris missal 2 dan jumlah
kolom 2 itu boleh saja selama tidak lebih dari 10.
Entry-entry dari matriks tersebut dapat kita panggil dengan mengetikkan
Nama_Array[indeks] ; dari contoh diatas berarti Matriks[2,3] yaitu entry dari
matriks pada baris kedua kolom ketiga.

Contoh program :

21 Logika dan Algoritma

 Program Rata_rata;
Uses crt;
type
larik = array[1..10] of integer;
var
x : larik;
Tot, i, n : integer;
mean : real;

Begin
clrscr;
write('Masukkan jumlah data : '); readln(n);
writeln;
Tot := 0;
for i:= 1 to n do
begin
write('Masukkan Data ke-',i,' ', 'Anda : '); readln(x[i]);
Tot:= Tot + x[i];
end;
writeln;
mean:= Tot/n;
write('Dan hasil perhitungan meannya : ');
writeln(mean:8:2);
readln;
end.
Hasil Run Program :
Masukkan jumlah data : 5
Masukkan Data ke-1 Anda : 1
Masukkan Data ke-2 Anda : 2
Masukkan Data ke-3 Anda : 3
Masukkan Data ke-4 Anda : 4
Masukkan Data ke-5 Anda : 5
Dan hasil perhitungan meannya : 3.00

Program Matriks :
Program Baca_tulis_matriks ;
uses crt;
Var m,n,i,j : integer;
x: Array[1..100,1..100] of integer;
begin
clrscr;
write('Baca ukuran baris Matriks :',' ');readln(m);
write('Baca ukuran kolom matriks :',' ');readln(n);
writeln('Matriks anda berukuran',' ',m,'x',n,' ');
for i:=1 to m do
for j:=1 to n do

22 Logika dan Algoritma

 begin
write('Baca nilai :',' ');readln(x[i,j]);
end;
writeln;
writeln('Matriksnya :',' ');
for i:=1 to m do
begin
for j:=1 to n do
write(x[i,j]:3); writeln;
end;
writeln;writeln('Matriks tranposenya :',' ');
for j:= 1 to n do
begin
for i:=1 to m do
write(x[i,j]:3);writeln;
end;writeln;
writeln('Matriks anda berukuran',' ',n,'x',m,' ');
readln;
end.

Hasil Run Program :

Baca ukuran baris Matriks : 2

Baca ukuran kolom matriks : 2
Matriks anda berukuran 2x2
Baca nilai : 1
Baca nilai : 2
Baca nilai : 3
Baca nilai : 4
Matriksnya :
1 2
3 4
Matriks tranposenya :
1 3
2 4
Matriks anda berukuran 2x2

PEMROGRAMAN MODULAR

Catatan ini akan membahas mengenai “ Pemrograman Modular “.Di mana

pemrograman modular ini merupakan salah satu kemudahan yang diberikan oleh Turbo
Pascal terhadap programmer, karena di sini programmer dapat membagi program yang
sedang dibuatnya ke dalam modul-modul program tertentu. Sehingga dapat menghindari

23 Logika dan Algoritma

penulisan teks program yang sama berkali-kali dan dapat juga memudahkan dalam
melakukan pelacakan kesalahan dalam program yang sedang dibuatnya.
Ada 2 jenis pemograman modelar yang dibahas dalam praktikum ini, yaitu :
1. PROCEDURE (Prosedur)
2. FUNCTION (Fungsi)

PROCEDURE

Deklarasi :
Procedure NamaProcedure(DaftarParameter) ;
{Deklarasi}
Begin
.............
.............
End ;

Pemanggilan Procedure :
Suatu procedure bukan merupakan program yang berdiri sendiri sehingga
tidak dapat dielsekusi secara langsung. Untuk itu suatu procedure memerlukan sebuah
akses pada program utama / modul lain yang befungsi sebagai pemanggil. Sedangkan
cara pemanggilannya adalah dengan : menuliskan nama procedurenya berikut
parameternya (jika ada).

Hal-hal yang berhubungan dengan procedure :

Ada beberapa hal yang berhubungan dengan penulisan sebuah procedure
program yaitu :

1. Variabel Global dan variabel

Variabel Global adalah variabel yang dapat dikenali diseluruh bagian program
biasanya variabel ini merupakan variabel yang dideklarasikan pada
deklarasi program umum.
Variabel Lokal adalah variabel yang dikenal pada lingkup yang lebih sempit dari pada
variabel global.

2. Parameter
Ada 2 paramete yang berlaku dalam sebuah procedure, yaitu :
a. Parameter Formal
Yaitu parameter yang dideklarsikan mengikuti pendeklarasian program utama
b. Paramete Aktual
Yaitu parameter yang dituliskan mengikuti pemanggilan procedure

Aturan antara parameter formal dan parameter aktual :

1) Banyaknya parameter aktual harus sama dengan banyaknya parameter formal

24 Logika dan Algoritma

 2) Tiap-tiap parameter aktual harus bertipe sama dengan parameter formal yang
bersesuaian
3) Tiap-tiap parameter aktual harus diekspresikan yang sesuai dengan parameter
formal

Pengiriman parameter :
a. Pengiriman parameter secara nilai (by Value)
- Tiap-tiap parameter dalam prosecure utama akan beisi nilai yang dikirim
oleh parameter aktual dan bersifat lokal diprocedure
- Pengiriman nilai parameter secara by value merupakan pengiriman searah,
artinya hanya dari parameter aktual ke parameter formal
- Perubahan parameter formal tifak mempengaruhi terhadap nilai parameter
aktual
Contoh :
Procedure Hitung(A,B,C : integer) ;
Begin
B: = A;
C: = A + B ;
Writeln(A,B,C) ;
Var X,Y,Z : integer ;

Begin
Readln(X) ; Readln(X) ; Readln(X) ;
Hitung(X,Y) ; Writeln(X,Y,Z) ;
Readln ;
End.

Ket :
Misalkan dimasukkan nilai dari X=5, Y=7 dan Z=15 maka nilai
ini akan dikirim ke parameter formal pada procedure yaitu A,B,C sehingga
nilai awal A=5, B=7 dan Z=15. Setelah melalui proses maka hasil outputnya
adalah bahwa nilai X=5 , Y=7 dan Z=15. Sebab apapun yang diproses pada
procedure tidak akan mempengaruhi nilai dari parameter aktual X,Y,Z.

b. Pengiriman parameter secara acuan (by Reference)

- Merupakan pengiriman dua arah yaitu dari parameter aktual ke parameter
formal dan dari parameter formal ke parameter aktual sebagai hasil output
dari procedure
- Perubahan nilai pada parameter formal mempengaruhi pada parameter
aktual
- Dicirikan dengan pengunaan deklarasi VAR , pada parameter
procedurenya

Contoh :
Procedure Hitung(Var A,B,C : integer) ;
Begin

25 Logika dan Algoritma

 B: = A;
C: = A + B ;
Writeln(A,B,C) ;
End;
Var X,Y,Z : integer ;
Begin
Readln(X) ; Readln(X) ; Readln(X) ;
Hitung(X,Y) ; Writeln(X,Y,Z) ;
Readln ;
End.

Ket :
Misalkan dimasukkan nilai dari X=5, Y=8 dan Z=15 maka nilai
ini akan dikirim ke parameter formal pada procedure yaitu A,B,C sehingga
nilai awal A=5, B=8 dan C=15. Setelah melalui proses maka hasil outputnya
adalah bahwa nilai X=A=5 , Y=B=A=5 dan Z=C=10. Sebab apapun yang
diproses pada procedure akan mempengaruhi nilai dari parameter aktual
X,Y,Z.

Contoh program yang menggunakan procedure :

Program KOMBINASI;
uses crt;
var f1,f2,f3:longint;
n,r,delta:integer;
c: real;

Procedure facto( n:integer; var f:longint);

var i:integer;
begin
f:=1;
for i:=1 to n do
f:= f * i;
end;

{======================PROGRAM UTAMA=======================}
Begin
clrscr;
gotoxy(12,3);
write('Kita akan menghitung nilai kombinasi dari suatu angka');
gotoxy(19,4);
writeln('Yang mempunyai rumus : rCn = n!/(r!(n-r)!)'); gotoxy(20,5);
writeln('Nilai r harus lebih kecil/sama dengan n');
writeln;gotoxy(28,6);
write('Masukkan nilai n :',' ');readln(n);

26 Logika dan Algoritma

 writeln;gotoxy(28,8);
write('Masukkan nilai r :',' ');readln(r);
facto(n,f1);
facto(r,f2);
delta:=(n-r);
facto(delta,f3);
c:= f1/(f2*f3);gotoxy(30,10);
write('Hasilnya :',' ',c:2:0);
readln;
end.
Hasil Run Program :

Kita akan menghitung nilai kombinasi dari suatu angka

Yang mempunyai rumus : rCn = n!/(r!(n-r)!)
Nilai r harus lebih kecil/sama dengan n
Masukkan nilai n : 6
Masukkan nilai r : 2

Hasilnya : 15

FUNCTION

Deklarasi :
Function NamaFungsi(NamaParameter) : TipeData ;
{Deklarasi}
Begin
...........
...........
End ;

Struktur dari fungsi ini hampir sama dengan procedur hanya saja function harus
dideklarasikan beserta tipe datanya dan fungsi ini adalah mengembalikan nilai sehingga
Tipe data dalam sebuah function menunjukkan tipe dari data akhir dari deklarasi sebuah
fungsi.
Suatu fungsi dapat dipanggil dengan menggunakan beberapa cara, misalkan :
Nama Fungsinya adalah Rata, maka ia akan dapat dipanggil dengan menggunakan

Rata2 : = Rata(vector,Ukuran) ;
X : = Y + Rata(vector,Ukuran) ;
Write(‘Nilai rata-ratanya = ‘, rata(vector,ukuran));

Perbedaan prinsip antara procedure dengan function :

1. Pada function nilai yang dikirim balik terdapat nama fungsinya (Karena nama
fungsi digunakan untuk menampung nama fungsi yang terakhir)
2. Function dapat langsung ditampikan hasilnya. Misal : writeln( Hitung(X,Y)) ;

27 Logika dan Algoritma

Catatan :
Untuk keterangan yang lain yang meliputi macam variabel, parameter, aturan
antar parameter dan cara pengiriman parameter sama dengan yang ada pada procedure,
sehingga tidak perlu dituliskan lagi.

Contoh Program yang menggunakan fungsi :

PROGRAM FAKTORIAL;
Uses crt;
Var i,N,Hsl:integer;

Function Fakto(N:integer):integer;
Var Fak: integer;
Begin
Fak:= 1;
for i:=1 to N do
Fak := Fak * i;
Fakto:= Fak;
end;
Begin
clrscr;
write('Faktorial berapa yang anda ingin hitung : ');
readln(N);
writeln('Hasil perhitungan : ',Fakto(N));
readln;
end.

Hasil Run Program :

Faktorial berapa yang anda ingin hitung : 5
Hasil perhitungan : 120

Dalam turbo Pascal telah dikenal ada beberapa tipe data yang kemudian dapat
digolongkan menjadi 2 kelompok besar tipe data yaitu tipe data standard dan tipe data
terstruktur. Pada laporan ini akan dibahas mengenai tipe-tipe data terstruktur yang
meliputi tipe data array, tipe data record dan tipe data set.

REKURSI

Salah satu keistimewaan yang dimiliki oleh Turbo Pascal adalah bahwa pascal
dapat melakukan suatu proses yang dinamakan sebagai proses Rekursi, yaitu proses untuk
memanggil dirinya sendiri. Dalam procedure dan function proses ini bisa berarti proses
berulang yang tidak diketahui kapan akan berakhirnya. Contoh paling sederhana dari
proses rekursi adalah Proses mencari faktorial dari suatu.

Faktorial N = N! = N (N-1) (N-2)……………..3.2.1

N! = N (N-1)! ,untuk N>0
N! = N (N-1) (N-2)!

28 Logika dan Algoritma

Jika ditulis dalam program menjadi :
Faktorial(0) = 1 ;
Faktorial(N) = N (N-1)!
Ini merupakan sebuah hubungan rekurens yang berarti nilai suatu fungsi dengan
argument tertentu dapat dihitung dengan menggunakan fungsi yang sama hanya saja
dengan argument yang lebih kecil.

Contoh program :

PROGRAM FAKTORIAL;
Uses crt ;
Var i , N , Hsl : integer
Function Fakto(N:integer):integer ;
Var Fak: integer ;
Begin
if (N=0) or (N=1) then
Fakto:= 1
else
Fakto:= N*Fakto(N-1) ;
end;
Begin
clrscr;
write('Faktorial berapa yang anda ingin hitung : ') ;
readln(N) ;
writeln('Hasil perhitungan : ',Fakto(N)) ;
readln ;
end .

Hasil Run Program :

Faktorial berapa yang anda ingin hitung : 5
Hasil perhitungan : 120

Dari program diatas maka notasi Fakto(N-1) yang digunakan untuk memanggil program
sebelumnya dinamakan sebagai Pemanggil atau rekursi.

TIPE DATA RECORD

Tipe data ini merupakan perluasan dari tipe data Array, yaitu karena pada array
masing-masing komponennya harus menggunakan tipe data yang sama, maka pada
record hal itu tidak berlaku lagi. Artinya diperbolehkan untuk menggunakan tipedata
yang berbeda pada masing-masing komponen (field) dari record tersebut.
Pendeklarasian record :
Type
Nama_record = record

29 Logika dan Algoritma

 Field1: tipe data1 ;
Field2: tipe data2 ;
…………………
…………………
Fieldn: tipe datan ;
End ;

Contoh :
Type Barang = record
Nama : string[20] ;
Jenis : string [20]
Jumlah : integer ;
End ;

Memasukkan data ke dalam record :

Untuk memberikan nilai dari masing-masing field maka kita harus menuliskan
Nama_record.field := (nilainya);
Misalkan : dari contoh diatas kita akan mengisikan nama barang dengan Piring, jenis
barang yaitu barang pecah belah dan jumlah barang 3 lusin maka kita harus menuliskan
pada program utama
Barang.Nama := ‘Piring’ ;
Barang.Jenis := ‘Pecah belah’ ;
Barang.Jumlah:= 36 ;
Nilai-nilai dari field ini akan disimpan dalam record. Untuk melihat apakah benar data
yang dimasukkan telah tersimpan dalah ecord maka pada var kita deklarasikan suatu
variable misal :
X : array[1..n] of Nama_record ; dari soal di atas yaitu
X : array[1..n] of Barang ;
Maka apabila nanti kita lakukan pemanggilan dengan mengetikkan
Write(Barang[i].nama),
data dari field yang tersimpan dalam record tersebut akan ditampilkan.

Contoh program :
PROGRAM DATABASE;
Uses crt;
TYPE mahasiswa=record
nama: array[1..20] of string;
nim: array[1..20] of string;
alamat: array[1..20] of string;
ipk: array[1..20] of real;
end;

VAR data1: mahasiswa;

PROCEDURE data(var mhs:mahasiswa; mhs1:mahasiswi);

Var i,n,no:integer;
pilih,tekan:char;
Begin

30 Logika dan Algoritma

 write('Masukan jumlah mahasiswa : ');readln(n);
writeln;
for i:= 1 to n do
begin
writeln('Masukan data mahasiswa ke - ',i);
writeln;
write('Nama Mahasiswa : ');readln(mhs.nama[i]);
write('No. Mahasiswa : ');readln(mhs.nim[i]);
write('Alamat Mahasiswa : ');readln(mhs.alamat[i]);
write('IPK : ');readln(mhs.ipk[i]);
writeln;
end;
writeln;
writeln('DATA MAHASISWA');
writeln;
writeln('==========================================================');
writeln('|','No':5,'Nama':20,'NIM':10,'Alamat':20,'IPK':10,'|':2);
writeln('==========================================================');
for i:=1 to n do
writeln('|',i:5,mhs.nama[i]:20,mhs.nim[i]:10,mhs.alamat[i]:20,mhs.ipk[i]:10:2, '|':2);
writeln('==========================================================');
writeln;
write('Ingin mencari data tertentu (y/n) ? ');readln(pilih);
writeln;
case pilih of
'y': begin
tekan:='Y';
while upcase(tekan)='Y' do
begin
clrscr;
writeln;
writeln('MENU PILIHAN');
writeln;
writeln('[1] NAMA');
writeln('[2] NIM');
writeln('[3] ALAMAT');
writeln('[4] IPK');
writeln;
write('Pilihan anda : ');readln(no);
case no of
1: begin
write('Masukan Nama Mahasiswa : ');readln(mhs1.nama);
writeln;
writeln('=========================================================');
writeln('|','Nama':20,'NIM':10,'Alamat':20,'IPK':10,'|':2);
writeln('=========================================================');
for i:=1 to n do
if (mhs1.nama) = (mhs.nama[i]) then
begin writeln('|',mhs1.nama:20,mhs.nim[i]:10,mhs.alamat[i]:20,mhs.ipk[i]:10:2,
'|':2);
end;

31 Logika dan Algoritma

 writeln('=========================================================');
writeln;
end;
2: begin
write('Masukan No. Mahasiswa : ');readln(mhs1.nim);
writeln;
writeln('=========================================================');
writeln('|','Nama':20,'NIM':10,'Alamat':20,'IPK':10,'|':2);
writeln('=========================================================');
for i:=1 to n do
if (mhs1.nim) = (mhs.nim[i]) then
begin
writeln('|',mhs.nama[i]:20,mhs1.nim:10,mhs.alamat[i]:20,mhs.ipk[i]:10 :2,'|':2);
end;
writeln('==========================================================');
writeln;
end;
3: begin
write('Masukan Alamat Mahasiswa : ');readln(mhs1.alamat);
writeln;
writeln('=========================================================');
writeln('|','Nama':20,'NIM':10,'Alamat':20,'IPK':10,'|':2);
writeln('=========================================================');
for i:=1 to n do
if (mhs1.alamat) = (mhs.alamat[i]) then
begin
writeln('|',mhs.nama[i]:20,mhs.nim[i]:10,mhs1.alamat:20,mhs.ipk[i]:10 :2,'|':2);
end;
writeln('=========================================================');
writeln;
end;
4: begin
write('Masukan IPK : ');readln(mhs1.ipk);
writeln;
writeln('=======================================================');
writeln('|','Nama':20,'NIM':10,'Alamat':20,'IPK':10,'|':2);
writeln('=======================================================');
for i:=1 to n do
if (mhs1.ipk) = (mhs.ipk[i]) then
begin
writeln('|',mhs.nama[i]:20,mhs.nim[i]:10,mhs.alamat[i]:20,mhs1.ipk: 10:2,'|':2);
end;
writeln('=======================================================');
writeln;
end;
end;
write('Ingin mencari data lagi (y/n) ? ');readln(tekan);
writeln;
end;end;end;end;
{====================PROGRAM UTAMA========================}
BEGIN

32 Logika dan Algoritma

 clrscr;
data(data1,data2);
readln;
end.

Hasil Run Program :

Masukan jumlah mahasiswa : 4

Masukan data mahasiswa ke - 1
Nama Mahasiswa : Tumpal PS
No. Mahasiswa : 8051
Alamat Mahasiswa : KalBar
IPK : 3.5
Masukan data mahasiswa ke - 2
Nama Mahasiswa : Sri Sunarwati
No. Mahasiswa : 8244
Alamat Mahasiswa : Klaten
IPK : 3.4
Masukan data mahasiswa ke - 3
Nama Mahasiswa : Putu Eka A
No. Mahasiswa : 8239
Alamat Mahasiswa : Bali
IPK : 3.3
Masukan data mahasiswa ke - 4
Nama Mahasiswa : Timotius N
No. Mahasiswa : 8299
Alamat Mahasiswa : Tegal
IPK : 3.5
DATA MAHASISWA
=============================================
| No Nama NIM Alamat IPK |
=============================================
| 1 Tumpal PS 8051 KalBar 3.50 |
| 2 Sri Sunarwati 8244 Klaten 3.40 |
| 3 Putu Eka A 8239 Bali 3.30 |
| 4 Timotius N 8299 Tegal 3.50 |
=============================================

Ingin mencari data tertentu (y/n) ? y

MENU PILIHAN

[1] NAMA
[2] NIM
[3] ALAMAT
[4] IPK

Pilihan anda : 1
Masukan Nama Mahasiswa : Tumpal PS
==========================================
| Nama NIM Alamat IPK |

33 Logika dan Algoritma

 ==========================================
| Tumpal PS 8051 KalBar 3.50 |
==========================================
Ingin mencari data lagi (y/n) ? y
MENU PILIHAN
[1] NAMA
[2] NIM
[3] ALAMAT
[4] IPK
Pilihan anda : 2
Masukan No. Mahasiswa : 8299
=========================================
| Nama NIM Alamat IPK |
=========================================
| Timotius N 8299 Tegal 3.50 |
=========================================
Ingin mencari data lagi (y/n) ? y

MENU PILIHAN
[1] NAMA
[2] NIM
[3] ALAMAT
[4] IPK
Pilihan anda : 3
Masukan Alamat Mahasiswa : Bali
=========================================
| Nama NIM Alamat IPK |
=========================================
| Putu Eka A 8239 Bali 3.30 |
=========================================
Ingin mencari data lagi (y/n) ? y
MENU PILIHAN
[1] NAMA
[2] NIM
[3] ALAMAT
[4] IPK
Pilihan anda : 4
Masukan IPK : 3.4

=========================================
| Nama NIM Alamat IPK |
=========================================
| Sri Sunarwati 8244 Klaten 3.40 |
=========================================

PENGURUTAN (SORTING)

Pengurutan atau shorting merupakan proses untuk menyusun kembali kumpulan

entri-entri yang telah dimasukkan dengan suatu aturan tertentu. Secara umum ada 2

34 Logika dan Algoritma

macam pengurutan yaitu pengurutan secara menaik (ascenden) dan pengurutan secara
menurun (descenden).
Metode-metode pengurutan data :

1. METODE SELEKSI (SELECTION SORT)

Masukkan dinyatakan sebagai vector misal vector A (belum terurut), dan N (missal
banyak elemen yang akan diurutkan). Keluaran adalah vector A yang telah terurut.

Algoritma metode seleksi :

- langkah 0 : Baca vector yang akan diurutkan (dalam program utama)
- langkah 1 : Kerjakan langkah 2 sampai 4 untuk i = 1 sampai N -1
- langkah 2 : Tentukan awal = i , kerjakan langkah 3 untuk j = i +1 sampai N
- langkah 3 : (Mencari data terkecil)
Tes : apakah A[awal] > A[j], jika ya maka ubah awal = j
- langkah 4 : Tukarkan nilai A[awal] dengan A[i]
- langkah 5 : selesai

Contoh Program :

PROGRAM contoh;
USES CRT;
TYPE ArrInt = array [1..100] of real ;

PROCEDURE Tukar(var a,b : real);

var Bantu : real;
begin
Bantu := a;
a := b;
b := Bantu;
end;

PROCEDURE SelectionSort(var X : ArrInt; N : integer);

var i,j : integer;
begin
for i:=1 to N-1 do
for j := i+1 to N do
if x[i] > x[j] then
Tukar(x[i],x[j]);
end;

VAR
Data : ArrInt;
i,j,n : integer;

BEGIN
clrscr;

35 Logika dan Algoritma

 Writeln('Masukkan data anda !');writeln;
Write('Berapakah frekuensi data anda ? ');readln(n);
writeln('Silakan masukkan data yang Anda punya !');
for i:=1 to n do
begin
Write('Data ke-',i,' = ');readln(data[i]);
end;
SelectionSort(data,n);
for i:=1 to n do
write('(',data[i]:4:2,'),');
readln;
end.
Hasil Run Progam :
Masukkan data anda !

Berapakah frekuensi data anda ? 5

Silakan masukkan data yang Anda punya !
Data ke-1 = -2
Data ke-2 = -2.9
Data ke-3 = 31
Data ke-4 = 0
Data ke-5 = 1
(-2.90),(-2.00),(0.00),(1.00),(31.00)

2. METODE GELEMBUNG (BUBLE SORT)

Disebut juga dengan metode Penukaran (Exchange Sort), yaitu metoda yang
mendasarkan pada penukaran elemen untuk mencapai keadaan urut yang diinginkan.
Algoritma Metode gelembung :
- langkah 0 : Baca vector yang akan diurutkan (dalam program utama)
- langkah 1 : Kerjakan langkah 2 untuk i = 1 sampai N-1
- langkah 2 : Kerjakan langkah 3 untuk j = 1 sampai N- i
- langkah 3 : Tes apakah A[j] > A[j +1] ? Jika ya, tukarkan nilai kedua elemen
ini
- langkah 4 : Selesai

Contoh Program :
PROGRAM STATISTIK;
Uses Crt;
TYPE ArrInt = array [1..100] of integer;
PROCEDURE Tukar(var a,b : integer);
var Bantu : integer;
begin
Bantu := a;
a := b;
b := Bantu;
end;

36 Logika dan Algoritma

 PROCEDURE BubleSort(var X : ArrInt; N : word);
var i, j : word;
begin
for i:=1 to N-1 do
for j := 1 to N-i do
if x[j] > x[j+1] then
Tukar(x[j], x[j+1]) ;
end;

Var
Data: ArrInt ;
i, j, n: integer ;
Begin
clrscr;
writeln('Masukkan data anda !');writeln;
write('Berapakah frekuensi data anda ? ');readln(n);
writeln('Silakan masukkan data Anda !');
for i:=1 to n do
begin
Write('Data ke-',i,' = ');readln(data[i]);
end;
BubleSort(data,n);
write('Hasil Pengurutan data dengan BubleSort : ');
for i:=1 to n do
write(data[i]:3);
readln;
end.
Hasil Run Program :
Masukkan data anda !

Berapakah frekuensi data anda ? 5

Silakan masukkan data Anda !
Data ke-1 = 0
Data ke-2 = -1
Data ke-3 = 2
Data ke-4 = -10
Data ke-5 = 30
Hasil Pengurutan data dengan Gelembung : -10 -1 0 2 30

3. METODE SISIP LANGSUNG (STRAIGHT INSERTION)

Pada metode ini elemen terbagi menjadi 2 bagian yaitu kelompok sumber yang
merupakan susunan asli dari kelompok tersebut (belum terurut) yaitu dari A 1…..AN
dan kelompok yang kedua adalah kelompok tujuan yaitu susunan elemen yang telah
terurut dengan urutan dari A1….Ai -1. Langkah penyisipan dimulai dari i = 2 dengan

37 Logika dan Algoritma

 pertambahan 1. Elemen ke i diambil dari kelompok sumber dan akan dipindahkan ke
kelompok tujuan dengan cara menyisipkannya pada tempatnya yang sesuai.
Algoritma metode sisip langsung :
- langkah 0 : Baca vector yang akan diurutkan (dalam program utama)
- langkah 1 : Kerjakan langkah 2 sampai 5 untuk i = 2 sampai dengan N
- langkah 2 : Tentukan : T = A[i] (elemen yang akan disisipkan), A[0] = T (data
sentinel) dan j = i -1.
- langkah 3 : (lakukan pergeseran). Kerjakan langkah 4 selama T < A[j]
- langkah 4 : Tentukan : A[j + 1] = A[j] dan j = j -1.
- langkah 5 : Tentukan : A[j + 1] = T
- langkah 6 : Selesai

TIPE DATA POINTER

Pemakaian array tidak selalu tepat untuk program-program terapan yang

kebutuhan pengingatnya selalu bertambah selama eksekusi program tersebut. Untuk itu
diperlukan satu tipe data yang dapat digunakan untuk mengalokasikan (membentuk) dan
mendealokasikan (menghapus) pengingat secara dinamis, yaitu sesuai dengan kebutuhan
pada saat suatu program dieksekusi. Oleh karena itu akan dijelaskan suatu tipe data yang
dinamakan sebagai tipe Data Pointer.
Nama peubah yang kita gunakan untuk mewakili suatu nilai data sebenarnya
merupakan / menunjukkan suatu lokasi tertentu dalam pengingat computer di mana data
yang diwakili oleh tipe data tersebut disimpan. Pada saat sebuah program dikompilasi
maka compiler akan melihat pada bagian deklarasi peubah (Var) untuk mengetahui nama-
nama peubah apa saja yang digunakan, sekaligus mengalokasikan atau menyediakan
tempat dalam memory untuk menyimpan nilai data tersebut. Dari sini kita bisa melihat
bahwa sebelum program dieksekusi, maka lokasi-lokasi data dalam memory sudah
ditentukan dan tidak dapat diubah selama program tersebut dieksekusi. Peubah-peubah
yang demikian itu dinamakan sebagai Peubah Statis (Static Variable).
Dari pengertian diatas kita perhatikan bahwa sesudah suatu lokasi pengingat
ditentukan untuk suatu nama peubah maka dalam program tersebut peubah yang
dimaksud akan tetap menempati lokasi yang telah ditentukan dan tidak mungkin diubah.
Dengan melihat pada sifat-sifat peubah statis maka bisa dikatakan bahwa banyaknya data
yang bisa diolah adalah sangat terbatas. Misalnya peubah dalam bentuk Array yang
dideklarasika sbb : Var matriks: array[1..100,1..100] of integer; maka peubah
tersebut hanya mampu menyimpan data sebanyak 100x100=10000 buah data. Jika kita
tetap nekat memasukkan data pada peubah tersebut setelah semua ruangnya penuh maka
eksekusi program akan terhenti dan muncul error. Memang kita

dapat mengubah deklarasi program diatas dengan memperbesar ukurannya. Tetapi jika
setiap kali kita harus mengubah deklarasi dari tipe daa tersebut sementara, banyaknya
data tidak dapat ditentukan lebih dahulu, maka hal ini tentu merupakan pekerjaan yang
membosankan.

38 Logika dan Algoritma

 Sekarang bagaimana jika kita ingin mengolah data yang banyaknya kita tidak
yakin sebelumnya bahwa larik yang telah kita deklarasikan sebelumnya mampu
menampung data yang kita miliki ?
Untuk menjawab pertanyaan di atas maka pascal menyediakan satu fasilitas yang
memungkinkan kita untuk menggunakan suatu peubah yang disebut dengan Peubah
Dinamis (Dynamic Variable). Peubah dinamis adalah peubah yang dialokasikan hanya
pada saat diperlukan, yaitu setelah program dieksekusi. Dengan kata lain, pada saat
program dikompilasi, lokasi untuk peubah belum ditentukan sebagai peubah dinamis.
Hal ini membawa keuntungan pula, bahwa peubah-peubah dinamis tersebut dapat
dihapus pada saat program dieksekusi sehingga ukuran memory selalu berubah. Hal
inilah yang menyebabkan peubah tersebut dinamakan sebagai peubah dinamis.
Pada peubah statis, isi dari peubah adalah data sesungguhnya yang akan diolah.
Pada peubah dinamis nilai peubah adalah alamat lokasi lain yang menyimpan data
sesungguhnya. Dengan demikian data yang sesungguhnya tidak dapat dimasup secara
langsung. Oleh karena itu, peubah dinamis dikenal dengan sebutan POINTER yang
artinya menunjuk ke sesuatu. Dalam peubah dinamis, nilai dari data yang ditunjuk oleh
suatu pointer biasanya disebut Simpul / node.

Dekarasi Pointer dan Alokasi Tempat

Bentuk umum deklarasi pointer :

Type Pengenal = ^simpul ;

Simpul = tipe data ;

dengan pengenal : nama pengenal yang menyatakan tipe data pointer

simpul : nama simpul
tipe data : tipe data dari simpul

Tanda ^ di depan simpul harus ditulis apa adanya karena itu menunjukkan
bahwa pengenal bertipe pointer. Tipe data dari simpul dapat berupa tipe data sebarang,
misalnya char, integer, atau real.

Contoh :
Type Str30 = string[30] ;
Point = ^Data ;
Data = record
Nama_Peg : Str30 ;
Alamat : Str30 ;
Pekerjaan : Str30 ;
End ;
Var
P1, P2 : Point ;
A, B, C : Str30 ;

Mengakses Data Dalam Tipe Data Pointer

39 Logika dan Algoritma

 Pada saat program dikompilasi maka P1 dan P2 akan menempati lokasi tertentu
dalam memory. Kedua peubah ini masing-masing belum menunjuk ke suatu simpul atau
nilainya dinyatakan dengan NIL. Oleh karena itu sebelum diakses varabel yang bertipe
pointer harus dipersiapkan terlebih dahulu, yaitu dengan menggunakan perintah NEW.
Deklarasi : NEW(peubah bertipe pointer);
Contoh :
New(P1); New(P2);
Maka sekarang kita mempunyai dua buah simpul yang ditunjuk oleh P1 dan P2. Setelah
itu kita dapat melakukan pengaksesan data, yaitu dengan menuliskan :
P1^.Nama_Peg := ‘Ariswan’;
P1^.Alamat := ‘Semarang’;
P1^.Pekerjaan := ‘Pengajar’;
Jika statemen New(P1)diulang beberapa kali maka hanya simpul yang terakhir
yang bisa dimasup. Hal ini terjadi karena setiap kali kita memberikan statemen New(P1)
maka nilai P1 yang lama akan terhapus. Dengan terhapusnya nilai P1 maka secara
otomatis simpul yang ditunjuk oleh P1 tidak ditunjuk lagi dan tidak ditunjuk pula oleh
pointer yang lain sehingga karena alamatnya tidak dapat ditentukan maka simpul tersebut
tidak dapat dimasup lagi.
Dari sini dapat dilihat bahwa sifat kedinamisan pointer agak tersamar, disebabkan
apabila kita menghendaki sejumlah simpul aktif dalam pengingat maka kita perlu
menyediakan sejumlah pointer yang sesuai untuk masing-masing simpul. Oleh karena itu,
apabila kita hendak mempunyai sebuah peubah yang benar-benar dinamis maka peubah
itu harus mampu memasup sejumlah lokasi tertentu.
Untuk itu akan diperkenalkan apa yang dinamakan sebagai Senarai Berantai
(Linked List).

Operasi Pada Pointer

Secara umum ada 2 operasi yang dapat dilakukan dengan tipe data pointer, yaitu :
1. Mengkopy pointer, sehingga sebuah simpul akan ditunjuk oleh lebih dari sebuah
pointer
2. Mengkopy isi dari simpul, sehingga dua atau lebih simpul yang ditunjuk oleh
pointer yang berbeda mempunyai isi yang sama

Catatan :
Syarat yang harus dipenuhi oleh kedua operasi tersebut adalah bahwa pointer-pointer
yang akan dioperasikan harus mempunyai deklarasi yang sama.
 Jika dalam statemen pemberian tanda ^ tidak diberikan maka operasinya
dinamakan sebagai mengkopi pointer, dengan konsekuensi simpul yang ditunjuk
oleh suatu pointer akan bisa terlepas dan tidak dapat dimasup lagi.
Contoh : P1 := P2 ;

 Jika tanda ^ diberikan maka operasinya dinamakan sebagai operasi mengkopi isi
simpul pointer, dengan konsekuensi bahwa isi dua buah simpul atau lebih akan
menjadi sama.
Contoh : P1^ := P2^ ;

40 Logika dan Algoritma

Menghapus Pointer
Statement yang digunakan untuk menghapus pointer adalah Dispose, yang
mempunyai bentuk umum :
Dispose(peubah) ;
dengan : peubah = sebarang peubah yang bertipe pointer.
Catatan :
Setelah suatu pointer dihapus maka lokasi yang semula ditempati oleh simpul
yang ditujuk oleh pointer tersebut akan bebas, sehingga bisa digunakan oleh peubah yang
lain.

SENARAI BERANTAI ( LINKED LIST )

Cara lain untuk menyimpan sekumpulan data selain dengan menggunakan record
adalah dengan menggunakan bantuan tipe data pointer. Dalam hal ini, masing-masing
data dengan sebuah medan yang bertipe pointer perlu digunakan.
Salah satu struktur data dinamis yang paling sederhana adalah Senarai Berantai
(Linked List). Yaitu kumpulan komponen (node) yang disusun secara berurutan dengan
menggunakan bantuan pointer. Node ini terbagi menjadi dua bagian yaitu bagian medan
informasi, yang berisi informasi yang akan disimpan atau diolah dan bagian penyambung
(link field), yang berisi alamat simpul selanjutnya.

Operasi Pada Senarai Berantai :

1. Menambah Simpul di Belakang

Misal dideklarasikan:
Type Point = ^Data ;
Data = record
Info : char ;
Berikut : Simpul
End;
Var Elemen : char ;
Awal, Akhir, Baru : Simpul ;

Untuk menyambung simpul yang ditunjuk oleh Akhir dan Baru maka pointer pada
simpul yang ditunjuk oleh Akhir dibuat sama dengan Baru , kemudian diubah pointer
Akhir sama dengan Baru.

Procedure Tambah_Belakang(Awal,Akhir,Elemen:
Data);
Var Baru : point;
Begin
New(Baru); Baru^.Info := elemen;
If Awal = NIL then
Awal:= Baru
Else Akhir^.Berikut := Baru;
Akhir:= Baru; Akhir^.Berikut:= NIL;
End;

41 Logika dan Algoritma

2. Menambah Simpul di Depan
Pertama kali pointer pada simpul yang ditunjuk oleh pointer Baru dibuat sama
dengan Awal. Kemudian Awal dibuat sama dengan Baru. Dengan cara ini maka simpul
baru akan selalu diperlakukan sebagai simpul pertama dalam senarai.

Procedure Tambah_Depan(var Awal,Akhir: point;

Elemen:Data);
Var Baru : point;
Begin
New(Baru); Baru^.Info :=Elemen;
If Awal= NIL then Akhir:= Baru
Else Baru^.Berikut:= Awal;
Awal := Baru;
End;

3. Menambah/ menyisipkan Simpul di Tengah

Untuk menambah simpul ditengah maka kita perlu sebuah pointer lain misal
dinamakan Bantu. Dalam hal ini simpul baru akan diletakkan setelah simpul yang
ditunjuk oleh pointer Bantu. Pertama kali ditentukan dimana simpul baru akan
ditempatkan. Kemudian pointer pada simpul yang ditunjuk oleh Baru dibuat sama dengan
pointer pada simpul yang ditunjuk oleh Bantu. Selanjutnya pointer pada simpul yang
ditunjuk oleh simpul Bantu dibuat sama dengan Baru. Urutan kedua proses ini tidak
boleh dibalik.

Procedure Tambah_Tengah(Var Awal,Akhir: point; Elemen:

Dat);
Var Baru,Bantu : point;
Begin
New(Baru); Baru^.Berikut:= Elemen;
If Awal = NIL then
Begin
Awal:= Baru; Akhir:= Baru;
End
Else
Begin
Bantu:= Awal;
While (Elemen > Bantu^.Berikut^.Info) and (Bantu
<> NIL) then
Bantu:= Bantu^.Berikut;
Baru^.Berikut:= Bantu^.Berikut;
Bantu^.Berikut:= Baru;
End;
End;

4. Menghapus Simpul Pertama

42 Logika dan Algoritma

 Simpul yang dapat dihapus oleh operasi penghapusan simpul adalah simpul yang
berada sesudah simpul yang ditunjuk oleh suatu pointer, kecuali untuk simpul pertama.
Untuk menghapus simpul pertama, maka pointer Bantu kita buat sama dengan
pointer Awal. Kemudian pointer Awal kita pindah dari simpul yang ditunjuk oleh pointer
Bantu. Selanjutnya, simpul yang ditunjuk oleh pointer Bantu kita Dispose.

Procedure Hapus_Awal_Simpul(var Awal, Akhir: point; Elemen:

Dat);
Var Hapus: point;
Begin
Awal:= Awal^.Berikut;
Dispose(Hapus);
End;

5. Menghapus Simpul di Tengah atau Terakhir

Pertama kita letakkan pointer Bantu pada simpul di sebelah kiri simpul yang akan
dihapus. Simpul yang akan dihapus kita tunjuk dengan pointer lain, misalnya Hapus.
Kemudian pointer pada simpul yang ditunjuk oleh Bantu kita tunjukkan pada simpul
yang ditunjuk oleh pointer pada simpul yang akan dihapus. Selanjutnya simpul yang
ditunjuk oleh pointer Hapus kita Dispose.

Procedure Hapus_Awal_Simpul(var Awal, Akhir: point; Elemen:

Dat);
Var Bantu, Hapus : point;
Begin {senarai masih kosong}
If awal= NIL then
Writeln(‘Searai berantai masih kosong !’)
Else
Begin {menghapus simpul diawal}
Hapus:= Awal;
Awal:= Hapus^.Berikut;
Dispose(Berikut);
End
Else {menghapus simpul ditengah atau akhir}
Begin
Bantu:= Awal;
While (Elemen <> Bantu^.info) and (Bantu^.Next
<> NIL) do
Bantu:= Bantu^.Berikut;
Hapus:= Bantu^.Berikut;

If Hapus <> NIL then

Begin
If Hapus = Akhir then
Begin

43 Logika dan Algoritma

 Akhir:= Bantu;
Akhir^.Berikut:= NIL;
End
Else Bantu^.Berikut:= Hapus^.Berikut;
Dispose(Hapus);
End
Else writeln(‘Tidak ketemu yang dihapus !!’);
End;
End;

6. Membaca Isi Senarai Berantai secara Maju

Pertama kali kita atur supaya pointer Bantu menunjuk ke simpul yang ditunjuk
oleh pointer Awal. Setelah isi simpul itu dibaca, maka pointer Bantu kita gerakkan ke
kanan untuk membaca simpul berikutnya. Proses ini kita ulang sampai pointer Bantu
sama dengan pointer Akhir.

Procedure Baca_Maju(Awal,Akhir : point);

Var Bantu : point;
Begin
Bantu:= Awal;
Repeat
Write(Bantu^.info:2);
Bantu:= Bantu^.Berikut;
Until Bantu = NIL;
Writeln;
End;

7. Membaca Isi Senarai Berantai secara Mundur

Ada 2 cara membaca mundur isi dari Senarai Berantai, yaitu dengan cara biasa
seperti diatas atau dengan memanfaatkan proses rekursi. Cara pertama yaitu kita atur
pointer Bantu sama dengan pointer Awal. Berikutnya, pointer awal kita arahkan ke
simpul Akhir dan kita pakai pointer lain misalkan Bantu1 untuk bergerak dari simpul
pertama sampai simpul sebelum simpul terakhir. Langkah selanjutnya adalah
mengarahkan medan pointer dari simpul terakhir ke simpul Bantu1. Langkah ini diulang
sampai pointer Akhir Berimpit dengan pointer Bantu. Cara kedua dengan rekursi.
Caranya hampir sama dengan cara membaca senarai berantai secara maju hanya saja
pencetakan isi simpul ditunda sampai pointer Bantu sama dengan pointer akhir.

Procedure Baca_Terbalik(var Awal,Akhir: point);

Var Bantu,Bantu1 : point;

44 Logika dan Algoritma

 Begin
Bantu:= Awal;
Awal:= Akhr;
Repeat
Bantu1:=Bantu;
While Bantu1^.Berikut <> Akhir do
Bantu1:= Bantu1^.Berikut;
Akhir^.Berikut:= Bantu1;
Akhir:= Bantu1;
Until Akhir = Bantu;
Akhir^.Berikut:= NIL;
End;
Dengan cara rekursi :

Procedure Terbalik(Bantu: point);

Begin
If Bantu <> NIL then
Begin
TERBALIK(Bantu^.Berikut);
Write(Bantu^.Info:2);
End;
End;

8. Mencari Data dalam Senarai Berantai

Misalkan data yang dicari disimpan dalam peubah Elemen. Pertama kali, pointer
Bantu dibuat sama dengan pointer Awal. Kemudan isi simpul yang ditunjuk oleh pointer
Bantu dibandingkan dengan Elemen. Jika belum sama, maka pointer Bantu dipindah ke
simpul disebelah kanannya dan proses perbandingan diulang lagi sampai bisa ditentukan
apakah Elemen ada dalam senarai berantai yang dimaksud atau tidak.

Function Cari_Data(Awal: point; Elemen : Dat): Boolean;

Var ketemu: Boolean;
Begin
Ketemu: false;
Repeat
If Awal^.info = Elemen then
Ketemu:= true
Else
Awal:= Awal^.Berikut;
Until (ketemu) or (Awal = NIL);
Cari_Data:= ketemu;
end;

NILAI

45 Logika dan Algoritma

TUGAS 10 %
QUIZ 10%
KEHADIRAN 10 %
MID 30 %
UAS 40%

46 Logika dan Algoritma