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

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

a. 1. = , mempunyai sisa r =
16,

2. r = 16 0

3. m = 20 dan n = 16

b. 1. = mempunyai sisa r = 4,

2.
r = 4 0

3. m =16 dan n = 4

c. 1. mempunyai sisa r = 0,

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 :

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

Judul program (opsional)
Format : { judul program } atau program_nama program;

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.

Program Utama
Diawali dengan Begin dan
diakhiri dengan End.

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 : = , , > , = , 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

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

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

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 0

N!
= N (N-1) (N-2)!

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

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

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;

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

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 |

==========================================

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

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;

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 A1…..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 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 Bantu^.Berikut^.Info) and (Bantu NIL) then

Bantu:= Bantu^.Berikut;

Baru^.Berikut:= Bantu^.Berikut;

Bantu^.Berikut:= Baru;

End;

End;

4. Menghapus Simpul Pertama

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

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;

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;

sumber : myblog