LAPORAN PRAKTIKUM

DASAR PEMROGRAMAN

Semester 1 Tahun Akademik 2020/2021

Disusun Untuk Memenuhi Tugas Mingguan Mata Kuliah Praktikum Dasar
Pemrograman

Oleh :
Nama : Raihan Azhar Lapandu
NPM : 207006044

LABORATORIUM INFORMATIKA
PROGRAM STUDI INFORMATIKA
FAKULTAS TEKNIK UNIVERSITAS SILIWANGI
TASIKMALAYA
2020
MODUL 10
SORTING
TUJUAN PRAKTIKUM
1. Memahami metode-metode sorting
2. Menggunakan metode sorting untuk keperluan pemrograman

DASAR TEORI
Sorting atau pengurutan data adalah proses untuk menyusun kumpulan data yang seragam
menjadi susunan tertentu. Kumpulan data dapat diurutkan secara Ascending(Urut Menaik), yaitu dari
data yang nilainya paling kecil sampai data yang nilainya paling besar, atau diurutkan secara
Descending(Urut Menurun), yaitu dari data yang nilainya paling besar sampai data yang nilainya
paling kecil.

Metode-metode Sorting :
1. Bubble Sort
Pengurutan model ini mengambil ide dari gelembung air, yaitu mengapungkan elemen yang
bernilai kecil dari bawah ke atas. Proses pengapungan dilakukan dengan pertukaran elemen-elemen
tabel.
Apabila kita menginginkan array terurut menaik, maka elemen array yang berharga paling kecil
”diapungkan” artinya diangkat ke ”atas” (atau ke ujung kiri array) melalui proses pertukaran. Proses
pengapungan ini dilakukan sebanyak n-1 langkah(satu langkah disebut satu kali pass) dengan n
adalah ukuran array.

Ilustrasi Kasus :
Perhatikan array TabInt di bawah ini yang terdiri dari n = 6 elemen yang belum terurut. Array
ini akan diurutkan menaik dengan metode Bubble Sort.
Elemen Array 25 27 10 8 76 21
Indeks 1 2 3 4 5 6

 Arah pembandingan

1
 2

Pass 1 : Pass 2 : (Berdasarkan hasil akhir Pass 1)

25 27 10 8 21 76 8 25 27 10 21 76
1 2 3 4 5 6
8 25 27 10 21 76
25 27 10 8 21 76
8 25 10 27 21 76
25 27 8 10 21 76
8 10 25 27 21 76
25 8 27 10 21 76
Hasil akhir Pass 2 :
8 25 27 10 21 76 8 10 25 27 21 76
1 2 3 4 5 6
Hasil Akhir Pass 1 :

8 25 27 10 21 76
1 2 3 4 5 6

Pass 3 : (Berdasarkan Hasil Akhir Pass 2) Pass 4 : (Berdasarkan Hasil Akhir Pass 3)
8 10 25 27 21 76
8 10 21 25 27 76

8 10 25 21 27 76
8 10 21 25 27 76

8 10 21 25 27 76
Hasil Akhir Pass 4 :
Hasil Akhir Pass 3 : 8 10 21 25 27 76
8 10 21 25 27 76 1 2 3 4 5 6

1 2 3 4 5 6

Pass 5 : (Berdasarkan Hasil Akhir Pass 4)

8 10 21 25 27 76

Hasil Akhir Pass 5 :

8 10 21 25 27 76
1 2 3 4 5 6

Hasil akhir Pass 5 menyisakan satu elemen yang

tidak perlu diurutkan lagi maka pengurutan selesai

Keterangan :
: Bagian data yang sudah diurutkan/diapungkan
: Bagian data yang dibandingkan dan mungkin ditukarkan posisinya
 3

Algoritma 10.1 Procedure Bubble Sort

Procedure BubbleSort(input n:integer,input/output T:TabInteger)
{Mengurutkan Tabel Integer[1..N] dengan Bubble Sort}
Kamus
pass : integer {pencacah untuk jumlah langkah}
k : integer {pencacah pengapungan untuk setiap langkah}
temp : integer {variabel bantu untuk pertukaran}
Algoritma
for pass  1 to (n-1) do
for k  n downto (pass+1) do
if (T[k] < T[k-1]) then
{pertukarkan T[k] dengan T[k-1]}
temp  T[k]
T[k]  T[k-1]
T[k-1]  temp
endif
endfor
endfor

Program 10.1 Implementasi Program Bubble Sort

Program Bubble_Sort;
uses crt;
const Nmax=100;
type
TabInteger = array[1..NMax] of integer;
var
TabInt : TabInteger;
jml_data : integer;
procedure InputData(n : integer; var T : TabInteger);
var
i : integer;
begin
for i:=1 to n do
begin
write('Nilai ke - ',i,' : '); readln(T[i]);
end;
end;
procedure BubbleSort(n : integer; var T : TabInteger);
var
pass, k, temp : integer;
begin
for pass:=1 to (n-1) do
for k:=n downto (pass+1) do
if T[k] < T[k-1] then
begin
temp := T[k];
T[k] := T[k-1];
T[k-1] := temp;
end;
{endfor}
{endfor}
 4

end;
begin
clrscr;
write('Banyaknya integer : ');readln(jml_data);
InputData(jml_data,TabInt); writeln;
BubbleSort(jml_data,TabInt); {memanggil Prosedur BubbleSort}
readln;
end.
Contoh Tampilan Pada Layar
{Kasus 1}

Analisis
Pada program ini, kita dikenalkan dengan proses ‘Sorting’ yaitu perintah untuk
mengurutkan data, entah itu dari terkecil ke terbesar (menaik) ataupun terbesar ke terkecil
(menurun). Pertama yang kita lakukan adalah membuat sebuah ‘array’ untuk menampung
data yang ingin diurutkan. Nama arraynya adalah ‘TabInteger’. Setelah itu, kita
menentukan variabel yang akan digunakan di program pada bagian ‘var’, yaitu ada
‘TabInt:TabInteger, jml_data:integer,’. Kemudian dibuat ‘procedure’ berjudul
‘InputData’ untuk memberi input kepada user memasukkan data-data yang ingin
diurutkan. Dibuat lagi procedure berjudul ‘BubbleSort’ untuk menampung rumus
pengurutan secara Bubble Sort (Pengurutan model ini mengambil ide dari gelembung air,
yaitu mengapungkan elemen yang bernilai kecil dari bawah ke atas. Proses pengapungan
dilakukan dengan pertukaran elemen-elemen tabel). Dalam procedure ini, parameter
inputnya yaitu ‘n:integer; var T:TabInteger;’. Lalu variabel dalam procedurenya
didefinisikan yaitu ‘pass,k,temp:integer’. Terakhir, ditulis rumus bubble sortingnya, yaitu
‘for pass:=1 to (n-1) do for k:=n downto (pass+1) do if T[k] < T[k-1] then
begin temp := T[k]; T[k] := T[k-1]; T[k-1] := temp; end;’. Procedure kemudian di ‘end’
dan dilanjut ke program utama dengan perintah ‘begin’. Diberi input bagi user untuk
memasukkan jumlah bilangan yang ingin dimasukkan. Setelah itu, dipanggil procedure
InputData yang telah dibuat sebelumnya, setelah itu dipanggil lagi procedure BubbleSort.
Outputnya berupa bilangan-bilangan yang telah diurutkan dari kecil ke besar.
 5

Program Bubble_Sort memanggil dua prosedur yaitu prosedur InputData(dengan parameter

jml_data sebagai input untuk parameter input n dan TabInt sebagai output untuk parameter
output T) dan prosedur BubbleSort(dengan jml_data sebagai input untuk parameter input n
dan TabInt sebagai input sekaligus output untuk parameter input/output T )

2. Maximum Sort
Pengurutan model ini dilakukan dengan mencari nilai terbesar/maksimum dari suatu array.
Nilai terbesar tersebut kemudian disimpan di awal array(jika diurutkan menurun) atau di akhir
array(jika diurutkan menaik) dan diisolasi agar tidak disertakan lagi pada proses selanjutnya.
Ilustrasi Kasus :
Perhatikan array TabInt di bawah ini yang terdiri dari n = 6 elemen yang belum terurut.
Array ini akan diurutkan menaik dengan metode Bubble Sort.
Elemen Array 29 27 10 8 76 21
Indeks 1 2 3 4 5 6

Pass 1 :
Cari elemen maksimum di dalam array TabInt[1..n]  maks = TabInt[5] = 76
Pertukarkan TabInt[5] dengan TabInt[n]
Proses Pertukaran Hasil Akhir Pass 1
29 27 10 8 76 21 29 27 10 8 21 76
Pass 2 : (Berdasarkan sususan Array hasil Pass 1)
Cari elemen maksimum di dalam array TabInt[1..5]  maks = TabInt[1] = 29
Pertukarkan TabInt[1] dengan TabInt[5]
29 27 10 8 21 76 21 27 10 8 29 76

Pass 3 : (Berdasarkan sususan Array hasil Pass 2)

Cari elemen maksimum di dalam array TabInt[1..4]  maks = TabInt[2] = 27
Pertukarkan TabInt[2] dengan TabInt[4]
 6

21 27 10 8 29 76 21 8 10 27 29 76

Pass 4 : (Berdasarkan sususan Array hasil Pass 3)

Cari elemen maksimum di dalam array TabInt[1..3]  maks = TabInt[1] = 21
Pertukarkan TabInt[1] dengan TabInt[3]
21 8 10 27 29 76 10 8 21 27 29 76

Pass 5 : (Berdasarkan sususan Array hasil Pass 4)

Cari elemen maksimum di dalam array TabInt[1..2]  maks = TabInt[1] = 10
Pertukarkan TabInt[1] dengan TabInt[2]
10 8 21 27 29 76 8 10 21 27 29 76

Terisa satu elemen yaitu 8, maka pengurutan dihentikan. Array sudah terurut menaik
Keterangan :
: Bagian data yang sudah diurutkan
: Bagian data yang terbesar dan posisi yang akan ditukarkan dengan data terbesar

Algoritma 10.2 Procedure Pengurutan dengan Metode Maximum Sort secara Menaik
Procedure MaxSort(input n:integer,input/output T:TabInteger)
{Mengurutkan Tabel Integer[1..N] dengan Maximum Sort}
Kamus
i : integer {pencacah untuk jumlah langkah}
k : integer {pencacah untuk mencari nilai maksimum}
imaks: integer {indeks yang berisi nilai maksimum sementara}
temp : integer {variabel bantu untuk pertukaran}
Algoritma
for i  n downto 2 do
imaks  1
for k  1 to (i-1) do
if (T[k] > T[imaks]) then
imaks  k
endif
endfor
{pertukarkan T[i] dengan T[imaks]}
temp  T[i]
T[i]  T[imaks]
T[imaks]  temp
endfor

3. Minimum Sort
Berbeda dengan algoritma pengurutan Maksimum, pada algoritma pengurutan minimum, basis
pencarian adalah elemen minimum. Pengurutan model ini dilakukan dengan mencari nilai
terkecil/minimum dari suatu array. Nilai terkecil tersebut kemudian disimpan di awal array(jika
 7

diurutkan menaik) atau di akhir array(jika diurutkan menurun) dan diisolasi agar tidak disertakan
lagi pada proses selanjutnya.
Algoritma 10.3 Procedure Pengurutan dengan Metode Minimum Sort secara Menaik
Procedure MinSort(input n:integer,input/output T:TabInteger)
{Mengurutkan Tabel Integer[1..N] dengan Minimum Sort}
Kamus
i : integer {pencacah untuk jumlah langkah}
k : integer {pencacah untuk mencari nilai minimum}
imin : integer {indeks yang berisi nilai minimum sementara}
temp : integer {variabel bantu untuk pertukaran}
Algoritma
for i  1 to (n-1) do
imin  i
for k  (i+1) to n do
if (T[k] < T[imin]) then
imin  k
endif
endfor
{pertukarkan T[i] dengan T[imin]}
temp  T[i]
T[i]  T[imin]
T[imin]  temp
endfor

LATIHAN
1. Buat kembali program 2.1 (Implementasi Program Bubble Sort) untuk memperoleh array yang
elemen-elemennya terurut menurun!
2. Buatlah program yang dapat mengurutkan data yang terdiri dari Nim, Nama, Nilai diurutkan
berdasarkan NIM!(Gunakan metode Bubble Sort)!
3. Implementasikan procedure MaxSort pada Algoritma 2.2 ke dalam Procedure dalam Bahasa
Pascal kemudian buat program yang memanggil procedure tersebut untuk pengurutan data!
4. Implementasikan procedure MinSort pada Algoritma 2.3 ke dalam Procedure dalam Bahasa
Pascal kemudian buat program yang memanggil procedure tersebut untuk pengurutan data!
5. Revisilah program untuk Latihan nomor 3 sehingga dapat digunakan untuk mengurutkan data
secara menurun!
6. Revisilah program untuk nomor 2 dengan menggunakan metode Maksimum Sort atau
Minimum Sort dan menambahkan menu :
a. Input data
b. Seach : Search berdasarkan nim(dengan Binary Search)
7. Pada diktat kuliah Algoritma dan Pemrograman implementasikan latihan soal no.3 dan no.4
pembuatan algoritma Sorting yang sudah anda buat ke dalam program, hasilnya masukan dalam
laporan praktikum untuk pertemuan modul ini.
 8

Jawaban :

1. Modul10Latihan1.pas

program bubblesortmenurun;
uses crt;
var i,n,j : integer;
a: array [1..100] of integer;
procedure bubble;
var z: integer;
begin
for i:= 1 to n-1 do
begin
for j:= n downto i+1 do
begin
if a[j] > a[j-1] then
begin
z:= a[j];
a[j]:= a[j-1];
a[j-1]:=z;
end;
end;
end;
end;
begin
clrscr;
write('Banyaknya Integer : '); readln(n);
for i:= 1 to n do
begin write('Nilai ke - ',i,' : '); readln(a[i]);
end;
bubble;
write('Data setelah diurutkan secara menurun (descending) : ');
for j:=1 to n do
write (a[j],' ');
readln;
end.

Contoh Tampilan Pada Layar

{Kasus 1}
 9

Analisis
Di program ini, syntax nya sama dengan program 10.1 sebelumnya, hanya ada perbedaan
di rumus BubbleSort nya agar pengurutannya menurun (perbedaannya yang di warnai
merah). Pertama yang kita lakukan adalah membuat sebuah ‘array’ untuk menampung
data yang ingin diurutkan. Nama arraynya adalah ‘TabInteger’. Setelah itu, kita
menentukan variabel yang akan digunakan di program pada bagian ‘var’, yaitu ada
‘TabInt:TabInteger, jml_data:integer,’. Kemudian dibuat ‘procedure’ berjudul
‘InputData’ untuk memberi input kepada user memasukkan data-data yang ingin
diurutkan. Dibuat lagi procedure berjudul ‘BubbleSort’ untuk menampung rumus
pengurutan secara Bubble Sort (Pengurutan model ini mengambil ide dari gelembung air,
yaitu mengapungkan elemen yang bernilai kecil dari bawah ke atas. Proses pengapungan
dilakukan dengan pertukaran elemen-elemen tabel). Dalam procedure ini, parameter
inputnya yaitu ‘n:integer; var T:TabInteger;’. Lalu variabel dalam procedurenya
didefinisikan yaitu ‘pass,k,temp:integer’. Terakhir, ditulis rumus bubble sortingnya, yaitu
‘for pass:=1 to (n-1) do for k:=n downto (pass+1) do if T[k] > T[k-1] then
begin temp := T[k]; T[k] := T[k-1]; T[k-1] := temp; end;’. Procedure kemudian di ‘end’
dan dilanjut ke program utama dengan perintah ‘begin’. Diberi input bagi user untuk
memasukkan jumlah bilangan yang ingin dimasukkan. Setelah itu, dipanggil procedure
InputData yang telah dibuat sebelumnya, setelah itu dipanggil lagi procedure BubbleSort.
Outputnya berupa bilangan-bilangan yang telah diurutkan dari besar ke kecil.

2. Modul10Latihan2.pas

program sortdatamahasiswa;
uses crt;
type mahasiswa = record
nim,nama:string;
umur:byte;
nilai:byte;
end;
mhsw=array[1..100] of mahasiswa;
var
data:mhsw;
n,k,i :integer;
pilih :char;
procedure input;
begin
inc(n);
clrscr;
writeln('---------------------------------------------');
writeln(' Masukkan Data ');
writeln('---------------------------------------------');
writeln('Nama : ');
writeln('NIM : ');
writeln('Nilai : ');
writeln('---------------------------------------------');
gotoxy(18,4);readln(data[n].nama);
gotoxy(18,5);readln(data[n].nim);
gotoxy(18,6);readln(data[n].nilai);
end;
procedure swap (var i,j:byte );
var temp:byte;
begin
begin
temp:=j;
j:=i;
i:=temp;
end;
end;
procedure swap2 (var i,j:string);
 10

var temp:string;
begin
begin
temp:=j;
j:=i;
i:=temp;
end;
end;
procedure buble2(m:byte; a:mhsw;var b:mhsw);
var
i,j:byte;
begin
for i:=m downto 2 do
begin
for j:=1 to i-1 do
if a[j].nim>a[j+1].nim then
begin
swap2(a[j].nim,a[j+1].nim);
swap2(a[j].nama,a[j+1].nama);
swap (a[j].nilai,a[j+1].nilai);
end;
end;
b:=a;
end;
procedure laporan;
var v:byte;
begin
for v:=1 to n do
begin
writeln('Data ke ',v);
writeln('NIM : ',data[v].nim);
writeln('Nama : ',data[v].nama);
writeln('Nilai : ',data[v].nilai);
writeln;
end;
readln;
end;
procedure menu;
begin
clrscr;
writeln(' Menu');
writeln('--------------------');
writeln('[1] - Input Data');
writeln('[2] - Sorting NIM');
writeln('[3] - Keluar');
write('Pilihan [1..3] : ');pilih:=readkey;
case pilih of
'1':input;
'2':begin
buble2(n,data,data);
clrscr;
writeln(' Sorting NIM');writeln;
laporan;
writeln('Sorting selesai, Tekan ENTER');
readln;
end;
'3':;
end;
end;
begin
 11

n:=0;
repeat
menu;
until pilih='3';
end.
Contoh Tampilan Pada Layar
{Kasus 1}

{Kasus 2}

{Kasus 3}
 12

Analisis
Pada program ini, kita menggunakan fungsi ‘BubbleSort’ untuk mengurutkan data-data
mahasiswa berdasarkan NIM. Pertama kita membuat sebuah ‘record’ dengan nama
‘mahasiswa’ bertipe ‘nim,nama:string; umur,nilai:byte’. Kemudian dibuat ‘array’
dengan nama ‘mhsw’ bertipe record mahasiswa tadi. Setelah itu didefiniskan variabel pada
bagian ‘var’ berupa ‘data:mhsw; n,k,i:integer; pilih:char;’. Lalu, ada beberapa
procedure yang dibuat untuk menampung beberapa rumus dan inputan. Pertama, ada
procedure berjudul ‘swap’ yang berfungsi untuk menukarkan integer, yang nantinya akan
digunakan dalam procedure sorting. Kedua, ada procedure berjudul ‘swap2’ untuk
menukarkan integer berupa nilai mahasiswa. Ketiga, ada procedure berjudul ‘buble2’
untuk menampung rumus bubblesort. Yang di sort disini adalah berdasarkan NIM dari
Mahasiswa yang diurut secara Bubble Sort menaik. Singkatnya, rumus bubble sort nya
adalah ‘for i:=m downto 2 do begin for j:=1 to i-1 do if a[j].nim>a[j+1].nim then begin
swap2(a[j].nim,a[j+1].nim); swap2(a[j].nama,a[j+1].nama); swap
(a[j].nilai,a[j+1].nilai); end; end; b:=a; end;’. Keempat ada procedure berjudul
‘laporan’ yang berfungsi sebagai penampil output dari hasil sorting data Mahasiswa. Yang
ditampilkan adalah Indeks datanya, NIM, Nama, dan Nilai mahasiswa. Terakhir, ada
procedure yang berjudul ‘menu’ yang sesuai namanya, menampilkan menu yang terdiri
dari ‘[1] Input Data; [2] Sorting NIM; [3] Keluar;’ Pada pilihan pertama, user akan
diberi input untuk memasukkan data yang ingin disorting. Pilihan ini memanggil procedure
input yang telah dibuat sebelumnya. Pada pilihan kedua, user akan ditampilkan output
berupa hasil sorting dari data yang telah user masukkan sebelumnya. Pilihan ini
memanggil procedure buble2 untuk mensorting dan procedure laporan untuk menampilkan
hasil sorting. Pada pilihan ketiga, sesuai namanya, maka akan mengakhiri program.

3. Modul10Latihan3.pas

program maxsort;
uses crt;
var i,n,j : integer;
a: array [1..100] of integer;
procedure maximum;
var z: integer;
begin
for i:= 1 to n-1 do
 13

begin
for j:= n downto i+1 do
begin
if a[j] < a[j-1] then
begin
z:= a[j];
a[j]:= a[j-1];
a[j-1]:=z;
end;
end;
end;
end;
begin
clrscr;
write('Banyaknya Integer : '); readln(n);
for i:= 1 to n do
begin write('Nilai ke - ',i,' : '); readln(a[i]);
end;
maximum;
write('Data setelah diurutkan (MaxSort) : ');
for j:=1 to n do
write (a[j],' ');
readln;
end.
Contoh Tampilan Pada Layar
{Kasus 1}

Analisis
Pengurutan ‘Maximum Sorting’ ini tidak jauh berbeda dengan Bubble Sort, hanya
bedanya terletak pada proses pertukaran datanya. Jika di Bubble Sort, data yang paling
besar “menggelembung’ ke atas, begitu seterusnya sampai data habis. Sedangkan,
Maximum Sorting ini menukar data yang besar ke ujung kanan, sampai datanya terurut
dari yang terkecil ke yang terbesar. Pertama yang kita lakukan adalah membuat sebuah
‘array’ untuk menampung data yang ingin diurutkan. Nama arraynya adalah
‘TabInteger’. Setelah itu, kita menentukan variabel yang akan digunakan di program pada
bagian ‘var’, yaitu ada ‘TabInt:TabInteger, jml_data:integer,’. Kemudian dibuat
‘procedure’ berjudul ‘InputData’ untuk memberi input kepada user memasukkan data-
data yang ingin diurutkan. Dibuat lagi procedure berjudul ‘Maximum’ untuk menampung
rumus pengurutan secara Maximum Sort. Dalam procedure ini, parameter inputnya yaitu
‘n:integer; var T:TabInteger;’. Lalu variabel dalam procedurenya didefinisikan yaitu
‘pass,k,temp:integer’. Terakhir, ditulis rumus maximum sortingnya, yaitu ‘for pass:=1 to
(n-1) do for k:=n downto (pass+1) do if T[k] < T[k-1] then begin temp := T[k]; T[k] :=
T[k-1]; T[k-1] := temp; end;’. Procedure kemudian di ‘end’ dan dilanjut ke program
utama dengan perintah ‘begin’. Diberi input bagi user untuk memasukkan jumlah bilangan
yang ingin dimasukkan. Setelah itu, dipanggil procedure InputData yang telah dibuat
sebelumnya, setelah itu dipanggil lagi procedure Maximum. Outputnya berupa bilangan-
bilangan yang telah diurutkan dari kecil ke besar.

4. Modul10Latihan4.pas
 14

program minsort;
uses crt;
var i,n,j : integer;
a: array [1..100] of integer;
procedure minimum;
var z: integer;
begin
for i:= 1 to n-1 do
begin
for j:= n downto i+1 do
begin
if a[j] > a[j-1] then
begin
z:= a[j];
a[j]:= a[j-1];
a[j-1]:=z;
end;
end;
end;
end;
begin
clrscr;
write('Banyaknya Integer : '); readln(n);
for i:= 1 to n do
begin write('Nilai ke - ',i,' : '); readln(a[i]);
end;
minimum;
write('Data setelah diurutkan (MinSort) : ');
for j:=1 to n do
write (a[j],' ');
readln;
end.
Contoh Tampilan Pada Layar
{Kasus 1}

Analisis
Pengurutan ‘Minimum Sorting’ ini tidak jauh berbeda dengan Bubble Sort, hanya
bedanya terletak pada proses pertukaran datanya. Jika di Bubble Sort, data yang paling
besar “menggelembung’ ke atas, begitu seterusnya sampai data habis. Sedangkan,
Maximum Sorting ini menukar data yang terkecil ke ujung kanan, sampai datanya terurut
dari yang terbesar ke yang terkecil. Pertama yang kita lakukan adalah membuat sebuah
‘array’ untuk menampung data yang ingin diurutkan. Nama arraynya adalah
‘TabInteger’. Setelah itu, kita menentukan variabel yang akan digunakan di program pada
bagian ‘var’, yaitu ada ‘TabInt:TabInteger, jml_data:integer,’. Kemudian dibuat
‘procedure’ berjudul ‘InputData’ untuk memberi input kepada user memasukkan data-
data yang ingin diurutkan. Dibuat lagi procedure berjudul ‘Minimum’ untuk menampung
rumus pengurutan secara Minimum Sort. Dalam procedure ini, parameter inputnya yaitu
‘n:integer; var T:TabInteger;’. Lalu variabel dalam procedurenya didefinisikan yaitu
‘pass,k,temp:integer’. Terakhir, ditulis rumus minimum sortingnya, yaitu ‘for pass:=1 to
(n-1) do for k:=n downto (pass+1) do if T[k] < T[k-1] then begin temp := T[k]; T[k] :=
 15

T[k-1]; T[k-1] := temp; end;’. Procedure kemudian di ‘end’ dan dilanjut ke program
utama dengan perintah ‘begin’. Diberi input bagi user untuk memasukkan jumlah bilangan
yang ingin dimasukkan. Setelah itu, dipanggil procedure InputData yang telah dibuat
sebelumnya, setelah itu dipanggil lagi procedure Minimum. Outputnya berupa bilangan-
bilangan yang telah diurutkan dari besar ke kecil.

5. Modul10Latihan5.pas

program maxsortdescending;
uses crt;
var i,n,j : integer;
a: array [1..100] of integer;
procedure maximum;
var z: integer;
begin
for i:= 1 to n-1 do
begin
for j:= n downto i+1 do
begin
if a[j] > a[j-1] then
begin
z:= a[j];
a[j]:= a[j-1];
a[j-1]:=z;
end;
end;
end;
end;
begin
clrscr;
write('Banyaknya Integer : '); readln(n);
for i:= 1 to n do
begin write('Nilai ke - ',i,' : '); readln(a[i]);
end;
maximum;
write('Data setelah diurutkan (MaxSort Descending/Menurun) : ');
for j:=1 to n do
write (a[j],' ');
readln;
end.
Contoh Tampilan Pada Layar
{Kasus 1}
 16

Analisis
Perbedaan disini hanya terletak pada rumus pengurutan maximum sorting nya (ditandai
dengan warna merah). Pertama yang kita lakukan adalah membuat sebuah ‘array’ untuk
menampung data yang ingin diurutkan. Nama arraynya adalah ‘TabInteger’. Setelah itu,
kita menentukan variabel yang akan digunakan di program pada bagian ‘var’, yaitu ada
‘TabInt:TabInteger, jml_data:integer,’. Kemudian dibuat ‘procedure’ berjudul
‘InputData’ untuk memberi input kepada user memasukkan data-data yang ingin
diurutkan. Dibuat lagi procedure berjudul ‘Maximum’ untuk menampung rumus
pengurutan secara Maximum Sort. Dalam procedure ini, parameter inputnya yaitu
‘n:integer; var T:TabInteger;’. Lalu variabel dalam procedurenya didefinisikan yaitu
‘pass,k,temp:integer’. Terakhir, ditulis rumus maximum sortingnya, yaitu ‘for pass:=1 to
(n-1) do for k:=n downto (pass+1) do if T[k] > T[k-1] then begin temp := T[k]; T[k] :=
T[k-1]; T[k-1] := temp; end;’. Procedure kemudian di ‘end’ dan dilanjut ke program
utama dengan perintah ‘begin’. Diberi input bagi user untuk memasukkan jumlah bilangan
yang ingin dimasukkan. Setelah itu, dipanggil procedure InputData yang telah dibuat
sebelumnya, setelah itu dipanggil lagi procedure Maximum. Outputnya berupa bilangan-
bilangan yang telah diurutkan dari besar ke kecil.

6. Modul10Latihan6.pas
program sortdatamahasiswa2;
uses crt;
type mahasiswa=record
nim:longint;
nama:string[20];
alamat:string[25];
IP:real;
end;
const jummhs:integer=3;
var
data:array [1..3] of mahasiswa;
procedure menu;forward;
procedure tampil;forward;
procedure inputdata;
var
i:integer;
begin
clrscr;
for i:=1 to jummhs do
begin
write('NIM :');readln(data[i].nim);
write('Nama : ');readln(data[i].nama);
write('Nilai : ');readln(data[i].ip);
writeln;
end;
menu;
end;
procedure bubblesort;
var
tmp:mahasiswa;
i,j:integer;
begin
for i:=jummhs downto 2 do
begin
for j:=2 to i do
begin
if data[j].nim < data[j-1].nim then
begin
tmp:=data[j];
data[j]:=data[j-1];
data[j-1]:=tmp;
 17

end;
end;
end;
clrscr;
writeln('PENGURUTAN DENGAN MAXIMUM SORT');
tampil;
end;

procedure binsearch;
var
atas,bawah,tengah:integer;
cari:longint;
begin
clrscr;
writeln('Masukkan NIM mahasiswa yang ingin dicari : ');
readln(cari);
atas:=1;
bawah:=jummhs;
tengah:=(atas+bawah)div 2;
while ((atas<bawah) and (data[tengah].nim<>cari)) do
begin
if data[tengah].nim < cari then
atas:= tengah+1
else
bawah:=tengah-1;
tengah:=(atas+bawah)div 2;
end;
if data[tengah].nim = cari then
begin
clrscr;
writeln('DATA MAHASISWA ADALAH : ');
gotoxy(3,3);write('NIM');
gotoxy(14,3);Write('NAMA');
gotoxy(44,3);write('Nilai');
gotoxy(3,5);write(data[tengah].nim);
gotoxy(14,5);Write(data[tengah].nama);
gotoxy(44,5);write(data[tengah].ip:3:2);
readkey;
menu;
end
else
begin
writeln('DATA MAHASISWA TIDAK ADA!');
readkey;
menu;
end;
end;
procedure tampil;
var
i:integer;
begin
gotoxy(3,2);write('NIM');
gotoxy(14,2);Write('NAMA');
gotoxy(44,2);write('NILAI');
for i:=1 to jummhs do
begin
gotoxy(3,3+i);write(data[i].nim);
gotoxy(14,3+i);Write(data[i].nama);
gotoxy(44,3+i);write(data[i].ip:3:2);
end;
 18

end;
procedure menu;
var
pil:integer;
begin
clrscr;
writeln('MENU DATA MAHASISWA');
writeln('[1] INPUT DATA');
writeln('[2] URUTKAN DATA (MAXIMUM SORT)');
writeln('[3] PENCARIAN MAHASISWA');
writeln('[4] KELUAR');
writeln;
write('Pilihan anda = ');
readln(pil);
case pil of
1:inputdata;
2:begin
bubblesort;
readkey;
menu;
end;
3:begin
binsearch;
menu;
end;
4:halt;
end;
end;
begin
menu;
end.

Contoh Tampilan Pada Layar

{Kasus 1}

{Kasus 2}
 19

{Kasus 3}

{Kasus 4}

Analisis
Pada program ini, program pada latihan no.2 dimodifikasi agar bisa menambahkan fitur
untuk menginput data dan mencari data berdasarkan NIM mahasiswa menggunakan proses
‘Binary Search’. Pertama, untuk menambahkan input, maka dibuat ‘procedure’ berjudul
‘inputdata’ untuk menampung masukan data dari user. Masukannya berupa ‘Nama : ,
NIM : , Nilai : ,’. Setelah itu procedure diakhir dengan ‘end;’. Lalu, untuk fitur pencarian
Binary Search nya, dibuat procedure berjudul ‘binsearch’ untuk menampung rumus binary
search itu sendiri. Pada procedure ini, akan diberi user untuk menginputkan NIM
mahasiswa yang ingin dicari. Setelah itu, procedure menjalankan sebuah rumus yaitu
‘atas:=1; bawah:=jummhs; tengah:=(atas+bawah)div 2; while ((atas<bawah) and
(data[tengah].nim<>cari)) do begin if data[tengah].nim < cari then atas:= tengah+1
else bawah:=tengah-1; tengah:=(atas+bawah)div 2; end;’. Lalu, setelah rumus
dijalankan, maka procedure akan menampilkan output berupa hasil dari NIM mahasiswa
yang dicari. Jika NIM salah, maka akan memberikan output berupa ‘DATA
MAHASISWA TIDAK ADA!’. Selain daripada itu, procedure dan program lainnya
cukup sama dengan pada latihan no.2

7. Modul10Latihan7.pas
program maxminsort;
uses crt;
Type
Larik = Array [1..1000] of Integer;
var
pil, I, N, J, Tmp, Temp, Mx, Min, U: Integer;
L: Larik;
mat : array[1..2,1..2] of byte;
jb : char;
Procedure InputData;
Begin
For I := 1 To N Do
Begin
 20

Write('Data Ke-', I, ': '); Readln(L[I]);

end;
end;
Procedure SORT(L : Larik; N : Integer);
label awal;
begin
awal:
clrscr;
writeln(' 1. Maximum Sort');
writeln(' 2. Minimum Sort');
writeln(' 3. EXIT Program ATAU Masukkan Data Yang Baru');
WriteLn('=====================================');
writeln;
write('PILIHAN ANDA ADALAH :');readln(pil);
case pil of
1:begin
ClrScr;
U := N;
For I := 1 To N-1 Do
Begin
Mx := 1;
For J := 2 To U Do
Begin
If L[J] > L[Mx] Then Mx := J;
End;
Tmp := L[U];
L[U] := L[Mx];
L[Mx] := Tmp;
U := U-1;
End;
WriteLn('Anda memilih Sorting MAXIMUM SORT');
WriteLn('==================================');
writeln('Data setelah diurutkan : ');
WriteLn;
For I := 1 To N Do
Begin
Write(L[I], ' ');
End;
WriteLn;
WriteLn;
WriteLn('==================================');
WriteLn('Tekan ENTER Untuk Kembali Ke Menu');
ReadLn;
goto awal;
end;
2:Begin
clrscr;
U := N;
for i:= 1 to N-1 do
begin
Min := 1;
for J:=2 to U do
begin
if L[J] < L[Min] then Min :=J;
end;
temp:= L[U];
L[U] := L[Min];
L[Min] := Temp;
U:= U-1;
end;
 21

writeln('Anda memilihi Sorting MINIMUM SORT');

WriteLn('==================================');
writeln('Data setelah diurutkan : ');
writeln;
for i:=1 to N do
begin
write(L[i], ' ' );
end;
WriteLn;
WriteLn;
WriteLn('==================================');
WriteLn('Tekan ENTER Untuk Kembali Ke Menu');
readln;
goto awal;
end;
3:Begin
clrscr;
writeln('Anda Pilih Menu Keluar atau Masukkan Data');
readln;
end;
end;
end;
Begin
jb:='y';
repeat
ClrScr;
Write('Banyaknya Integer : ');ReadLn(N);
InputData;
SORT(L, N);
write('Apakah ingin memasukkan data yang baru (Y/T)?
');Readln(jb);
until (jb='T') or (jb='t');
end.
Contoh Tampilan Pada Layar
{Kasus 1}

{Kasus 2}

{Kasus 3}
 22

{Kasus 4}

{Kasus 5}

Analisis
Pada program ini, disajikan menu pilihan bagi user untuk mensorting data dengan cara
‘Maximum Sort’ atau ‘Minimum Sort’. Pertama, dibuat ‘array’ untuk menampung data
integer dengan nama ‘Larik’. Kemudian didefinisikan variabel berupa
‘pil,i,n,j,tmp,temp,mx,mn,u:integer; L:Larik; mat:array; jb:char;’. Kemudian, dibuat
‘procedure’ berjudul ‘InputData’ yang berfungsi untuk memberi input kepada user untuk
memasukkan jumlah data serta data tersebut. Setelah itu, dibuat lagi procedure berjudul
‘SORT’ yang menampung pilihan menu sekaligus rumus dari maximum dan minimum
sort. Pada procedure ini, setelah menginput data pada procedure InputData sebelumnya,
user kemudian diberikan pilihan yaitu ‘1. Maximum Sort; 2. Minimum Sort; 3. Exit
Program atau Masukkan Data Yang Baru’. Jika user memilih pilihan ke-1, maka akan
dilakukan rumus MaximumSorting, yaitu ’U := N; For I := 1 To N-1 Do Begin Mx := 1;
For J := 2 To U Do Begin If L[J] > L[Mx] Then Mx := J; End; Tmp := L[U]; L[U] :=
L[Mx]; L[Mx] := Tmp; U := U-1; End;’. Lalu, setelah rumus dijalankan, akan keluar
output berupa ‘Anda memilih Sorting MAXIMUM SORT’ kemudian diikuti dengan
data yang telah terurut mulai dari terkecil ke terbesar. Jika user memilih pilihan ke-2, maka
akan dilakukan rumus MinimumSorting, yaitu U := N; for i:= 1 to N-1 do begin Min :=
1; for J:=2 to U do begin if L[J] < L[Min] then Min :=J; end; temp:= L[U]; L[U] :=
L[Min]; L[Min] := Temp; U:= U-1; end;’. Lalu, setelah rumus dijalankan, akan keluar
output berupa ‘Anda memilih Sorting MINIMUM SORT’ kemudian diikuti dengan data
yang telah terurut mulai dari terbesar ke terkecil. Jika user memilih pilihan ke-3, maka
akan keluar output ‘Anda Pilih Menu Keluar atau Masukkan Data’ dan ‘Apakah ingin
memasukkan data yang baru (Y/T)?’. Jika user memilih ‘y’ maka program akan
memulai lagi dari awal penginputan data sampai sorting. Jika user memilih ‘t’ maka
program akan ditutup dan diakhiri dengan ‘end.’.