Struktur Data dan Algoritma Lanjut

Oleh : Shiyami M, S.Kom.

JURUSAN MANAJEMEN INFORMATIKA POLITEKNIK POS INDONESIA BANDUNG 2011

BAB I ALGORITMA PENCARIAN (SEARCHING)

1.1 Deskripsi Umum Proses Pencarian adalah menemukan nilai / data tertentu dalam sekumpulan data yang bertipe sama. Pada Bab ini akan dibahas algoritma pencarian yang paling sederhana yaitu : pencarian beruntun (Sequential Search) dan pencarian bagidua (binary search). 1.1.1 Algoritma Pencarian Beruntun (Sequential Search) Algoritma pencarian beruntun adalah proses membandingkan setiap elemen array satu per satu secara beruntun, mulai dari elemen pertama sampai elemen yang dicari ditemukan, atau seluruh elemen sudah diperiksa. Contoh : Diberikan sebuah larik L dibawah ini dengan n = 5 elemen 27 1 13 2 30 3 11 4 25 5

Misal nilai yang akan dicari adalah x = 11 Maka elemen yang dibandingkan secara berturut-turut adalah : 27, 13, 30, 11 (ditemukan) Indeks larik yang dikembalikan : idx = 4 Misal nilai yang akan dicari adalah x = 12 Maka elemen yang dibandingkan secara berturut-turut adalah : 27, 13, 30, 11, 25 (tidak ditemukan) Indeks larik yang dikembalikan : idx = -1 Terdapat 2 versi algoritma pencarian beruntun sbb : a. Versi 1 pembandingan elemen sebagai kondisi pengulangan ALGORITMA SequentialSearchV1 {Mencari keberadaan nilai x di dalam Array L[1..N]} DEKLARASI Const Nmaks = 100 {Jumlah maksimal elemen larik} L : array[1..Nmaks] of integer K : integer {pencatat indeks larik} X : integer {elemen larik yang dicari} N : integer {ukuran larik} DESKRIPSI Read (n) {banyaknya data yg akan dimasukkan kedalam larik} Read (L[K]) {memasukan elemen larik} Read (X) {data yang akan dicari} 2

K 1 while (K<n) and (L[K] <> X) do K K+1; endwhile if L[K] X then write (X, ditemukan') else write (X, 'ga ketemu nih') endif Bagaimana jika hasil pencarian berupa indeks elemen larik yang mengandung nilai X ?

Untuk algoritma pencarian diatas, proses pembandingan dilakukan di dalam badan pengulangan, bila elemen yang dicari (x) tidak terdapat dalam indeks larik (L[K]) maka aktivitas pembandingan (x) diteruskan ke elemen dalam indeks larik berikutnya (K K+1). Pembandingan dihentikan apabila elemen yg dicari (x) terdapat dalam indeks larik (L[K] = X) atau indeks (K) sudah mencapai akhir larik (K = n). Perhatikan juga jika indeks (k) sudah mencapai akhir larik, elemen ini belum dibandingkan dengan (x). pembandingan elemen terakhir ini dilakukan bersama-sama dengan penyimpulan hasil pencarian. Hasil pencarian akan dilaksanakan di luar badan pengulangan dengan pernyataan (if L[K] X then . ) Translasi ke dalam pascal

Algoritma Sequential Search versi 1 dengan hasil pencarian berupa indeks elemen larik yang mengandung nilai X ALGORITMA SequentialSearchV2 {Mencari keberadaan nilai x di dalam Array L[1..N]} DEKLARASI Const Nmaks = 100 {Jumlah maksimal elemen larik} L : array[1..Nmaks] of integer K : integer {pencatat indeks larik} X : integer {elemen larik yang dicari} N : integer {ukuran larik} Idx : integer {indeks larik} DESKRIPSI Read (n) {banyaknya data yg akan dimasukkan kedalam larik} Read (L[K]) {memasukan elemen larik} Read (X) {data yang akan dicari} K 1 while (K<n) and (L[K] <> X) do K K+1 endwhile if L[K] X then idx k write (X, ditemukan pada index ke :' , idx ) else write (X, 'ga ketemu nih') endif b. Versi 2 pembandingan elemen di dalam badan pengulangan Hasil pencarian berupa peubah Boolean yang bernilai true bila x ditemukan dan false bila x tidak ditemukan ALGORITMA SequentialSearchV3 {Mencari keberadaan nilai x di dalam Array L[1..N]} DEKLARASI Const Nmaks = 100 {Jumlah maksimal elemen larik} L : array[1..Nmaks] of integer K : integer {pencatat indeks larik} X : integer {elemen larik yang dicari} N : integer {ukuran larik} Idx : integer {indeks larik} Found : boolean DESKRIPSI Read (n) {banyaknya data yg akan dimasukkan kedalam larik} Read (L[K]) {memasukan elemen larik} Read (X) {data yang akan dicari}

K1 while (K n) and (not found) do if L[K] X then found true else K K+1 endwhile if found then idx k write (X, ditemukan pada index ke :' , idx ) else write (X, 'ga ketemu nih') endif

Pada versi 2 ini pembandingan dilakukan di dalam kondisi pengulangan dengan menambahkan peubah (found) sebagai boolean, perlu diperhatikan bahwa didalam kondisi pengulangan terdapat proses pembandingan indeks larik dengan elemen yg dicari (L[K] = X) dengan hasil peubah (found) akan diisi dengan nilai true. Bila (L[K] X) maka pembandingan ini akan terus berulang (K K+1) dan selama peubah (found) masih bernilai false (not found) dan indeks (K) belum mencapai akhir larik (K=n). Kondisi pengulangan dihentikan bila peubah found telah bernilai true (found = true) atau dengan kata lain bila kondisi (L[K] = X) . Hasil pencarian disimpulkan di luar badan pengulangan dengan pernyataan (if found then ) 1.1.2 Algoritma Pencarian Beruntun pada Larik Terurut Menaik Larik yang elemennya sudah terurut dapat meningkatkan kinerja algoritma pencarian beruntun. Hal ini karena pada larik yang terurut kita dapat segera menyimpulkan bahwa x tidak terdapat dalam larik bila ditemukan elemen larik yang lebih besar dari x. Secara singkat kita akan melakukan proses serupa dengan pencarian beruntun. Jika diasumsikan larik terurut naik (ascending) maka pencarian akan Kita mulai dengan pembandingan dengan elemen yang pertama, dan diteruskan sepanjang data yang dicari masih lebih kecil dari nilai elemen pada larik. Jika elemen larik sudah lebih besar, maka pencarian dihentikan karena pasti data yang dicari tidak akan pernah ditemukan pada larik. ALGORITMA SequentialSearchV4 {Mencari keberadaan nilai x di dalam Array L[1..N]} DEKLARASI Const Nmaks = 100 {Jumlah maksimal elemen larik} L : array[1..Nmaks] of integer K : integer {pencatat indeks larik} X : integer {elemen larik yang dicari} N : integer {ukuran larik} Idx : integer {indeks larik} 5

DESKRIPSI Read (n) {banyaknya data yg akan dimasukkan kedalam larik} Read (L[K]) {memasukan elemen larik} Read (X) {data yang akan dicari} K1 while (K < n) and (L[K] < X) do K K+1 endwhile if L[K] X then idx k write (X, ditemukan pada index ke :' , idx ) else write (X, 'ga ketemu nih') endif Pada pencarian larik terurut ini proses pembandingan dilakukan dengan melakukan pengecekan terhadap nilai pada indeks larik pertama (L[K]) apakah memilki nilai lebih kecil dari (x)? bila (L[K] > X) maka dapat disimpulkan bahwa (x) tidak terdapat dalam larik . bila (L[K] < X) maka proses pengulangan akan terus dilakukan hingga (L[K] = X). proses penyimpulan oencarian dilakukan di luar pengulangan dengan pernyataan (if L[K] X then ) 1.1.3 Algoritma Pencarian Bagi dua (Binary Search) Terdapat algoritma pencarian pada data terurut yang paling efisien, yaitu algoritma pencarian bagidua atau pencarian biner (binary search). Algoritma ini digunakan untuk kebutuhan pencarian dengan waktu yang cepat. Metode pencarian biner ini bekerja dengan cara sebagai berikut : a. Menentukan terlebih dahulu elemen tengah larik. Elemen tengah adalah elemen dengan indeks k = (I + j) div 2, elemen tengah ini akan membentuk larik menjadi 2 bagian yaitu bagian kiri dan bagian kanan. b. Memeriksa apakah elemen tengah larik telah sama dengan data yang dicari (x) bila sama maka pencarian selesai, bila tidak sama maka pencarian data akan dilakukan pada elemen larik bagian kanan atau bagian kiri. Cara kerja metode pencarian biner dapat dijelaskan sebagai berikut : Dimisalkan kita memiliki larik L terurut dengan 6 buah elemen yang sudah terurut menurun seperti di bawah ini : 23 i=1 18 2 14 3 10 4 7 5 3 6=j

Inisialisasi i disana adalah sebagai inisialisasi untuk indeks elemen pertama dan j adalah sebagai inisialisasi untuk indeks elemen terakhir, kedua inisialisasi ini nantinya akan berfungsi sebagai pembagi data menjadi dua bagian.

(i) Misalkan elemen yang dicari adalah X = 14 Langkah 1 : I = 1 dan j = 6 Indeks elemen tengah k = (I + j) div 2 = 3 (elemen yang diarsir)

23 i=1

18 2

14 3

10 4

7 5

3 6=j

Langkah 2 : Membandingkan elemen tengah L[K] dengan nilai elemen yang dicari (x) L[3] = 14 ? ya! (x ditemukan pencarian selesai) (ii) Misalkan elemen yang dicari adalah X = 10 Langkah 1 : I = 1 dan j = 6 Indeks elemen tengah k = (I + j) div 2 = 3 (elemen yang diarsir) 23 i=1 18 2 14 3 10 4 7 5 3 6=j

Langkah 2 : Membandingkan elemen tengah L[K] dengan nilai elemen yang dicari (x) L[3] = 10 ? tidak! pencarian berlanjut dengan menentukan apakah akan dilakukan pencarian di bagian kiri atau kanan larik dengan pemeriksaan membandingkan elemen tengah L[k] apakah lebih besar ( > ) dari nilai elemen yang dicari (x) L[3] > 10? Ya! Maka pencarian dilakukan di bagian kanan dengan i = k + 1 = 4 dan j = 6 (tetap) 10 i=4 7 5 3 6=j

Langkah 3 : I = 4 dan j = 6 Indeks elemen tengah k = (I + j) div 2 = 5 (elemen yang diarsir) 10 i=4 7 5 3 6=j

Langkah 4 : Membandingkan elemen tengah L[K] dengan nilai elemen yang dicari (x) L[5] = 10 ? tidak! 7

pencarian berlanjut dengan menentukan apakah akan dilakukan pencarian di bagian kiri atau kanan larik dengan pemeriksaan membandingkan elemen tengah L[k] apakah lebih besar ( > ) dari nilai elemen yang dicari (x) L[5] > 10 ? tidak! Lakukan pencarian pada larik bagian kiri dengan I = 4 (tetap) dan j = k 1 = 4 10 4 Langkah 5 : I = 4 dan j = 4 Indeks elemen tengah k = (I + j) div 2 = 4 (elemen yang diarsir) 10 4 Langkah 6 : Membandingkan elemen tengah L[K] dengan nilai elemen yang dicari (x) L[4] = 10 ? ya! (x ditemukan pencarian selesai) ALGORITMA BinarySearch {Mencari keberadaan nilai x di dalam Array L[1..N]} DEKLARASI Const Nmaks = 100 {Jumlah maksimal elemen larik} L : array[1..Nmaks] of integer K : integer {pencatat indeks larik} X : integer {elemen larik yang dicari} N : integer {ukuran larik} Idx : integer {indeks larik} Found : boolean I,j : integer DESKRIPSI Read (n) {banyaknya data yg akan dimasukkan kedalam larik} Read (L[K]) {memasukan elemen larik} Read (X) {data yang akan dicari} i1 jn while (i <= j) and (not found) do K (i + j) div 2 if L[K] X then found true else if (L[K] > X) then {inilah ciri dari pencarian bagidua terurut menurun} i K+1 else j K-1 endwhile 8

if found then idx k write (X, ditemukan pada index ke :' , idx ) else write (X, 'ga ketemu nih') endif Bagaimana dengan pencarian bagidua terurut menaik ?

Algoritma pencarian bagidua terurut menaik ALGORITMA BinarySearchV2 {Mencari keberadaan nilai x di dalam Array L[1..N]} DEKLARASI Const Nmaks = 100 {Jumlah maksimal elemen larik} L : array[1..Nmaks] of integer K : integer {pencatat indeks larik} X : integer {elemen larik yang dicari} n : integer {ukuran larik} Idx : integer {indeks larik} Found : boolean DESKRIPSI Read (n) {banyaknya data yg akan dimasukkan kedalam larik} Read (L[K]) {memasukan elemen larik} Read (X) {data yang akan dicari} i1 jn while (i <= j) and (not found) do K (i + j) div 2 if L[K] X then found true else if (L[K] < X) then {disini perbedaan pencarian bagidua terurut menaik} i K+1 else j K+1 endwhile if found then idx k write (X, ditemukan pada index ke :' , idx ) else write (X, 'ga ketemu nih') endif

1.2 Latihan Praktikum 1. Buatlah program pencarian berdasarkan 6 contoh algoritma yang telah di bahas di atas ? 2. Buatlah algoritma pencarian menggunakan 2 metode pencarian di atas untuk larik terstruktur data mahasiswa yang terdiri dari NIM, nama mahasiswa, jenis kelamin dan kelas kemudian buatlah programnya.

10

BAB II ALGORITMA PENGURUTAN (SORTING)

2.1 Deskripsi Umum Proses pengurutan adalah proses mengatur sekumpulan objek menurut urutan atau susunan tertentu. Pada Bab ini akan dibahas algoritma pengurutan yang paling sederhana yaitu : a. Pengurutan apung (Bubble Sort) b. Pengurutan seleksi (Selection Sort) c. Pengurutan sisip (Insertion Sort) d. Pengurutan shell (Shell Sort) 2.1.1 Algoritma Pengurutan Apung (Bubble Sort) Algoritma Pengurutan Apung adalah proses pengurutan data satu dengan data yang lain dengan melakukan prinsip pertukaran elemen dalam proses pengurutannya (exchange sort). Contoh : Diberikan sebuah larik L yang belum terurut dibawah ini dengan n = 5 elemen, dan larik ini akan diurut menaik. Arah pembandingan dimulai dari elemen paling akhir. 27 1 13 2 30 3 11 4 25 5

Langkah 1 : I=1: K=n downto i+1 K=5 K=4 K=3 K=2

Pembandingan elemen L[K] < L[K-1] L[5] < L[4] ? (25 < 11 ?) L[4] < L[3] ? (11 < 30 ?) L[3] < L[2] ? (11 < 13 ?) L[2] < L[1] ? (11 < 27 ?)

Pertukarkan L[K] dengan L[K-1]? Tidak Ya Ya Ya

Hasil sementara 27, 13, 30, 11, 25 27, 13, 11, 30, 25 27, 11, 13, 30, 25 11, 27, 13, 30, 25

Hasil akhir pada posisi I = 1: 11 27 13 30 25 1 2 3 4 5 Langkah 2 : I=2: K=n downto i+1 K=5 K=4 K=3

Pembandingan elemen L[K] < L[K-1] L[5] < L[4] ? (25 < 30 ?) L[4] < L[3] ? (25 < 13 ?) L[3] < L[2] ? (13 < 27 ?)

Pertukarkan L[K] dengan L[K-1]? Ya Tidak Ya

Hasil sementara 11, 27, 13, 25, 30 11, 27, 13, 25, 30 11, 13, 27, 25, 30

Hasil akhir posisi I = 2 : 11 13 27 25 1 2 3 4

30 5 11

Langkah 3 : I=3: K=n downto i+1 K=5 K=4

Pembandingan elemen L[K] < L[K-1] L[5] < L[4] ? (30 < 25 ?) L[4] < L[3] ? (25 < 27 ?)

Pertukarkan L[K] dengan L[K-1]? Tidak Ya

Hasil sementara 11, 13, 27, 25, 30 11, 13, 25, 27, 30

Hasil akhir posisi I = 3 : 11 13 25 27 1 2 3 4 Langkah 4 : I=4: K=n downto i+1 K=5

30 5

Pembandingan elemen L[K] < L[K-1] L[5] < L[4] ? (30 < 25 ?)

Pertukarkan L[K] dengan L[K-1]? Tidak

Hasil sementara 11, 13, 27, 25, 30

Hasil akhir posisi I = 4 : 11 13 25 27 1 2 3 4

30 5

ALGORITMA BubbleSortNaik {Mengurutkan larik L[1..n] sehingga terurut menaik dengan metode bubble sort} DEKLARASI Const Nmaks = 100 {Jumlah maksimal elemen larik} L : array[1..Nmaks] of integer I : integer {pencacah untuk jumlah langkah} K : integer {pencacah untuk pertukaran pada setiap langkah} temp : integer {peubah bantu untuk pertukaran} N : integer {ukuran larik} DESKRIPSI Read (n) {banyaknya data yg akan dimasukkan kedalam larik} Read (L[K]) {memasukan elemen larik} For I 1 to n 1 do For k n downto I + 1 If L[k] < L[k-1] then temp L[k] L[k] L[k-1] L[k-1] temp Endif Endfor Endfor Write (L[K]) Bagaimana pengurutan data yang terurut menurun? 12

Transalasi algoritma bubble short menaik dalam pascal

Untuk algoritma pengurutan data yang terurut menurun dengan menggunakan metode bubble sort, kita melakukan proses sebaliknya dari yang terurut menaik yaitu menukarkan elemen yang berharga maksimum ke ujung kiri larik atau ke index elemen paling kecil. Contoh : Diberikan sebuah larik L yang belum terurut dibawah ini dengan n = 5 elemen, dan larik ini akan diurut menurun. Arah pembandingan dimulai dari elemen paling akhir. 27 1 13 2 30 3 11 4 25 5

13

Langkah 1 : I=1: K=n downto i+1 K=5 K=4 K=3 K=2

Pembandingan elemen L[K] > L[K-1] L[5] > L[4] ? (25 > 11 ?) L[4] > L[3] ? (25 > 30 ?) L[3] > L[2] ? (30 > 13 ?) L[2] > L[1] ? (30 > 27 ?)

Pertukarkan L[K] dengan L[K-1]? Ya Tidak Ya Ya

Hasil sementara 27, 13, 30, 25, 11 27, 13, 30, 25, 11 27, 30, 13, 25, 11 30, 27, 13, 25, 11

Hasil akhir pada posisi I = 1: 30 27 13 25 11 1 2 3 4 5 Langkah 2 : I=2: K=n downto i+1 K=5 K=4 K=3

Pembandingan elemen L[K] > L[K-1] L[5] > L[4] ? (11 > 25 ?) L[4] > L[3] ? (25 > 13 ?) L[3] > L[2] ? (25 > 27 ?)

Pertukarkan L[K] dengan L[K-1]? Tidak Ya Tidak

Hasil sementara 30, 27, 13, 25, 11 30, 27, 25, 13, 11 30, 27, 25, 13, 11

Hasil akhir posisi I = 2 : 30 27 25 13 1 2 3 4 Langkah 3 : I=3: K=n downto i+1 K=5 K=4

11 5

Pembandingan elemen L[K] > L[K-1] L[5] > L[4] ? (11 > 13 ?) L[4] > L[3] ? (13 > 25 ?)

Pertukarkan L[K] dengan L[K-1]? Tidak Tidak

Hasil sementara 30, 27, 25, 13, 11 30, 27, 25, 13, 11

Hasil akhir posisi I = 3 : 30 27 25 13 1 2 3 4 Langkah 4 : I=4: K=n downto i+1 K=5

11 5

Pembandingan elemen L[K] > L[K-1] L[5] > L[4] ? (11 > 13 ?)

Pertukarkan L[K] dengan L[K-1]? Tidak

Hasil sementara 30, 27, 25, 13, 11

Hasil akhir posisi I = 4 : 30 27 25 13 1 2 3 4

11 5

14

ALGORITMA BubbleSortTurun {Mengurutkan larik L[1..n] sehingga terurut menaik dengan metode bubble sort} DEKLARASI Const Nmaks = 100 {Jumlah maksimal elemen larik} L : array[1..Nmaks] of integer I : integer {pencacah untuk jumlah langkah} K : integer {pencacah untuk pertukaran pada setiap langkah} temp : integer {peubah bantu untuk pertukaran} N : integer {ukuran larik} DESKRIPSI Read (n) {banyaknya data yg akan dimasukkan kedalam larik} Read (L[K]) {memasukan elemen larik} For I 1 to n 1 do For k n downto I + 1 If L[k] > L[k-1] then temp L[k] L[k] L[k-1] L[k-1] temp Endif Endfor Endfor Write (L[K])

2.1.2

Algoritma Pengurutan Seleksi (Selection Sort) Algoritma Pengurutan Seleksi adalah pengurutan dengan memilih elemen maksimum/minimum dari larik, lalu menempatkan elemen maksimum/minimum itu pada awal atau akhir larik (elemen terujung), elemen terujung tersebut tidak disertakan pada proses selanjutnya. Proses yangsama diulang untuk elemen larik yang tersisa dan mempertukarkannya dengan elemen terujung larik sisa. Ada 2 varian pengurutan seleksi ditinjau dari pemilihan elemen maksimum / minimum yaitu : a. Algoritma pengurutan seleksi-maksimum Yaitu memilih elemen maksimum sebagai basis pengurutan Contoh : Diberikan sebuah larik L yang belum terurut dibawah ini dengan n = 5 elemen, dan larik ini akan diurut menaik menggunakan metode selection sort. Arah pembandingan dimulai dari elemen paling akhir. 27 1 13 2 30 3 11 4 25 5

15

Langkah 1 : I=5 Cari elemen maksimum di dalam larik L[1..5] => hasilnya L[imaks] = L[3] = 30 Pertukarkan L[imaks] dengan L[5], diperoleh : 27 1 13 2 25 3 11 4 30 5

Langkah 2 : I=4 Cari elemen maksimum di dalam larik L[1..4] => hasilnya L[imaks] = L[1] = 27 Pertukarkan L[imaks] dengan L[4], diperoleh : 11 1 13 2 25 3 27 4 30 5

Langkah 3 : I=3 Cari elemen maksimun di dalam larik L[1..3] => hasilnya L[imaks] = L[3] = 25 Pertukarkan L[imaks] dengan L[3] (tetap), diperoleh : 11 1 13 2 25 3 27 4 30 5

Langkah 4 : I=2 Cari elemen maksimum di dalam larik L[1..2] => hasilnya L[imaks] = L[2] = 13 Pertukarkan L[imaks] dengan L[2] (tetap), diperoleh : 11 13 25 27 30 1 2 3 4 5 Tersisa satu elemen yaitu 11, maka pengurutan selesai larik telah terurut menaik. ALGORITMA SelectionSortMaxNaik {Mengurutkan larik L[1..n] sehingga terurut menaik dengan metode selection sort} DEKLARASI Const Nmaks = 100 {Jumlah maksimal elemen larik} L : array[1..Nmaks] of integer I : integer {pencacah untuk jumlah langkah} J : integer {pencacah untuk mencari nilai maksimum} temp : integer {peubah bantu untuk pertukaran} imaks : integer (peubah untuk indeks yang berisi nilai maksimum sementara} N : integer {ukuran larik} DESKRIPSI Read (n) {banyaknya data yg akan dimasukkan kedalam larik} Read (L[K]) {memasukan elemen larik} For I n downto 2 do Imaks 1 {elemen pertama diasumsikan sbg elemen maksimum sementara} For j 2 to I do If L[j] > L[imaks] then Imaks j 16

Endif Endfor {pertukaran L[imaks] dengan L[i]} temp L[i] L[i] L[imaks] L[imaks] temp Endfor Write (L[i]) Bagaimana untuk pengurutan data menurun ? Untuk algoritma pengurutan data terurut menurun menggunakan metode selection sort max dilakukan dengan merubah proses passing bila untuk terurut menaik pertukaran elemen maksimum pada larik L[1..n] dengan elemen terakhir, pada terurut menurun maka pertukaran dilakukan dengan elemen pertama larik. Contoh : Diberikan sebuah larik L yang belum terurut dibawah ini dengan n = 5 elemen, dan larik ini akan diurut menurun menggunakan metode selection sort. 27 1 13 2 30 3 11 4 25 5

Langkah 1 : I=1 Cari elemen maksimum di dalam larik L[1..5] => hasilnya L[imaks] = L[3] = 30 Pertukarkan L[imaks] dengan L[1], diperoleh : 30 13 27 11 25 1 2 3 4 5 Langkah 2 : I=2 Cari elemen maksimum di dalam larik L[2..5] => hasilnya L[imaks] = L[3] = 27 Pertukarkan L[imaks] dengan L[2], diperoleh : 30 1 27 2 13 3 11 4 25 5

Langkah 3 : I=3 Cari elemen maksimun di dalam larik L[3..5] => hasilnya L[imaks] = L[5] = 25 Pertukarkan L[imaks] dengan L[3], diperoleh : 30 1 27 2 25 3 11 4 13 5

17

Langkah 4 : I=4 Cari elemen maksimum di dalam larik L[4..5] => hasilnya L[imaks] = L[5] = 13 Pertukarkan L[imaks] dengan L[4], diperoleh : 30 27 25 13 11 1 2 3 4 5 Tersisa satu elemen yaitu 11, maka pengurutan selesai larik telah terurut menurun. ALGORITMA SelectionSortMaxTurun {Mengurutkan larik L[1..n] sehingga terurut menurun dengan metode selection sort max} DEKLARASI Const Nmaks = 100 {Jumlah maksimal elemen larik} L : array[1..Nmaks] of integer I : integer {pencacah untuk jumlah langkah} J : integer {pencacah untuk mencari nilai maksimum} temp : integer {peubah bantu untuk pertukaran} imaks : integer (peubah untuk indeks yang berisi nilai maksimum sementara} N : integer {ukuran larik} DESKRIPSI Read (n) {banyaknya data yg akan dimasukkan kedalam larik} Read (L[K]) {memasukan elemen larik} For I 1 to n - 1 do Imaks 1 {elemen pertama diasumsikan sbg elemen maksimum sementara} For j I + 1 to n do If L[j] > L[imaks] then Imaks j Endif Endfor {pertukaran L[imaks] dengan L[i]} temp L[i] L[i] L[imaks] L[imaks] temp Endfor Write (L[i])

b. Algoritma pengurutan seleksi-minimum Pada algoritma pengurutan seleksi-minimum, basis pencarian adalah elemen minimum, elemen minimum ditempatkan di awal larik (untuk terurut menaik) dan ditempatkan di akhir larik (untuk terurut menurun) Contoh : Diberikan sebuah larik L yang belum terurut dibawah ini dengan n = 5 elemen, dan larik ini akan diurut menaik menggunakan metode selection sort minimum. 27 1 13 2 30 3 11 4 25 5 18

Langkah 1 : I=1 Cari elemen minimun di dalam larik L[1..5] => hasilnya L[imin] = L[4] = 11 Pertukarkan L[imin] dengan L[1], diperoleh : 11 1 13 2 30 3 27 4 25 5

Langkah 2 : I=2 Cari elemen minimum di dalam larik L[2..5] => hasilnya L[imin] = L[2] = 13 Pertukarkan L[imin] dengan L[2], diperoleh : 11 1 13 2 30 3 27 4 25 5

Langkah 3 : I=3 Cari elemen minimun di dalam larik L[3..5] => hasilnya L[imin] = L[5] = 25 Pertukarkan L[imin] dengan L[3], diperoleh : 11 1 13 2 25 3 27 4 30 5

Langkah 4 : I=4 Cari elemen minimum di dalam larik L[4..5] => hasilnya L[imin] = L[4] = 27 Pertukarkan L[imin] dengan L[4], diperoleh : 11 13 25 27 30 1 2 3 4 5 Tersisa satu elemen yaitu 30, maka pengurutan selesai larik telah terurut menaik. ALGORITMA SelectionSortMinNaik {Mengurutkan larik L[1..n] sehingga terurut menaik dengan metode selection sort min} DEKLARASI Const Nmaks = 100 {Jumlah maksimal elemen larik} L : array[1..Nmaks] of integer I : integer {pencacah untuk jumlah langkah} J : integer {pencacah untuk mencari nilai maksimum} temp : integer {peubah bantu untuk pertukaran} imin : integer (peubah untuk indeks yang berisi nilai minimun sementara} N : integer {ukuran larik} DESKRIPSI Read (n) {banyaknya data yg akan dimasukkan kedalam larik} Read (L[K]) {memasukan elemen larik} For I 1 to n - 1 do Imin 1 {elemen pertama diasumsikan sbg elemen minimun sementara} For j I + 1 to n do If L[j] < L[imin] then Imin j 19

Endif Endfor {pertukaran L[imin] dengan L[i]} temp L[i] L[i] L[imin] L[imin] temp Endfor Write (L[i]) Bagaimana untuk pengurutan data terurut menurun ? Contoh : Diberikan sebuah larik L yang belum terurut dibawah ini dengan n = 5 elemen, dan larik ini akan diurut menurun menggunakan metode selection sort minimun. 27 1 13 2 30 3 11 4 25 5

Langkah 1 : I=5 Cari elemen minimun di dalam larik L[1..5] => hasilnya L[imin] = L[4] = 11 Pertukarkan L[imin] dengan L[5], diperoleh : 27 1 13 2 30 3 25 4 11 5

Langkah 2 : I=4 Cari elemen minimun di dalam larik L[1..4] => hasilnya L[imin] = L[2] = 13 Pertukarkan L[imin] dengan L[4], diperoleh : 27 1 25 2 30 3 13 4 11 5

Langkah 3 : I=3 Cari elemen minimum di dalam larik L[1..3] => hasilnya L[imin] = L[2] = 25 Pertukarkan L[imin] dengan L[3], diperoleh : 27 1 30 2 25 3 13 4 11 5

Langkah 4 : I=2 Cari elemen minimum di dalam larik L[1..2] => hasilnya L[imin] = L[1] = 27 Pertukarkan L[imin] dengan L[2], diperoleh : 30 27 25 13 11 1 2 3 4 5 Tersisa satu elemen yaitu 30, maka pengurutan selesai larik telah terurut menurun.

20

ALGORITMA SelectionSortMinTurun {Mengurutkan larik L[1..n] sehingga terurut menurun dengan metode selection sort min} DEKLARASI Const Nmaks = 100 {Jumlah maksimal elemen larik} L : array[1..Nmaks] of integer I : integer {pencacah untuk jumlah langkah} J : integer {pencacah untuk mencari nilai minimum} temp : integer {peubah bantu untuk pertukaran} imin : integer (peubah untuk indeks yang berisi nilai minimum sementara} N : integer {ukuran larik} DESKRIPSI Read (n) {banyaknya data yg akan dimasukkan kedalam larik} Read (L[K]) {memasukan elemen larik} For I n to downto 2 do imin 1 {elemen pertama diasumsikan sbg elemen minimum sementara} For j 2 to I do If L[j] < L[imin] then imin j Endif Endfor {pertukaran L[imin] dengan L[i]} temp L[i] L[i] L[imin] L[imin] temp Endfor Write (L[i])

2.1.3

Algoritma Pengurutan Sisip (Insertion Sort) Algoritma Pengurutan Sisip adalah metode pengurutan dengan cara menyisipkan elemen larik pada posisi yang tepat. Pencarian yang tepat dilakukan dengan menyisir larik. Selama penyisiran dilakukan pergeseran elemen larik. Contoh : Diberikan sebuah larik L yang belum terurut dibawah ini dengan n = 5 elemen, dan larik ini akan diurut menaik. 27 1 13 2 30 3 11 4 25 5

Untuk setiap langkah lakukan : 1. Y = L[i] 2. Sisipkan y pada tempat yang sesuai di antara L[1] L[i]

21

Langkah 1 : I=2: Y = L[i] Y = 13 Cari posisi yang tepat untuk Y = L[2] didalam larik L[12] sambil menggeser, diperoleh : 13 27 30 11 25 1 2 3 4 5 Langkah 2 : I=3: Y = L[3] Cari posisi yang tepat untuk Y = L[3] didalam larik L[1..3] tanpa menggeser, diperoleh : 13 27 30 11 25 1 2 3 4 5 Langkah 3 : I=4: Y = L[4] Cari posisi yang tepat untuk Y = L[4] didalam larik L[1..4] sambil menggeser, diperoleh : 11 13 27 30 25 1 2 3 4 5 Langkah 4 : I=5: Y = L[5] Cari posisi yang tepat untuk Y = L[5] didalam larik L[1..5] sambil menggeser, diperoleh : 11 13 25 27 30 1 2 3 4 5

ALGORITMA InsertionSortNaik {Mengurutkan larik L[1..n] sehingga terurut menaik dengan metode insertion sort} DEKLARASI Const Nmaks = 100 {Jumlah maksimal elemen larik} L : array[1..Nmaks] of integer I : integer {pencacah untuk jumlah langkah} J : integer {pencacah untuk penulusuran larik} Y : integer {peubah bantu agar L[i] tidak ditimpa selama pergeseran} N : integer {ukuran larik} Ketemu : Boolean {untuk menyatakan posisi penyisipan ditemukan} DESKRIPSI Read (n) {banyaknya data yg akan dimasukkan kedalam larik} Read (L[i]) {memasukan elemen larik} For I 2 to n do {mulai dari pass 2 sampai pass N} Y L[i] {cari posisi yg tepat untuk Y di dalam larik L[1..i-1] sambil menggeser} J i-1 22

Ketemu false While (j >= 1) and (not ketemu) do If Y < L[J] then L[J + 1] L[J] {geser} JJ-1 else ketemu true Endif Endwhile { J < 1 or ketemu} L[J + 1] Y {sisipkan Y pada tempat yang sesuai} Endfor Write (L[K]) Bagaimana pengurutan data yang terurut menurun?

Transalasi algoritma insertion short menaik dalam pascal

program insertionShort; uses wincrt; const nMaks = 100; var l : array[1..nMaks]of integer; i,j,n,y : integer; ketemu : boolean; begin write('masukan jumlah index array yg akan digunakan :'); readln(n); for i:=1 to n do begin write('Masukan elemen array :'); readln(l[i]); end; writeln; writeln('sebelum diurutkan'); writeln('------------------------');

for i:=1 to n do begin writeln('Elemen array index ke-',i,':',l[i]); end; for i:=2 to n do begin writeln('-----------'); writeln('iterasi i-',i); y := L[i]; {cari posisi yg tepat u/ y didalam larik L[1..i-1] sambil menggeser} j := i - 1; ketemu := false; while (j >= 1) and (not ketemu) do

23

begin if y < L[j] then begin L[j+1] := L[j]; {geser} writeln ('geser L[',j,'] ke L[',j+1,']'); j := j - 1; end else begin ketemu := true; end; end; {j < 1 or ketemu} L[j+1] := y; {sisipkan y pada tempat yg sesuai} Y pada posisinya dg menempatkan Y pada

writeln('tempatkan L[',j+1,']'); end;

writeln; writeln('setelah diurutkan'); writeln('------------------------');

for i:=1 to n do begin writeln('Elemen array index ke-',i,':',l[i]); end; end.

Untuk algoritma pengurutan data yang terurut menurun dengan menggunakan metode insertion sort, kita melakukan proses sebaliknya dari yang terurut menaik yaitu menukarkan elemen yang berharga maksimum ke ujung kiri larik atau ke index elemen paling kecil. ALGORITMA InsertionSortTurun {Mengurutkan larik L[1..n] sehingga terurut menurun dengan metode insertion sort} DEKLARASI Const Nmaks = 100 {Jumlah maksimal elemen larik} L : array[1..Nmaks] of integer I : integer {pencacah untuk jumlah langkah} J : integer {pencacah untuk penulusuran larik} Y : integer {peubah bantu agar L[i] tidak ditimpa selama pergeseran} N : integer {ukuran larik} Ketemu : Boolean {untuk menyatakan posisi penyisipan ditemukan} DESKRIPSI Read (n) {banyaknya data yg akan dimasukkan kedalam larik} Read (L[i]) {memasukan elemen larik} For I 2 to n do {mulai dari pass 2 sampai pass N} Y L[i] {cari posisi yg tepat untuk Y di dalam larik L[1..i-1] sambil menggeser} 24

J i-1 Ketemu false While (j >= 1) and (not ketemy) do If Y > L[J] then L[J + 1] L[J] {geser} JJ-1 else ketemu true Endif Endwhile { J < 1 or ketemu} L[J + 1] Y {sisipkan Y pada tempat yang sesuai} Endfor Write (L[K])

2.1.4

Algoritma Pengurutan Shell Algoritma ini merupakan perbaikan terhadap metode pengurutan sisip, kelemahan metode pengurutan sisip terletak pada banyaknya operasi pergeseran yg diperlukan dalam mencari posisi yang tepat untuk elemen larik. Secara garis besar, algortima pengurutan Shell dituliskan sebagai berikut : 1. Step n {n = ukuran larik} 2. While step 1 do a. Step step div 3 + 1 b. For I I to step do Insertion Sort setiap elemen ke-step mulai dari elemen ke-i Algoritma pengurutan Shell dubuat dengan pertama-tama dengan memodifikasi algoritma pengurutan sisip sedemikian sehingga kita dapat menspesifikasikan titik awal pengurutan dan ukuran step. Contoh : Diberikan sebuah larik L yang belum terurut dibawah ini dengan n = 5 elemen, dan larik ini akan diurut menaik. 27 1 13 2 30 3 11 4 25 5

Langkah 1 : Step = 2 urutkan setiap 2 elemen 27 1 | 25 13 30 2 3 | | | 27 11 11 25 4 5 | | | 30 13 25

Hasil pada step = 2 diperoleh : 25 1 11 2 27 3 13 4 30 5

Langkah 2 : Step = 1 urutkan setiap 1 elemen 25 11 27 13 30 1 2 3 4 5 Pada step=1 ini pengurutan dilakukan sama dengan pengurutan sisip biasa. Hasil pada step = 1 diperoleh : 11 1 13 2 25 3 27 4 30 5

ALGORITMA ShellSortNaik {Mengurutkan larik L[1..n] sehingga terurut menurun dengan metode shell sort} DEKLARASI Const Nmaks = 100 {Jumlah maksimal elemen larik} L : array[1..Nmaks] of integer I : integer {pencacah untuk jumlah langkah} J : integer {pencacah untuk penulusuran larik} Y : integer {peubah bantu agar L[i] tidak ditimpa selama pergeseran} N : integer {ukuran larik} Ketemu : Boolean {untuk menyatakan posisi penyisipan ditemukan} Start, step : integer {pencacah u/ menentukan jumlah langkah pengurutan} DESKRIPSI Read (n) {banyaknya data yg akan dimasukkan kedalam larik} Read (L[i]) {memasukan elemen larik} Step n While step > 1 do Step step div 3 + 1 For start 1 to step do I start + step While i <= n do Y L[i] {cari posisi yg tepat untuk Y di dalam larik L[1..i-1] sambil menggeser} J i - step Ketemu false While (j >= 1) and (not ketemu) do If Y < L[J] then L[J + step] L[J] {geser} J J - step else ketemu true Endif Endwhile 26

{ J < 1 or ketemu} L[J + step] Y {sisipkan Y pada tempat yang sesuai} i i + step Endwhile Endfor Endwhile Write (L[K])

2.2 Latihan Praktikum Pertemuan II dan III 2.2.1 Latihan Praktikum Pertemuan II 1. Buatlah program dari 6 algoritma yang telah dibahas pada algoritma pengurutan apung dan seleksi. 2. Buatlah algoritma dan program untuk melakukan pengurutan data dengan menggunakan salah satu metode pengurutan diatas. Ada tiga data yang harus diurutkan : a. NIM b. Nama c. Golongan Darah 2.2.2 Latihan Praktikum Pertemuan III 1. Buatlah program dari 3 algoritma yang telah dibahas pada algoritma pengurutan sisip dan shell. 2. Buatlah algoritma dan program untuk melakukan pengurutan data terurut menurun dengan menggunakan metode pengurutan shell.

27

BAB III MATRIKS (LANJUTAN)

3.1 Definisi Matriks Matriks adalah struktur penyimpanan data di dalam memori utama yang setiap individu elemennya diacu dengan menggunakan dua buah indeks yaitu; indeks baris dan indeks kolom. 3.2 Pendeklarasian Matriks Ada beberapa cara pendeklarasian matriks sbb : 1. Sebagai nama peubah DEKLARASI L : Array [1..5,1..4] of integer 2. Sebagai tipe DEKLARASI Type Mat : Array [1..5,1..4] of integer L : Mat {L adalah nama matriks bertype Mat} 3. Sebagai sebuah konstanta DEKLARASI Const NbarisMaks = 20 {jumlah baris maksimum} Const NkolomMaks = 20 {jumlah kolom maksimum} L : Array [1..NbarisMaks,1..NkolomMaks] of integer 3.3 Pemrosesan Matriks Algoritma pemrosesan matriks pada umumnya adalah memanipulasi elemen-elemen matriks. Pemrosesan matriks adalah proses beruntun, setiap elemen matriks dikunjungi lalu dilakukan aksi terhadap elemen tersebut. Karena secara lojik elemen matriks disusun dalam susunan baris dan kolom, maka pemrosesan matriks dilakukan per baris dan per kolom. Skema umum pemrosesan matriks dengan gaya per-baris per-kolom : DEKLARASI Const NbarisMaks = 20 {jumlah baris maksimum} Const NkolomMaks = 20 {jumlah kolom maksimum} L : Array [1..NbarisMaks,1..NkolomMaks] of integer Nbar, Nkol : integer {ukuran baris dan kolom matriks} I : integer {indeks baris} j : integer {indeks kolom} DESKRIPSI Read (Nbar) Read (Nkol) For I 1 to Nbar do For J 1 to Nkol do Proses L[I,j] Endfor 28

Endfor Proses L[I,j] adalah operasi yang memanipulasi nilai L[I,j] seperti operasi I/O, baca, tulis, komputasi, pengubahan dsb Selain struktur for struktur pengulangan while dan repeat juga dapat digunakan untuk pemrosesan matriks. DEKLARASI Const NbarisMaks = 20 {jumlah baris maksimum} Const NkolomMaks = 20 {jumlah kolom maksimum} L : Array [1..NbarisMaks,1..NkolomMaks] of integer Nbar, Nkol : integer {ukuran baris dan kolom matriks} I : integer {indeks baris} j : integer {indeks kolom} DESKRIPSI Read (Nbar) Read (Nkol) I 1 while I Nbar do J 1 While J Nkol do Proses L[I,j] JJ+1 Endwhile II+1 Endfor Proses L[I,j] adalah operasi yang memanipulasi nilai L[I,j] seperti operasi I/O, baca, tulis, komputasi, pengubahan dsb DEKLARASI Const NbarisMaks = 20 {jumlah baris maksimum} Const NkolomMaks = 20 {jumlah kolom maksimum} L : Array [1..NbarisMaks,1..NkolomMaks] of integer Nbar, Nkol : integer {ukuran baris dan kolom matriks} I : integer {indeks baris} j : integer {indeks kolom} DESKRIPSI Read (Nbar) Read (Nkol) I 1 Repeat J 1 Repeat Proses L[I,j] JJ+1 Until J > Nkol II+1 Until I > Nbar Proses L[I,j] adalah operasi yang memanipulasi nilai L[I,j] seperti operasi I/O, baca, tulis, komputasi, pengubahan dsb 29

3.3.1

Mencari Elemen dalam matriks a. Mencari elemen terbesar dalam matriks Elemen maksimum matriks adalah elemen matriks yang mempunyai nilai terbesar. Elemen maksimum matriks dicari dengan menelusuri semua elemen matriks mulai dari elemen L[1,1] hingga L[Nbar, Nkol] Algoritma mencari elemen terbesar dalam matriks sbb : DEKLARASI Const NbarisMaks = 20 {jumlah baris maksimum} Const NkolomMaks = 20 {jumlah kolom maksimum} L : Array [1..NbarisMaks,1..NkolomMaks] of integer Nbar, Nkol : integer {ukuran baris dan kolom matriks} i : integer {indeks baris} j : integer {indeks kolom} maks : integer DESKRIPSI Read (Nbar) Read (Nkol) Read (L[i,j]) Maks L[1,1] {diasumsikan elemen pertama adalah elemen maksimum sementara} For I 1 to Nbar do For J 1 to Nkol do If L[i,j] > Maks then Maks L[i,j] Endfor Endfor Write (Maks) b. Mencari elemen tertentu dalam matriks Mencari nilai tertentu dalam matriks, bila data ditemukan maka indeks baris dan kolom data ditemukan ditampilkan. Algoritma pencarian elemen ini menggunakan pencarian beruntun. DEKLARASI Const NbarisMaks = 20 {jumlah baris maksimum} Const NkolomMaks = 20 {jumlah kolom maksimum} L : Array [1..NbarisMaks,1..NkolomMaks] of integer Nbar, Nkol : integer {ukuran baris dan kolom matriks} I : integer {indeks baris} j : integer {indeks kolom} idxBar, idxKol : integer x : integer ketemu : Boolean DESKRIPSI Read (Nbar) Read (Nkol) Read (L[I,j]) Read (X) 30

I1 Ketemu false While (I Nbar) and (not ketemu) do J1 While (j Nkol) and (not ketemu) do If L[I,j] = X then ketemu true else jj+1 endif Endwhile If not ketemu then ii+1 endif Endwhile If ketemu then IdxBar i IdxKol j Write (X,ketemu nih di baris ,idxBaris, dan kolom : idxKol) Else IdxBar -1 IdxKol -1 Write (X,ga ketemu nih ) endif

3.3.2

Matriks Transpose Matriks transpose adalah matriks yang diperoleh dari matriks yang lain. Matriks transpose dihasilkan dengan mentrasnformasikan seluruh elemen pada baris i dari matriks asal menjadi elemen-elemen kolom j pada matriks transpose, sedemikian sehingga menjadi : At [j,i] = A[I,j] untuk setiap I dan j Contoh matriks A dan matriks transposenya : 1 2 1 3 5 3 4 2 4 6 5 6 A At Ukuran matriks pada matriks transpose akan berkebalikan dengan ukuran matriks asal, diasumsikan ukuran matriks transpose lebih kecil dari ukuran maksimum matriks yang telah dideklarasikan. DEKLARASI Const NbarisMaks = 20 {jumlah baris maksimum} Const NkolomMaks = 20 {jumlah kolom maksimum} Type MatriksInt = array [1..NbarisMaks,1..NkolomMaks] of integer; L : Matriksint {matriks asal} Lt : Matriksint {matriks transpose} 31

Nbar, Nkol : integer {ukuran baris dan kolom matriks} I : integer {indeks baris} j : integer {indeks kolom} NbarLt, NKolLt : integer {ukuran baris dan kolom matriks transpose} DESKRIPSI Read (Nbar) Read (Nkol) Read (l[I,j]) NbarLt Nkol NkolLt Nbar {proses transpose} For I 1 to Nbar do For J 1 to Nkol do Lt[j,i] L[i,j] Endfor Endfor Write (Lt[I,j]) 3.3.3 Perkalian Matriks Perkalian dua buah matriks A dan B menghasilkan matriks C yaitu C = A x B, syarat perkalian matriks A dan B adalah jumlah kolom matriks A harus sama dengan jumlah baris matriks B Misalkan A[1..m,1..n] dan B[1..n,1..p] yg dalam hal ini : m, adalah jumlah baris matriks A n, adalah jumlah kolom matriks A dan jumlah baris matriks B p, adalah jumlah kolom matriks B Hasil perkalian A dan B akan menghasilkan matriks C [1..m,1..p]
Contoh perkalian matriks : (1 10) + (2 12) + (3 14) (1 11) + (2 13) + (3 15) 1 2 3 10 11 76 82 4 5 6 X 12 13 = (4 10) + (5 12) + (6 14) (4 11) + (5 13) + (6 15) = 184 199 7 8 9 14 15 292 316 (7 10) + (8 12) + (9 14) (7 11) + (8 13) + (9 15)

Algoritma perkalian dua buah matriks DEKLARASI Const NbarisMaks = 20 {jumlah baris maksimum} Const NkolomMaks = 20 {jumlah kolom maksimum} Type MatriksInt = array [1..NbarisMaks,1..NkolomMaks] of integer; A : Matriksint {matriks A} B : Matriksint {matriks B} C : Matriksint {matriks C} m,n,p : integer NbarC, NkolC : integer {ukuran baris dan kolom matriks C} I : integer {indeks baris} j : integer {indeks kolom} k : integer 32

DESKRIPSI Read (m) {jumlah baris yg akan digunakan pd Matriks A} Read (n) {jumlah kolom dan baris yg akan digunakan pd Matriks A dan B} Read (p) {jumlah kolom yg akan digunakan pd Matriks B} Read (A[I,j]) Read (B[I,j]) NbarC m {inisialisasi jumlah baris untuk matriks C} NkolC p {inisialisasi jumlah kolom untuk matriks C} {proses perkalian matriks} For I 1 to m do For J 1 to p do C[I,j] 0 For k 1 to n do C[I,j] C[I,j] + A[I,k] * B[k,j] Endfor Endfor Endfor Write (C[I,j])

3.4 Latihan Praktikum 1. Buatlah program dari 4 algoritma diatas mulai dari mencari nilai elemen maksimum matriks hingga ke perkalian matriks 2. Buatlah algoritma dan program untuk mencari elemen minimum pada sebuah matriks.

33

BAB IV ALGORITMA REKURSIF

4.1 Pengertian Rekursif Rekursif merupakan suatu proses di mana sebuah fungsi/prosedur memanggil dirinya sendiri. Dengan kata lain algoritma rekursif adalah algoritma yang memanggil dirinya sendiri, oleh karena itu algoritma rekursif harus dinyatakan dalam prosedur atau fungsi, karena hanya prosedur dan fungsi yang dapat dipanggil dalam sebuah program. Syarat bentuk rekursif adalah : a. Fungsi atau Prosedur yang memanggil dirinya sendiri b. Terdapat basis untuk menghentikan proses rekursif (basis adalah bagian yang berisi kasus yang terdefinisi secara eksplisit, bagian ini juga sekaligus menghentikan rekursifdan memberikan sebuah nilai yang terdefinisi pada fungsi rekursif) c. Subroutine call yang melibatkan parameter yang nilainya menuju kondisi nilai terminal (recurrence) Bentuk rekursif bertujuan untuk : a. Menyederhanakan penulisan program b. Menggantikan bentuk iterasi (struktur pengulangan) 4.2 Proses Rekursif Berikut ini adalah contoh fungsi rekursif : a. Menghitung perkalian a x b a x b = a + a + a + + a (sebanyak b kali) = a + (a x (b 1)) Maka, axb= (i) a , jika b = 1 {basis} (ii) a + (a x (b 1)) , jika b > 1 {rekurens} Function kali (input a,b : integer)integer { mengembalikan nilai a x b , a dan b > 0 Basis : a x b = a jika b = 1 Rekurens : a x b = a + (a x (b 1)) jika b > 1 } Algoritma If b = 1 then Return a Else Return a + kali (a, b 1) Endif

34

{Program pemanggil fungsi rekursi} Program RekursiKali Deklarasi a,b : integer function kali(input a,b : integer)integer Deskripsi Read (a) Read (b) Write (kali(a,b))

b. Menghitung factorial n! = n x (n-1) x (n-2) x x n = n x (n-1)! Maka, (i) n! = 1 , jika n = 0 {basis} (ii) n! = n x (n-1)! , jika n > 0 {rekurens} Function factorial(input n : integer)integer {mengembalikan nilai n! Basis : jika n = 0, maka 0! = 1 Rekurens : jika n > 0, maka n! = n x (n-1)!} Algoritma If n = 0 then Return 1 Else Return n * factorial (n-1) Endif

{Program pemanggil fungsi rekursi} Program RekursiFactorial Deklarasi n : integer function factorial(input n : integer)integer Deskripsi Read (n) Write (factorial(n)) c. Menghitung perpangkatan an = a x a x a x x a (sebanyak n kali) = a x an-1 Maka, (i) an = 1 , jika n = 0 (ii) an = a x an-1 , jika n > 0

35

Function pangkat(input a,n : integer) integer {mengembalikan nilai an Basis : jika n = 0, maka an = 1 Rekurens : jika n > 0, maka an = a x an-1} Algoritma If n = 0 then Return 1 Else Return a * pangkat (a, n-1) Endif

{Program pemanggil fungsi rekursi} Program RekursiPangkat Deklarasi a,n : integer function pangkat(input a,n : integer)integer Deskripsi Read (a) Read (n) Write (pangkat(a,n))

d. Menentukan deret bilangan Fibonacci ke-n Deret bilangan Fibonacci adalah bilangan deret yang dimulai dari bilangan 1 untuk deret ke-1 dan untuk deret ke-2 lalu deret ke-3 adalah penjumlahan dari 2 deret sebelumnya dan begitu seterusnya. Contoh deret fibonacci : 1 1 2 3 5 8 13 21 Fibo(n) = 1 , 1 , 2 , 3 , 5 , (fibo(n-1) + fibo(n-2)) Maka, (i) Fibo(n) = 1 , jika n=1 atau n=2 (ii) Fibo(n) = fibo(n-1)+fibo(n-2) , jika n > 2 Function Fibonacci(input n:integer)integer {menentukan bilangan deret Fibonacci ke-n Basis : Fibo(n) = 1 jika n=1 atau n=2 Rekurens : Fibo(n) = fibo(n-1)+fibo(n-2) jika n > 2} Algoritma If n=1 or n=2 then Return 1 Else Return Fibonacci(n-1) + Fibonacci(n-2) Endif 36

{Program pemanggil fungsi rekursi} Program RekursiFibonacci Deklarasi n : integer function fibonacci(input n : integer)integer Deskripsi Read (n) Write (fibonacci(n)) e. Mencari indeks larik yang elemennya = x, pencarian dilakukan dengan metode pencarian beruntun (sequential search) (i) Cari (A,n,x,j) = j , jika A[j] = x Cari (A,n,x,j) = -1 , jika j > n (ii) Cari = Cari (A,n,x,j+1) , jika j n Function cari(input A : larik, n,x,j : integer) integer {mencari indeks larik ke-j, j berisi indeks elemen larik yang dicari Basis : Cari = j jika A[j] = x Cari = 0 jika j > n Rekurens : jika j n, maka cari = cari (A,n,x,j-1) } Algoritma If A[j] = x then Return j Else If j > n then Return -1 Else Return cari(A,n,x,j+1) Endif Endif {Program pemanggil fungsi rekursi} Program RekursiCariIndeks Deklarasi Const nmaks = 100 Type Larik : array [1..nmaks] of integer A : larik n : integer x : integer j : integer function cari(input A : larik, input n,x,j : integer)integer Deskripsi Read (n) Read (A[j]) Read (x) J=1 Write (cari(A,n,x,j) 37

f.

Mencari nilai maksimum dalam larik A[1..n] (i) Maks(A,j) = A[j] , jika j = 1 Maks(A,j) = A[j] , jika A[j] > Maks(A,j-1) (ii) Maks = Maks(A,j-1) , jika Maks(A,j-1) > A[j] Function Maks(input A : larik, input j : integer) integer {mengembalikan nilai maksimum larik A[1..n] Basis : jika n = 1 , maka maks(A,n) = A[1] Jika A[n] > maks(A,n-1) , maka maks(A,n) = A[n] Rekurens : jika maks(A,n-1) > A[n] , maka Maks = Maks(A,n-1)} Algoritma If j = 1 then Return A[1] Else if A[j] > Maks(A,j-1) then Return A[j] Else Return Maks(A,j-1) Endif Endif {Program pemanggil fungsi rekursi} Program RekursiMaks Deklarasi Const nmaks = 100 Type Larik : array [1..nmaks] of integer A : larik n : integer j : integer function maks(input A : larik, input j : integer)integer Deskripsi Read (n) Read (A[j]) Write(maks(A,j))

4.3 Latihan Praktikum Pertemuan V 1. Buatlah program dari algoritma yang telah di bahas diatas 2. Buatlah program untuk contoh-contoh fungsi rekursif diatas kedalam prosedur 3. Buatlah algoritma dan program menggunakan algoritma rekursif untuk permasalahan di bawah ini : a. menentukan deret ke-n untuk bilangan ganjil dan genap b. menjumlahkan deret hingga ke-n untuk bilangan bulat positif c. mencari nilai elemen minimum pada sebuah larik

38

BAB V ARSIP BERUNTUN

5.1 Definisi Arsip Beruntun Arsip atau berkas adalah struktur penyimpanan data di dalam memori sekunder seperti disk. Data disimpan dalam arsip agar sewaktu-waktu arsip dapat dibuka kembali. Pada umunya arsip menyimpan informasi dari kategori yang sama, misalnya data buku disimpan dalam arsip buku, data mahasiswa disimpan dalam arsip mahasiswa. Setiap arsip dikenali melalui namanya. Setiap item data yang direkam dalam arsip disebut rekaman (record) dan pengorganisasian data di dalam arsip terbagi kedalam 2 cara yaitu : beruntun (sequential) dan acak (random) atau akses langsung. Arsip beruntun adalah sekumpulan rekaman bertipe sama yang diakses secara beruntun mulai dari rekaman pertama sampai rekaman yang dituju atau sampai dengan rekaman yang terakhir. Rekaman dalam arsip beruntun diakses secara satu per satu secara searah. Struktur arsip beruntun, seperti halnya pada larik kita dapat membayangkan struktur logic arsip beruntun dengan sederetan kotak yang memanjang horizontal atau vertical, secara umum struktur arsip beruntun tidak jauh berbeda dengan struktur larik , berikut adalah table persamaan dan perbedaan antara arsip beruntun dan larik : Arsip Beruntun Struktur logic arsip beruntun dapat digambarkan sebagai sederetan kotak yang memanjang horizontal atau vertical 1. Pengaksesan elemen tidak dapat diakses secara kangsung, harus dibaca dari awal rekaman 2. Pemrosesan elemen/rekaman hanya dapat dilakukan dalam satu arah, dimulai dari rekaman pertama sampai terakhir tidak dapat dari arah sebaliknya 3. Pemrosesan elemen/rekaman berakhir jika sudah sampai pada tanda akhir arsip (end of file) Larik Struktur logic larik dapat digambarkan sebagai sederetan kotak yang memanjang horizontal atau vertical 1. Pengaksesan elemen dapat dilakukan secara langsung melalui indeksnya 2. Pemrosesan elemen larik dapat dilakukan baik dari elemen paling pertama sampai akhir ataupun sebaliknya dari akhir menuju elemen pertama 3. Pemrosesan elemen larik berakhir jika pencatat indeks sudah melebihi ukurak larik (biasa disimbolkan dengan N)

Persamaan

Perbedaan

39

5.2 Pendeklarasian Arsip Beruntun Terdapat 3 Cara pendeklarasian arsip dalam algoritma sbb : 1. Deklarasi arsip beruntun sebagai peubah (variabel) DEKLARASI Arsip : File of tipe data rekaman {tipe rekaman dapat berupa tipe dasar (integer, real, char, Boolean, string) atau tipe terstruktur (record)} 2. Deklarasi arsip beruntun sebagai tipe bentukan DEKLARASI Type nama tipe arsip : File of tipe data rekaman Arsip : nama tipe arsip

3. Deklarasi arsip beruntun sebagai tipe rekaman DEKLARASI Type nama tipe rekaman : record < dtArsip : tipe data rekaman > Arsip : File of nama tipe rekaman

Contoh-contoh pendeklarasian arsip beruntun : 1. Arsip Bil yang berisi sekumpulan data integer Notasi Algoritmik : DEKLARASI Bil : File of integer {peubah} Pascal : Bil : file of integer; {arsip} I : integer; {rekaman} 2. Arsip Mhs yang berisi data mahasiswa (NIM, nama dan IP) dan setiap rekaman dalam arsip Mhs bertipe terstruktur (record) Notasi Algoritmik : DEKLARASI Type DtMhs : record <NIM : integer, nama : string, IP : real> {tipe rekaman} ArsipMhs : File of DtMhs {arsip} Pascal : Type DtMhs = record Nim : longint; Nama : string [25]; Ip : real; end; var ArsipMhs : file of DtMhs; {arsip} RekMhs : DtMhs; {rekaman}

40

3. Mendefinisikan arsip integer sebagai tipe bentukan Notasi Algoritmik : DEKLARASI Type ArsipInt : file of integer {tipe bentukan} Bil : ArsipInt {arsip bil bertipe arsipint} Pascal : Type ArsipInt = file of integer; Var Bil : ArsipInt; {arsip} I : integer; {rekaman} 4. Mendefinisikan arsip data mahasiswa pada No.2 sebagai tipe bentukan Notasi Algoritmik : DEKLARASI Type DtMhs : record <NIM : integer, nama : string, IP : real> {tipe rekaman} Type ArsipMhs : File of DtMhs {tipe arsip} Mhs : ArsipMhs {arsip bertipe ArsipMhs} Pascal : Type DtMhs = record Nim : longint; Nama : string [25]; Ip : real; end; Type ArsipMhs = file of DtMhs; Var Mhs : ArsipMhs; RekMhs : DtMhs; 5.3 Fungsi Pustaka untuk pemrosesan Arsip Beruntun Dalam melakukan pemrosesan arsip beruntun terdapat instruksi baku yang dinyatakan sebagai fungsi/prosedur pustaka (library function) fungsi tersebut sudah tersedia sehingga kita dapat langsung memakainya. 1. Open Fungsi ini untuk membuka arsip beruntun untuk siap dibaca/ditulis, sebuah arsip beruntun yang dibuka hanya bias untuk masukan saja atau keluaran saja, tidak bias untuk dibaca dan ditulis sekaligus. Notasi algoritmik : Open (nama arsip, kode) Contoh : Open (Mhs, 1) {buka arsip mhs untuk pembacaan} Open (Mhs, 2) {buka arsip mhs untuk penulisan} Open (Bil, 1) {buka arsip mhs untuk pembacaan} -----------------------------------------------------------------------------------------------------------------------Pascal : Assign (pegawai, pegawai.txt) {buka arsip} 41

Rewrite (pegawai) {untuk penulisan/input data arsip} Reset (arsip) {untuk pembacaan/menampilkan hasil inputan} Contoh : Assign (mhs,mhs.dat); {mhs.dat adalah nama arsip fisik} Rewrite (mhs); {input data kedalam arsip mhs yg disimpan dlm arsip fisik mhs.dat} Assign (mhs,mhs.dat); Reset (mhs); {menampilkan hasil inputan data dari arsip fisik mhs.dat} Assign (bil,bil.dat); Reset (bil); {bil.dat adalah nama arsip fisik}

2. Fread Fungsi untuk membaca rekaman yang sekarang sedang ditunjuk oleh pointer Notasi Algoritmik : Fread (nama arsip, rekaman) Contoh : Fread (mhs, RekMhs) Fread (bil, i) Fread (kar, ch) -----------------------------------------------------------------------------------------------------------------------Pascal : Read (arsip, rekaman) Contoh : Read (mhs, RekMhs); {RekMhs adalah nama rekaman dari arsip mhs} Read (bil, I); {I adalah nama rekaman dari arsip bil} Read (kar, ch); {ch adalah nama rekaman dari arsip kar}

3. Fwrite Fungsi untuk menulis rekaman ke dalam arsip beruntun Notasi Algoritmik : Fwrite (nama arsip, nama rekaman) Contoh : Fwrite (mhs, <202, shinta maulida, 3.22>) Fwrite (bil, 123) Fwrite (kar, AB) RekMhs.nim 20223 RekMhs.nama Suyudi RekMhs.ip 3.35 Fwrite (mhs, RekMhs) -----------------------------------------------------------------------------------------------------------------------Pascal : Write (arsip, rekaman) Contoh : RekMhs.nim := 202;

{proses input data nim kedalam rekaman RekMhs} 42

RekMhs.nama := shinta; {proses input data nama kedalam rekaman bernama RekMhs RekMhs.ip := 3.22; {proses input data ip kedalam rekaman RekMhs} Write (mhs, RekMhs); {RekMhs adalah nama rekaman yg menyimpan data mahasiswa yg telah diinput dan tersimpan dalam arsip mhs} Write (bil, 123); Write (kar, AB); RekMhs.nim := 20223; RekMhs.nama := suyudi; RekMhs.ip := 3.35; Write (mhs, RekMhs); 4. Close Fungsi untuk menutup arsip yang sudah dibuka Notasi Algoritmik : Close (nama arsip) Contoh : Close (mhs) Close (bil) Close (kar) -----------------------------------------------------------------------------------------------------------------------Pascal : Close (arsip) Contoh : Close (mhs); Close (bil); Close (kar); 5. EOF (End Of File) Fungsi untuk mendeteksi akhir arsip. Fungsi ini mengembalikan nilai true jika tanda akhir arsip dicapai atau false jika tidak. Notasi Algoritmik : While not EOF (arsip) do Fread (arsip, rek) Endwhile Pascal : While not EOF (mhs) do begin read (mhs, rekMhs); end;

43

5.4 Membuat Arsip Beruntun Contoh 1. mengisi arsip bilangan bulat dengan nilai yg dibaca dari papan ketik. Notasi Algoritmik : PROGRAM BuatArsipBilangan DEKLARASI Bil : File of integer {arsip bil.bulat} N : integer {banyaknya bil.bulat} I : integer {pencacah pengulangan} X : integer {peubah untuk membaca inputan bil.bulat dr piranti masukan/rekaman arsip bil}

DESKRIPSI Open (bil, 2) Read (n) For I 1 to n do Read (x) Fwrite (Bil, x) Endfor Close (bil) Pascal :

Contoh 2. membaca arsip bilangan bulat pada contoh no.1 Notasi Algoritmik : PROGRAM BacaArsipBilangan DEKLARASI Bil : File of integer {arsip bil.bulat} N : integer {banyaknya bil.bulat} X : integer {peubah untuk membaca inputan bil.bulat dr piranti masukan}

44

DESKRIPSI Open (bil, 1) While not EOF (bil) do Fread (Bil, x) Write (x) Endwhile Close (bil) Pascal :

Contoh 3. mengisi dan membaca arsip mahasiswa dengan data mahasiswa yang dibaca dari papan ketik DEKLARASI Type dtMhs = record <nim : integer, nama : string, ip : real> {tipe rekaman} Msiswa : dtMhs {penampung data rekaman} Mhs : file of dtMhs {arsip} I , n : integer DESKRIPSI Open (mhs, 2) Read (n) For i1 to n do Read (Msiswa.nim, Msiswa.nama, Msiswa.ip) Fwrite (Mhs, Msiswa) Endfor Open (mhs, 1) While not EOF (mhs) do Fread (Mhs, Msiswa) Write (Msiswa) Endwhile Close (mhs)

45

Pascal :

Contoh 4. Mencari NIM tertentu dari arsip data mahasiswa yg terdapat pada contoh 3 dg arsip fisik dtmhs.txt DEKLARASI Type dtMhs = record <nim : integer, nama : string, ip : real> {tipe rekaman} Msiswa : dtMhs {penampung data rekaman} Mhs : file of dtMhs {arsip} Nomor : integer {data nim yg akan dicari} Ketemu : boolean DESKRIPSI Ketemu false Open (mhs, 1) Read (nomor) While not EOF (mhs) and not ketemu do Fread (Mhs, Msiswa) If Msiswa.nim = nomor then Ketemu true Endif Endwhile 46

If ketemu then Write (Msiswa.nim,Data yg dicari ditemukan) Else Write (nomor,Data yg dicari tidak ditemukan) Close (mhs) Contoh 5. kasus pengelolaan data nilai mahasiswa Pada contoh kasus ini akan menampilkan : a. Rekam data matakuliah yang ditempuh oleh setiap mahasiswa beserta dengan nilainya. b. Cetak daftar nilai mahasiswa beserta dengan data matakuliah yg ditempuh. c. Cetak daftar mahasiswa yang mengambil matakuliah tertentu. Untuk setiap satu mahasiswa akan berisi banyak nilai dan banyak data matakuliah. Rekaman dengan NIM yg sama akan disimpan secara berurutan. Setiap rekaman akan berisi data : 1. 2. 3. 4. 5. NIM Nama mahasiswa Kode matakuliah SKS matakuliah Indeks nilai setiap matakuliah (A,B,C,D)

Procedure rekamDataMhs (output mhs : arsipMhs) DEKLARASI N : integer {jumlah data mhs yg akan dientri} I : integer {pencacah pengulangan} DESKRIPSI Open (mhs, 2); Read (n) For I 1 to n do Read (kulMhs.nim) Read (kulMhs.nama) Read (kulMhs.kodemk) Read (kulMhs.sks) Read (kulMhs.indeks) Fwrite (mhs, kulMhs) Endfor Close (mhs) Procedure cetakDaftarNilai (input kdnim:integer output mhs : arsipMhs) {mencetak daftar nilai mahasiswa untuk NIM tertentu} DEKLARASI ketemu : Boolean DESKRIPSI Open (mhs, 1) Ketemu false While not EOF (mhs) and not ketemu then Fread (mhs, kulMhs) If kulMhs.nim = kdnim then Ketemu true Endif Endwhile 47

If ketemu then Write (DAFTAR NILAI MATAKULIAH) Write (NIM :,kulMhs.nim) Write (Nama :,kulMhs.nama) Write (------------------------------------------) Write (No Matakuliah SKS NIlai) Write (------------------------------------------) No 1 While kulMhs.nim = kdnim and not EOF (mhs) Fread (mhs, kulMhs) Write (no, kulMhs.kodemk, kulMhs.sks, kulMhs.index) No no + 1 Endwhile Write (------------------------------------------) Else Write (data mahasiswa dengan NIM :,kdnim,tidak ada) Endif Close (mhs) Procedure CetakDaftarPesertaMk (input matkul:string, output mhs:arsipMhs) {mencetak daftar peserta matakuliah untuk matakuliah tertentu} DESKRIPSI Open (mhs, 1) Write (DAFTAR PESERTA MATAKULIAH) Write (Kode Matakuliah :,matkul) Write (------------------------------------------) Write (No NIM Nama NIlai) Write (------------------------------------------) No 1 While not EOF (mhs) do Fread (mhs, kulMhs) If kulMhs.kodemk = matkul then Write (no, kulMhs.nim, kulMhs.nama, kulMhs.index) No no+1 Endif Endwhile Write (------------------------------------------) Close (mhs) Program kelolaMatkulMhs DEKLARASI Type dtmhs : record <nim:integer, nama:string, kodemk:string, sks:integer, indeks:char> Type arsipMhs : file of dtmhs Mhs : arsipMhs {peubah arsip} kulMhs : dtmhs {rekaman} Kdnim : integer Menu : integer Matkul : string No : integer {no urut} Procedure rekamDataMhs (output mhs : arsipMhs) Procedure cetakDaftarNilai (input kdnim:integer output mhs : arsipMhs) 48

Procedure CetakDaftarPesertaMk (input matkul:string, output mhs:arsipMhs) DESKRIPSI Repeat Write (Pilihan Menu) Write (1. Rekam Data Mahasiswa) Write (2. Cetak Daftar Nilai Mahasiswa) Write (3. Cetak Daftar Peserta Matakuliah) Write (4. Keluar) Write (Pilih Menu 1/2/3/4 :) read(menu) Case menu of 1 : rekamDataMhs(mhs) 2 : read (kdnim) {input nim mhs yg akan dicetak daftar nilainya} CetakDaftarNilai (kdnim, mhs) 3 : read (matkul) {input matakuliah yg akan dicetak daftar pesertanya} CetakDaftarPesertaMk (matkul, mhs) Until menu 4

5.5 Latihan Praktikum 1. Buatlah program dari algoritma yang telah dibahas di atas 2. Buatlah algoritma dan program untuk menambahkan pilihan menu pada contoh kasus no.5 di atas sbb : a. Mencetak daftar nilai matakuliah untuk setiap mahasiswa dicetak dalam satu tampilan Contoh keluaran sbb : DAFTAR NILAI MATAKULIAH NIM : xxxx Nama : xxxx No Mata Kuliah SKS Nilai 1 XXX X X 2 XXX X X 3 XXX X X DAFTAR NILAI MATAKULIAH NIM : xxxx Nama : xxxx No Mata Kuliah SKS Nilai 1 XXX X X 2 XXX X X 3 XXX X X

b. Mencetak daftar IP mahasiswa dengan ekivalensi nilai indeks dalam angka (A=4, B=3, C=2, D=1, E=0) rumus untuk menghitung IP adalah : Total nilai = angka x sks IP = total nilai / total sks

49

Contoh keluaran sbb : DAFTAR IP MAHASISWA NIM Nama XXX XXXXX XXX XXXXX XXX XXXXX

No 1 2 3

IP X.XX X.XX X.XX

50

BAB VI STRUKTUR DATA

6.1 Definisi Struktur Data Secara garis besar perangkat lunak atau biasa dikenal dengan nama PROGRAM terdiri dari kumpulan algoritma dan struktur data PROGRAM = ALGORITMA + STRUKTUR DATA Apakah kaitan algoritma dan struktur data? Algoritma adalah deskripsi langkah-langkah penyelesaian masalah yang tersusun secara logis atau urutan logis pengambilan keputusan untuk pemecahan suatu masalah. Ditulis dengan notasi khusus Notasi mudah dimengerti Notasi dapat diterjemahkan menjadi sintaks suatu bahasa pemrograman

Struktur data adalah model logika/matematik yang secara khusus mengorganisasi data. Sebuah model harus dapat mencerminkan keterhubungan data dengan dunia nyata dan bentuknya sederhana/efektif (dapat memproses data sesuai kebutuhan). Dalam istilah ilmu komputer, sebuah struktur data adalah cara penyimpanan, penyusunan dan pengaturan data di dalam media penyimpanan komputer sehingga data tersebut dapat digunakan secara efisien.

Dalam teknik pemrograman, struktur data berarti tata letak data yang berisi kolom-kolom data, baik itu kolom yang tampak oleh pengguna (user) atau pun kolom yang hanya digunakan untuk keperluan pemrograman yang tidak tampak oleh pengguna. Setiap baris dari kumpulan kolom-kolom tersebut dinamakan catatan (record). Terdapat 2 jenis struktur data yaitu : a. Struktur data statis Struktur yang tidak berubah seperti larik/array, record, himpunan, jenis struktur data ini telah disediakan pada bahasa pemrograman (contohnya bahasa pascal) b. Struktur data dinamik Struktur data yang berubah seperti list/senarai, queue/antrian, tumpukan/stack, pohon, graph, jenis struktur data ini tidak terdapat dalam bahasa pemrograman namun dapat dibentuk sendiri.

51

6.2 Contoh-Contoh Struktur Data a. Larik/Array Adalah struktur data yang diproses melalui indeksnya. Struktur data ini termasuk yang paling mudah digunakan.

Array A satu dimensi : 8 indeks (1 s/d 8) dan data 1, 7, 18 dst.

1 7 18 03 69 24 08 70

Ar ray B dua di mensi (matr iks) : - j uml ah bari s 2, kol om 3 - d ata 18, 03, 69, 24, 08, 70.

1 1 2
18

2
03

3
69

24

08

70

b. List Berkait/Senarai Adalah struktur data yang diproses melalui alamat kepala (awal). Info adalah tempat untuk datanya, next untuk menyimpan alamat berikutnya. Struktur ini merupakan struktur dinamis dimana ukurannya dapat berubah pada saat eksekusi program

52

c. Pohon Adalah struktur data yang diproses melalui alamat akarnya (root). Struktur ini merupakan struktur dinamis dimana ukurannya boleh berubah. Datanya mempunyai hubungan hirarki di antara elemennya

Pohon dengan akar A

d. Tumpukan/Stack Struktur data ini diproses (penambahan dan penghapusan data) hanya pada satu ujung yaitu pada posisi TOP-nya. Struktur data ini menggunakan system LIFO (last in first out)
Tumpukan dengan tiga data ( 18, 03, dan 69 yang mer upakan posisi terakhir / TOP )

69

<< TOP

03

18

e. Antrian/Giliran Struktur data ini mirip stack, diproses dari dua ujung, penambahan pada posisi belakang sedangkan penghapusan data pada posisi depan. Struktur data ini menggunakan system FIFO (first in first out)

AMBIL

69

03

18

TAMBAH

53

f.

Graph Struktur data ini mirip dengan struktur data pohon. Hanya saja hubungan antar data tidak selalu hubungan hirarki

Graf dengan simpul X, Y, T dan S

7 3

X
6
1

Y
2

T
4 5

Didalam struktur data diperlukan tempat penyimpanan data dan organisasi/operasi terhadap data tersebut. Operasi-operasi standar yang dimiliki antara lain : a. b. c. d. e. f. Traversal (Traversing) : mengunjungi setiap elemen SD (Struktur Data) Pencarian (Searching) : menemukan elemen/lokasi pada SD Penyisipan (Inserting) : menambah elemen baru pada SD Penghapusan (Deleting) : menghapus elemen dari SD Pengurutan (Sorting) : menyusun urutan elemen secara logika Penyambungan (Merging) : menggabung 2 buah SD

Mengapa Perlu Struktur Data ? Mengenal bentuk organisasi penyimpanan data dan pengoperasiannya. Menentukan kualitas informasi : akurat, tepat pada waktunya dan relevan. Informasi dapat dikatakan bernilai bila manfaatnya lebih efektif dibandingkan dengan biaya mendapatkannya. Mengurangi duplikasi data (data redudancy) Hubungan data dapat ditingkatkan (data relatability) Mengurangi pemborosan tempat simpanan luar

54

BAB VII TIPE DATA POINTER

7.1 Pengertian Pointer Pointer adalah suatu tipe data yang digunakan untuk mengalokasikan dan mendealokasikan tempat untuk variable penyimpan data. Pointer disebut juga sebagai peubah dinamis, nilai yang dimilikinya bukan data melainkan nilai yang menunjuk ke lokasi lain (alamat) yang berisi data sesunggunya yang akan diproses. Contoh peubah statis adalah array (larik) dimana lokasi-lokasi data sudah ditentukan dan tidak bisa diubah selama program dieksekusi. Kerugiannya menggunakan array adalah bahwa banyaknya data yang bisa diolah menjadi terbatas sesuai dengan kapasitas arraynya. Ilustrasi :

1000 1.

10 10 2. 1000

Gambar 1. diatas mengilustrasikan perubah A adalah perubah statis. Dalam hal ini 1000 adalah nilai data yang sesungguhnya dan disimpan pada perubah (lokasi) A. Gambar 2. Diatas mengilustrasikan perubah A adalah perubah dinamis. Nilai pada perubah A adalah 10, nilai ini bukan nilai data yang sesungguhnya tetapi alamat lokasi dimana data yang sesungguhnya berada, jadi dalam hal ini nilai data yang sesungguhnya tersimpan pada lokasi 10. Tabel perbandingan Kriteria Sifat Ukuran Array Statis Pasti Pointer Dinamis Sesuai kebutuhan

7.2 Deklarasi Pointer Bentuk umum deklarasi pointer adalah : Var <nama_var> : <^tipedata>; Contoh : Var nama_mhs : ^string[20]; Nilai : ^real;

55

Deklarasi umum pointer dalam record Type <nama_pointer> = <^nama_record>; <nama_record> = record <item1> : <tipedata1>; <item2> : <tipedata2>; <item n> : <tipedata n>; End; <nama_var> : <nama_pointer>; Contoh : Type

Var

teks = string[20]; Point = ^data; Data = record Nama : teks; Alamat : teks; Pekerjaan : teks; Next : point; End; P1, P2 : point;

Var

Pada contoh diatas P1 dan P2 masing-masing bertipe pointer. Pada saat dikompilasi P1 dan P2 akan menmpati lokasi tertentu dan belum menunjuk ke suatu simpul tertentu, nilainya dinyatakan dengan nil. Untuk mengalokasikan simpul dalam pengingat, statement yang digunakan adalah new dengan bentuk umum : New (P1); Akan terbentuk simpul seperti ini :

P1

P2

Simpul P1 dan P2 berisi medan pointer. Medan nama,alamat,pekerjaan belum mempunyai nilai, maka nilainya ditunjukan dengan tanda ? sedangkan medan yang bertipe pointer (medan next) karena tidak menunjuk ke simpul lain, maka nilainya adalah nil yang disimbolkan dengan tanda

56

7.3 Operasi Pointer Secara umum ada 2 operasi dasar yang bias dilakukan menggunakan data yang bertipe pointer. 1. Operasi yang pertama adalah mengcopy pointer, sehingga sebuah simpul akan ditunjuk oleh lebih dari sebuah pointer. 2. Operasi kedua adalah mengcopy isi simpul sehingga dua atau lebih simpul yang ditunjuk oleh pointer yang berbeda mempunyai isi yang sama. Syarat yang harus dipenuhi untuk kedua operasi ini adalah pointer yang akan dioperasikan harus mempunyai deklarasi yang sama. Contoh : Type teks = string(20); simpul = ^data; Data = record Nama : teks; Alamat : teks; Next : simpul; End; T1, T2 : simpul; Pada deklarasi diatas pointer T1 dan T2 mempunyai deklarasi yang simpul yang sama, sehingga memenuhi syarat kedua operasi. Untuk membentuk simpul kita berikan statement : New (T1); New (T2); Sehingga kita mempunyai 2 simpul sbb : T1 ? ? T2 ? ?

Var

Jika kita isi : T1^.nama := Kabayan; T1^.alamat := Bandung; Maka simpulnya menjadi : T1 kabayan Bandung T2 ? ?

57

1. Operasi mengcopy pointer Dari deklarasi diatas untuk mengcopy pointer dilakukan dengan memebrikan statement : T2 := T1; Maka simpul akan berubah menjadi : T1 kabayan Bandung

T2

Dari gambar diatas pointer T2 menunjuk ke simpul pointer T1, simpul yg semula ditunjuk T2 terlepas. Dalam keadaan seperti ini maka simpul tersebut tidak dapat di isi lagi karena lokasi simpul tersebut dalam pengingat tidak diketahui lagi.

2. Operasi mengcopy isi simpul Dari deklarasi diatas untuk mengcopy pointer dilakukan dengan memberikan statement : T2^ := T1^; Maka simpul akan berubah menjadi : T1 kabayan Bandung

T2

kabayan Bandung

Untuk pointer karena hanya berurusan dengan alamat dalam pengingat, maka hanya bisa dioperasikan dengan dua operator yaitu ( = ) atau ( <> ) 7.4 Menghapus pointer Pointer yang telah dialokasikan (dibentuk) dapat didealokasikan (dihapus) pada saat program diekseskusi. Setelah suatu pointer dihapus, maka lokasi yang semula ditempati oleh simpul yang ditunjuk oleh pointer akan bebas sehingga bisa digunakan oleh perubah lain. Bentuk umum Statemen untuk menghapus pointer adalah : Dispose (peubah) Perubah : sembarang peubah yang bertipe pointer contoh : dispose (T1);

58

Kesimpulan : Dengan pointer memory tempat penyimpanan data dapat digunakan dengan efisien Pointer memiliki operasi copy pointer, copy simpul dan hapus pointer

7.5 Latihan Praktikum Pertemuan VII 1. Buatlah program dari contoh operasi copy pointer dan copy simpul diatas (dibuat dalam 2 program). 2. Buatlah program untuk menyajikan sebuah data menggunakan tipe data pointer dg memberikan menu operasi copy pointer dan copy simpul. (tema bebas) cat. Setiap mahasiswa membuat program dg tema yg berbeda. (dibuat dalam 1 program)

59

BAB VIII SENARAI BERANTAI (LINKED LIST)

7.6 Linked List Linked list merupakan salah satu struktur data yang dinamis, keuntungannya dibandingkan dengan larik adalah pada linked list dapat diketahui pasti kapan penambahan dan penghapusan data berakhir. Linked list adalah komponen yang disusun berurutan dengan bantuan pointer, masing-masing komponen disebut simpul (node), tiap node terdiri dari 2 bagian. Bagian pertama adalah bagian informasi (data) berisi informasi yang akan disimpan dan diolah dan bagian kedua adalah medan penyambung (Link field) berisi alamat simpul selanjutnya. Ilustrasi : First Istilah : First Info Next Nill : Pointer penunjuk lokasi simpul pertama linked list : Informasi /data yang akan diolah : Almat ke simpul selanjutnya : Tidak Bernilai Info next info

7.7 Single Linked List Single linked list adalah linked list dengan simpul yang memilki satu link / pointer yang mengacu ke simpul berikutnya Linked List dengan 4 elemen :

Contoh Lain : Penyajian linked list dalam pengingat utama Info Kiki Toni Agam Via Mira Helmi Iyan Shila Link 8 6 1 0 4 0 7 2 60

LB 3

MI 9

1 2 3 4 5 6 7 8 9

Penyajian dalam single linked list :

7.8 Operasi pada Single Linked List Ada sejumlah operasi yang bisa dilakukan pada sebuah linked list, yaitu operasi membaca, menambah simpul, menghapus simpul, mencari data list. Sebagai penjelasan dari operasi-operasi diatas kita akan gunakan deklarasi pointer dan simpul seperti di bawah ini : TYPE DataString = STRING[30]; ListPointer = ^ListRecord; ListRecord = RECORD Nama : DataString; Alamat : DataString; Next : ListPointer END; VAR awal, akhir, baru : ListPointer; DataNama, DataAlamat : DataString; Operasi-operasi yang dapat dilakukan pada single linked list antara lain : 1. Menambah simpul di belakang sebagai simpul terakhir Ilustrasi :

61

Prosedur :

PROCEDURE BuildListBack(VAR awal, akhir : ListPointer; DataNama : DataString; DataAlamat : DataString); VAR baru : ListPointer; BEGIN NEW(baru); baru^.Nama := DataNama; baru^.Alamat := DataAlamat; if awal = nil then begin awal:=baru; end else begin akhir^.next:=baru; end; akhir:=baru; akhir^.next:=nil; END;

2. Menambah simpul di depan sebagai simpul pertama Ilustrasi :

62

Prosedur :

PROCEDURE BuildListFront(VAR awal, akhir : ListPointer; DataNama : DataString; DataAlamat : DataString); VAR baru : ListPointer; BEGIN NEW(baru); baru^.Nama := DataNama; baru^.Alamat := DataAlamat; if awal = nil then begin akhir:=baru; end else begin baru^.next:=awal; end; awal:=baru; END; 3. Penghapusan simpul pertama dalam list Ilustrasi :

63

Prosedur : Procedure Hapus_Depan(Var awal : ListPointer); Var Baru : ListPointer; Begin Baru := awal; if awal = Nil then Writeln('List Kosong...') else Begin awal := awal^.next; dispose(Baru); End; End; 4. Penghapusan simpul di akhir simpul Ilustrasi :

Prosedur : Procedure Hapus_Belakang(Var awal : ListPointer); Var Baru,bantu : ListPointer; Begin Bantu := awal; if Bantu = Nil then Writeln('List Kosong...') else Begin While Bantu^.next^.next <> nil do Bantu := Bantu^.next; New(Baru); Baru := Bantu^.next; Bantu^.next:=nil; dispose(Baru); End; End; 64

5. Penghapusan simpul pada simpul tertentu Ilustrasi :

Prosedur : Procedure Hapus_Tengah(Var awal : ListPointer; DataNama : DataString); Var Bantu,Hapus : ListPointer; Begin Bantu := awal; if awal = Nil then Writeln('List Kosong...') else Begin Bantu := awal; New(Hapus); While Bantu^.next <> nil Do Begin if Bantu^.next^.nama = DataNama then begin Hapus:=Bantu^.next; Bantu^.next:=Hapus^.next; dispose(Hapus); End else Bantu:=Bantu^.next; End; End; End;

65

6. Membaca isi list Ilustrasi :

Prosedur : PROCEDURE ReadListMaju(awal : ListPointer); var i : integer; bantu : ListPointer; BEGIN writeln(--------------------------); writeln('No Nama Alamat'); writeln(--------------------------); bantu := awal; i:=1; repeat begin Writeln (i,'',bantu^.Nama:8,' ',bantu^.Alamat:8); bantu := bantu^.Next; end; i:=i+1; until bantu=nil; writeln(--------------------------); END; 7. Pencarian list function cariData(DataNama, DataAlamat : DataString; awal:ListPointer):boolean; Var ketemu : boolean; begin ketemu := false; repeat if awal^.nama = DataNama then begin ketemu := true; write(DataNama,' Data ketemu dalam senarai '); end else begin awal := awal^.next; end; until ketemu or (awal = nil); cariData := ketemu; writeln; writeln; end;

66

Untuk menyempurnakan prosedur dan fungsi di atas dalam program, berikut adalah prosedur untuk membaca data-data yang akan dimasukan ke dalam single linked list dan prosedur untuk menampilkan kembali data-data yang telah dimasukan tersebut Prosedur baca data untuk penambahan simpul di depan PROCEDURE GetDataFront(VAR awal:ListPointer); VAR Name:DataString; Addres:DataString; n,i : integer; BEGIN write ('Masukan jumlah data :');readln(n); FOR i:=1 to n DO BEGIN writeln('---Pegawai ke-',i); write('Masukkan nama :');readln(Name); write('Masukan alamat : ');readln(Addres); BuildListFront(awal,akhir,Name,Addres); END; END;

Prosedur baca data untuk penambahan simpul di belakang PROCEDURE GetDataBack(VAR akhir:ListPointer); VAR Name:DataString; Addres:DataString; n,i : integer; BEGIN write ('Masukan jumlah data :');readln(n); FOR i:=1 to n DO BEGIN writeln('---Pegawai ke-',i); write('Masukkan nama :');readln(Name); write('Masukan alamat : ');readln(Addres); BuildListBack(awal,akhir,Name,Addres); END; END;

Prosedur untuk menampilkan kembali hasil dari input data PROCEDURE DisplayInfo(awal:ListPointer); BEGIN writeln; writeln (' DAFTAR PEGAWAI '); ReadListMaju(awal); writeln;writeln; END;

67

7.9 Latihan Praktikum 1. Buatlah program utama untuk mengaplikasikan seluruh operasi pada single linked list di atas. 2. Buatlah prosedur untuk menyimpan data pada simpul ke dalam arsip berupa file yang diberi nama pegawai.txt 3. Aplikasikan program utama dan seluruh prosedur yang telah dibuat diatas.

68

BAB IX TUMPUKAN (STACK) 9.1 Pengertian Stack Bentuk struktur data selain list dalam ilmu computer adalah tumpukan (stack). Tumpukan dapat diartikan sebagai suatu kumpulan data yang seolah-olah ada data yang diletakkan di atas data yang lain dan kita dapat menambahkan / menyisipkan dan mengambil / menghapus data seperti operasi pada bentuk struktur data yang lain, bedanya pada stack semua dilakukan melalui ujung atas tumpukan yang selanjutnya disebut TOP.

Stack dapat diilustrasikan sebagai berikut :

Dengan memperhatikan ilustrasi diatas maka kita bias melihat bahwa tumpukan merupakan suatu senarai (list) yang mempunyai sifat masuk terakhit keluar pertama (Last In First out - LIFO)

9.2 Penyajian Stack Penyajian tumpukan dapat dilakukan dengan 2 cara yaitu : 1. Array Stack adalah sekumpulan data, maka dengan adanya tipe data terstruktur yang disebut array, bisa digunakan untuk menyajikan stack. Tapi akan kita temukan penggunaan array untuk stack kurang tepat, karena banyak elemen dalam array statis, sedang jumlah elemen dalam stack bisa sangat bervariasi Dengan demikian penggunaan array untuk penyajian stack diasumsikan bahwa jumlah elemen lebih kecil dari batas maksimum array, jika pada saat ukuran array dan stack sudah sama dan kita masih menambah data maka akanterjadi overflow, sehingga membutuhkan suatu variable pencatat posisi ujung tumpukan. 69

Deklarasi stack menggunakan array : Const max = 255; Type stack = record Isi : array[1..max] of integer; Atas : 0..max; End; Var T : stack;

Operasi pada stack menggunakan array : a. Operasi Push (Menumpuk/Menyisipkan/Menambah) Operasi ini adalah operasi untuk menumpuk data atau menyisipkan atau menambah data implementasinya : Procedure Push (var T:stack; x : integer); Begin If T.Atas = Max then Writeln (Stack Sudah Penuh); else T.Atas := T.Atas + 1; T.Isi[T.Atas] := x; End; b. Operasi Pop (Mengambil/Menghapus) Operasi ini adalah operasi untuk mengambil data dalam stack atau menghapus data, implementasinya : Procedure Pop (Var T:Stack); Begin If T.atas = 0 then Writeln (Tumpukan sudah kosong); Else T.Atas := T.Atas 1; End; 2. List Stack dapat disajikam dalam bentuk senarai berantai (linked list). Elemen pertama dalam linked list diperlakukan sebagai elemen teratas dari stack (TOP). Berikut ini deklarasi operasi stack menggunakan single linked list berkepala.

70

Deklarasi stack menggunakan list: Type stack = ^elemen; Elemen = record Info : char; Next : stack; End; Var atas : stack; Operasi stack menggunakan list : a. Operasi Push Karena kita menggunakan linked list berkepala maka terlebih dulu dilakukan inisialisasi tumpukan untuk menentukan simpul kepala. Jika linked list hanya berisi simpul kepala maka artinya stack masih kosong. Procedure inisialisasi_stack(var T : stack) Begin New (atas); Atas^.next := nil; End; Procedure Push(atas : stack; data : char); Var baru : stack; Begin New(baru); Baru^.info := data; Baru^.next := nil; If atas^.next <> nil then Baru^.next := atas^.next; Atas^.next := baru; Else Atas^.next := baru; End; b. Operasi Pop Dalam prosedur pop perlu dicek apakah stack masih isi atau kosong. Karena kita menggunakan list, maka stack kosong dinyatakan sebagai pointer pada simpul kepala yang bernilai nil.

71

Procedure Pop(atas : stack; var kosong:Boolean; data:char); Var bantu : stack; Begin Kosong := false; If atas^.next = nil then Kosong := true; Writeln (Stack kosong) Else Bantu := atas^.next; Data := bantu^.info; Atas^.next := bantu^.next; Dispose (bantu); End; 9.3 Contoh Pemakaian Stack Untuk lebih memahami operasi yang terjadi pada stack berikut disajikan contoh program yang memanfaatkan stack. 1. Contoh penggunaan stack untuk membalik kalimat program balik_kalimat; uses wincrt; const max = 255; type stack = record isi : string[255]; atas : 0..max; end; var T : stack; i : integer; kalimat : string[255]; procedure awalan(var T : stack); begin T.Atas := 0; end; procedure push(var T : stack; x : char); begin T.Atas := T.Atas+1; T.Isi[T.Atas] := x; end; function pop(var T:stack):char; begin pop := T.Isi[T.Atas]; T.Atas := T.Atas-1; end;

72

begin awalan(T); writeln ('tumpukan untuk membalik kalimat'); writeln ('-------------------------------'); write ('Isikan sembaarang kalimat :'); readln(kalimat); writeln ('Kalimat asli : ',kalimat); for i:=1 to length(kalimat) do begin push(T, kalimat[i]); end; for i:=1 to length(kalimat) do begin write(pop(T)); end; end.

2. Contoh penulisan ungkapan numeris Salah satu pemanfaatan stack adalah untuk menulis ungkapan menggunakan notasi tertentu. Seperti kita ketahui dalam penulisan ungkapan numeris kita selalu menggunakan tanda kurung untuk mengelompokkan bagian mana yang harus dikerjakan lebih dulu.

Sebagai contoh : (A + B) * (C - D) Suku (A + B) akan dikerjakan lebih dulu kemudian suku (C - D) dan terakhir mengalikan hasil dari dua suku ini. Cara penulisan ungkapan seperti ini disebut dengan notasI INFIX, artinya operator di tulis diantara dua operand.

Selanjutnya terjadi pengembangan cara penulisan ungkapan numeris yang disebut dengan notasi PREFIX dan POSTFIX. PREFIX artinya operator ditulis sebelum kedua operand yang akan disajikan dan POSTFIX artinya kebalikan dari prefix dalam hal ini operator ditulis sesudah operand.

Contoh konversi notasi infix menjadi prefix : Infix A+B A+BC (A + B) * (C - D) A B / (C * D $ E) Prefix +AB - +ABC *+ A B C D - A/B*C$DE

73

Langkah konversi infix menjadi prefix : Misal ungkapan yang akan dikonversi adalah : (A + B) * (C - D) 1. Dengan menggunakan tanda kurung bantuan, operator ungkapan diatas ditulis sebelum operand. [+AB]*[-CD] P Q

2. Hasil ungkapan sementara kita kelompokan menjadi P dan Q maka ungkapan di atas ditulis sebagai berikut : P*Q 3. Selanjutnya notasi infix diatas kita ubah menjadi notasi prefix dengan menempatkan operator sebelum operand. *P Q 4. Kembalikan P dan Q pada notasi semula dengan menghapus tanda kurung bantuan, maka diperoleh notasi prefix sebagai berikut : *+ A B C D Contoh konversi notasi infix menjadi postfix : Infix A+B A+BC (A + B) * (C - D) A B / (C * D $ E) Postfix AB+ AB+CAB+CD-* ABCDE$*/-

Langkah konversi infix menjadi postfix : Misal ungkapan yang akan dikonversi adalah : (A + B) * (C - D) 1. Dengan menggunakan tanda kurung bantuan, operator ungkapan diatas ditulis sesudah operand. [AB+]*[CD-] P Q

2. Hasil ungkapan sementara kita kelompokan menjadi P dan Q maka ungkapan di atas ditulis sebagai berikut : P*Q 74

3. Selanjutnya notasi infix diatas kita ubah menjadi notasi postfix dengan menempatkan operator sesudah operand. PQ* 4. Kembalikan P dan Q pada notasi semula dengan menghapus tanda kurung bantuan, maka diperoleh notasi prefix sebagai berikut : AB+CD-* Table tingkat kekuatan symbol konversi infix menjadi postfix Tingkat kekuatan 4 3 2 1 0 Nama Variable,konstanta Pangkat Kali, bagi Tambah, kurang Kurung buka A, B, ... , Z , 0, 9 ^, $ *, / +, ( Simbol

program infix_postfix; uses wincrt; type stack = record rinci : string[255]; atas : 0..255; end; var infix : string[255]; lagi : char; function valensi (tanda : char):integer; begin case tanda of '^',$ : valensi := 3; '*','/' : valensi := 2; '+','-' : valensi := 1; '(' : valensi := 0; end; end; procedure push (var t : stack; elemen : char); begin T.Atas := T.Atas + 1; T.Rinci[T.Atas] := elemen; end; function pop (var t : stack): char; begin pop := T.Rinci[T.Atas]; T.Atas := T.Atas - 1; end; 75

procedure konversi_cetak(infix : string); var i : integer; operator : set of char; temp, kar : char; t : stack; test : boolean; begin operator := ['$']+['*']+['/']+['+']+['-']; for i:=1 to length(infix) do begin kar := infix[i]; if kar = '(' then begin push(T, kar); end else if kar = ')' then begin while T.Rinci[T.Atas] <> '(' do write (pop(T):2); temp := pop(T); end else if kar in operator then begin while (T.Atas <> 0) and (valensi(kar) <= valensi(T.Rinci[T.Atas])) do write (pop(T):2); push(T, kar); end else if kar <> ' ' then write (kar:2); end; if T.Atas <> 0 then repeat write (pop(T):2); until T.Atas = 0; end; begin writeln ('MENGUBAH NOTASI INFIX MENJADI POSTFIX'); writeln ('-------------------------------------'); repeat write ('Masukan ungkapan infix :'); readln (infix); write ('Ungkapan postfix :'); konversi_cetak(infix); writeln; write ('akan mencoba lagi : Y(a) / T(idak) :'); readln (lagi); until not (lagi in ['Y', 'y']); end.

76

9.4 Latihan Praktikum 1. Konversi notasi infix di bawah ini ke dalam notasi prefix dan postfix a. (A + B) * (C / D) b. A B / (C * D $ E) c. (A - B) * ((C + D) / E $ F) 2. Buatlah program menggunakan stack dengan inputan sebuah kata, untuk memeriksa apakah kata tersebut palindrom (kata yang dibaca dari kanan atau kiri pembacaannya sama, contoh : ada, malam, katak)

77

BAB X ANTRIAN (QUEUE) 9.5 Pengertian Antrian Antrian adalah suatu kumpulan data yang mana penambahan elemen hanya bisa dilakukan pada suatu ujung (disebut dengan sisi belakang/rear) dan penghapusan / pengambilan elemen melalui ujung lain (disebut dengan sisi depan/front).

Pada antrian prinsip yang digunakan adalah masuk pertama keluar pertama (First In First Out FIFO) dengan kata lain urutan keluar elemen akan sama dengan urutan masuknya.

Contoh : Penjualan karcis kereta, bioskop Penjadualan pencetakan (spooling system) Simulasi Parkir

9.6 Implementasi Penambahan dan Penghapusan Elemen Antrian dengan pergeseran Kondisi Antrian :

Operasi Dasar Pada Antrian : Operasi Tambah Operasi Ambil

78

a. Operasi Tambah Elemen Ilustrasi Tambah Elemen : 1. Operasi tambah elemen pada posisi awal dimana belum ada elemen yang ditambahkan

2. Operasi tambah elemen pertama

3. Operasi tambah elemen ke-2

4. Operasi tambah elemen ke-3

5. Operasi tambah elemen ke-4

79

b. Operasi Ambil Elemen Ilustrasi Ambil Elemen : 1. Operasi Ambil elemen pertama

2. Operasi ambil elemen ke-2

3. Operasi ambil elemen ke-3

4. Operasi ambil elemen ke-4

80

Contoh Program : program antrianGeser; uses wincrt; const max = 5; type antri = array[1..max] of char; var antrian : antri; belakang : integer; x : char; i, pilih : integer; {* Prosedur u/ menambah elemen kedalam antrian*} procedure tambah (var antrian:antri; x : char); begin if belakang = 0 then begin for i:=1 to max do begin write('Data Antrian Ke-',i,':'); readln(x); belakang := belakang + 1; antrian[belakang] := x; end; end else begin for i:=1 to (max-belakang) do begin write('Data Antrian Ke-',i,':'); readln(x); belakang := belakang + 1; antrian[belakang] := x; end; end; writeln; end; {* Fungsi u/menghapus elemen dalam antrian *} function hapus (var antrian:antri):char; begin x := antrian[1]; for i:=1 to belakang do begin antrian[i] := antrian[i+1]; end; belakang := belakang-1; writeln('Antrian yang keluar : ',x); writeln; end; {* prosedur u/mencetak antrian*} procedure cetak(var antrian:antri); begin for i:=1 to belakang do begin 81

writeln('--antrian ke-',i,':', antrian[i]); writeln; end; end; {*** PROGRAM UTAMA ***} begin repeat writeln (' MENU'); writeln ('1. Tambah Antrian'); writeln ('2. Hapus Antrian'); writeln ('3. Cetak Antrian'); writeln ('4. Selesai'); write ('Pilih menu :'); readln(pilih); writeln; case pilih of 1 : tambah(antrian,x); 2 : writeln(hapus(antrian)); 3 : cetak(antrian); 4 : exit; end; until pilih = 4; end.

9.7 Implementasi Penambahan dan Penghapusan Elemen Antrian Sirkuler (Tanpa Pergeseran) Kondisi Antrian :

82

a. Operasi Tambah Elemen Ilustrasi Tambah Elemen : 1. Operasi tambah elemen pada posisi awal dimana belum ada elemen yang ditambahkan

2. Operasi tambah elemen pertama

3. Operasi tambah elemen ke-2

4. Operasi tambah elemen ke-3

5. Operasi tambah elemen ke-4

83

b. Operasi Ambil Elemen dan Tambah Elemen Baru Ilustrasi Ambil Elemen : 1. Operasi Ambil elemen pertama

2. Operasi ambil elemen ke-2

3. Operasi ambil elemen ke-3

4. Operasi tambah elemen ke-5

5. perasi tambah elemen ke-6

84

6. Operasi tambah elemen ke-7

7. Antrian overflow

Contoh program : program antrian_sirkuler; uses wincrt; const max = 5; type antri = array[1..max] of char; var antrian : antri; depan, belakang, pilih : integer; elemen : char; {*Prosedur untuk menggambar kotak antrian*} procedure kotak; var i : integer; begin gotoxy(20,15); for i:=1 to max*4+1 do write('-'); gotoxy(20,16); for i:=1 to max do write('| '); writeln('|'); gotoxy(20,17);

for i:=1 to max*4+1 do write('-'); gotoxy(8,16); write('<-- keluar'); gotoxy(22+max*4+1,16); writeln('<-- masuk'); end;

85

{* Prosedur u/ meletakkan elemen dalam kotak antrian*} procedure letakkan(x:char; r:integer); begin gotoxy(18+4*r,16); write(x); end; {* Fungsi u/ mencek keadaan antrian *} function kosong(q:antri):boolean; begin kosong:=(depan=belakang); end; {* Prosedur u/ menambah elemen baru *} procedure tambah(var antrian:antri; x :char); begin if belakang=max then begin belakang:=1; end else begin belakang:=belakang+1; end; if not(kosong(antrian)) then begin antrian[belakang]:=x; letakkan(x,belakang); end else begin gotoxy(40,9); write('ANTRIAN SUDAH PENUH'); repeat until keypressed; gotoxy(40,9); write(' ':30); belakang:=belakang-1; if belakang = 0 then belakang:=max end end; {* Fungsi u/ menghapus elemen dari antrian*} function hapus(var antrian:antri):char; begin if depan = max then begin depan := 1; end else begin 86

depan:=depan+1; hapus:=antrian[depan]; end; end; {*** PROGRAM UTAMA ***} begin kotak; depan:=0; belakang:=0; repeat for pilih := 5 to 9 do begin gotoxy(40,pilih);write(' ':39); end; gotoxy(1,1); writeln('Daftar Menu Pilihan'); writeln('-------------------'); writeln('1. Menambah Elemen Baru'); writeln('2. Menghapus Elemen'); writeln('3. Selesai'); writeln; writeln('Pilih :'); repeat gotoxy(22,9); writeln(' '); gotoxy(22,9); readln(pilih); until (pilih>=1) and (pilih<=3); case pilih of 1 : begin gotoxy(40,5); writeln('Menambah Elemen'); gotoxy(40,6); writeln('---------------'); gotoxy(40,8); write('Isikan Elemennya : '); readln(elemen); tambah(antrian,elemen); end; 2 : begin if not (kosong(antrian)) then begin elemen := hapus(antrian); letakkan(' ',depan); end else begin gotoxy(30,9); writeln('ANtrian Kosong'); elemen := readkey; gotoxy(30,9); write(' ':30); end end; end; until pilih = 3; end. 87

BAB XI POHON (TREE) 9.8 Pengertian Struktur Pohon digunakan untuk menggambarkan hubungan yang sifatnya hirarkis antara elemenelemen yang ada. Secara sederhana pohon bisa didefinisikan sebagai kumpulan elemen yang salah satu elemennya disebut dengan root, node, subtree. Node atau simpul dalam struktur pohon adalah elemen pohon yang berisi informasi/data dan penunjuk percabangan.

Contoh struktur pohon dalam kehidupan sehari-hari : 1. Silsilah keluarga 2. Struktur Organisasi

Contoh sebuah pohon beserta tingkatnya :

ROOT
NODE/ SIMPUL/ SUBTREE NODE/ SIMPUL/ SUBTREE NODE/ SIMPUL/ SUBTREE 9.9 Istilah-Istilah Dasar Istilah- istilah dasar dalam sruktur pohon adalah sbb : a. Tingkat (level) dan kedalaman (depth) pohon

Tingkat (level) suatu simpul ditentukan dengan pertama kali menentukan akar sebagai bertingkat 1. Jika suatu simpul dinyatakan sebagai tingkat N, maka simpul-simpul yang merupakan anaknya dikatakan berada dalam tingkat (N+1). Kedalaman (depth) dari suatu pohon adalah tingkat maksimum dari simpul dalam pohon tersebut dikurangi dengan 1.

88

Maka pada gambar diatas tingkat (level) dari struktur pohon tersebut adalah 4 dengan kedalaman 3.

b. Derajat simpul Derajat suatu simpul dinyatakan sebagai banyaknya anak atau turunan dari simpul tersebut. Untuk setiap simpul yang berderajat 0 disebut dengan daun (leaf).

DERAJAT 2 DERAJAT 2 DERAJAT 0/ DAUN(LEAF)

DERAJAT 3

c. Node internal dan eksternal Node internal adalah node yang memiliki anak dan node eksternal adalah node yang tidak memiliki anak (daun)

89

Node Internal

Node internal

Node Eksternal

d. Notasi pohon Terdapat beberapa cara penulisan / penggambaran pohon yaitu sbb : 1. Diagram pohon

2. Diagram venn

3. Notasi kurung (A(B(D,E(I,J)),C(F,G,H))) atau (A (B(D)(E(I)(J))) (C(F)(G)(H)))

90

4. Notasi tingkat

5. Notasi Garis

9.10 Pohon Biner Pohon biner (binary tree) bisa didefinisikan sebagai suatu kumpulan simpul yang mungkin kosong atau mempunyai akar dan dua subpohon yang saling terpisah yang disebut dengan subpohon kiri (left subtree) dan subpohon kanan (right subtree) atau dengan kata lain struktur pohon yang haynay memiliki maksimal 2 anak. Contoh pohon biner :

91

Jumlah maksimum node pada setiap tingkat adalah 2 pangkat n

9.11 Penelusuran Pohon Biner Penelusuran (traversal) pohon biner adalah proses mendatangi setiap simpul dari pohon secara sistematik masing-masing satu kali. Operasi ini biasanya digunakan untuk mencetak informasi yang ada pada simpul. Terdapat 4 macam cara penelusuran pohon biner yaitu sbb : 1. Preorder Kunjungan ini menggunakan urutan sbb : Cetak isi simpul yang dikunjungi Kunjungi cabang kiri Kunjungi cabang kanan

Diberi inisial (SLR = Simpul Left Right) 2. Inorder Kunjungan ini menggunakan urutan sbb : Kunjungi cabang kiri Cetak isi simpul yang dikunjungi Kunjungi cabang kanan

Diberi inisial (LSR = Left Simpul Right) 3. Postorder Kunjungan ini menggunakan urutan sbb : Kunjungi cabang kiri Kunjungi cabang kanan Cetak isi simpul yang dikunjungi

Diberi inisial (LRS = Left Right Simpul)

92

4. Leverorder Kunjungan simpul dimulai dari simpul bertingkat 1 hingga simpul-simpul bertingkat n, yaitu yang dimulai dari akar pohon sampai semua simpul di tingkat yang paling tinggi. Contoh :

Preorder Inorder Postorder Levelorder

:A :D :D :A

B B E B

D E B C

E A K D

C F I K J K I F J C I J F C A E F I J K

9.12 Penyajian Pohon Biner Jika kita memperhatikan setiap simpul dalampohon biner, kita bisa menyusun struktur data tersebut dalam setiap simpul dengan 2 buah pointer untuk menunjuk cabang kiri dan kanan dan informasi yang disimpan dalam simpul tersebut. Simpul pada pohon biner :

KIRI

INFO

KANAN

Deklarasi pohon biner : Type tree = ^simpul;

Simpul = record Info : char; Kiri, kanan : tree; End;

93

Penyajian pohon biner dengan senarai berantai :

Pembentukan pohon Biner dari Hasil Traversal dan Derajat Simpul Suatu pohon biner dapat dibentuk dari hasil traversal dan derajat simpulnya dengan aturan sebagai berikut : 1. Pembacaan hasil traversal dimulai sesuai dengan kaidah penelusurannya: preorder dari paling kanan maju ke kiri, cari yang derajatnya tidak bernilai nol, kemudian ambil node sebanyak derajatnya. Inorder dari kanan dan kiri, cari derajatnya tidak bernilai nol, kemudian ambil node sebanyak derajatnya. Postorder dari kiri, cari derajatnya tidak bernilai nol, kemudian ambil node sebanyak derajatnya. 2. Lanjutkan dengan mengulangi langkah 1

Contoh 1 : Preorder Derajat Langkah 1 : Derajat yang bukan nol (dimulai dari kanan) yang pertama adalah V, karena V berderajat 2, maka ambil node sebanyak dua yaitu W dan X root :U V W X Y :2 2 0 0 0

94

Langkah 2 : Lanjutkan pencarian derajat bukan nol, maka ditemukan U berderajat 2 karena tidak ada lagi derajat bukan nol maka U sudah pasti adalah root dari struktur pohon yg akan dibentuk, ingat kembali prosedur kunjungan preorder adalah SLR (Simpul Left Right) berarti simpul yg pertama pada langkah 1 yang telah terbentuk akan menjadi simpul bagian kiri (left) dari root U dan simpul kanan (right) sudah pasti adalah Y berderajat 0.

Contoh 2 : Inorder : B A C H G F I Derajat Langkah 1 : Cari derajat bukan nol dari kanan dan kiri, maka diperolah F untuk kanan dan A untuk kiri, lalu ambil node 0 sebanyak derajatnya diantara F dan A Root Kiri Kanan :0 2 0 2 0 2 0

B A C H G F I 0 2 0 2 0 2 0

SIMPUL KIRI A B C

SIMPUL KANAN F G I

Langkah 2 : Setelah simpul kiri dan kanan terbentuk maka akan tersisa satu simpul di tengah antara simpul yang telah terbentuk, dan simpul tersisa itu adalah H sebagai root dengan derajat 2, lalu ambil node sebanyak derajatnya yaitu A dan F.

95

A B C G

F I

Contoh 3 : Postorder Derajat Langkah 1 : Cari derajat bukan nol dari arah kiri, maka akan ditemukan C dengan derajat 2 dan A berderajat 1, ambil node 0 untuk C sebanyak derajatnya yaitu B dan D lalu ambil node sebanyak derajatnya untuk A yaitu C. :B D C A J L K H :0 0 2 1 0 0 2 2

B D C A J L K H 0 0 2 1 0 0 2 2 A C B Langkah 2 : Lanjutkan pencarian maka akan ditemukan K dengan derajat 2 dan H dengan derajat 2, ambil node 0 untuk K sebanyak derajatnya yaitu L dan K dan ambil node sebanyak derajatnya untuk H (root) yaitu K dan A. Root B D C A J L K H 0 0 2 1 0 0 2 2 D

96

A C B D J

K L

Contoh Program program pohonbiner; uses wincrt; Type Tree = ^Simpul; Simpul = Record Info : integer; Kiri : Tree; Kanan : Tree; End; var pohon : tree; i,n : integer; huruf : integer;

Function BARU(Hrf : integer) : Tree; Var Temp : Tree; Begin New(Temp); Temp^.Info := Hrf; Temp^.Kiri := NIL; Temp^.Kanan := NIL; BARU := Temp; End; Procedure MASUK(Var Pohon : Tree; Hrf : integer); Begin If Pohon = NIL Then {Jika pohon masih kosong} begin Pohon := BARU(Hrf) end Else If Pohon^.Info > Hrf then {Jika Hrf lebih kecil, cabang kiri} begin writeln('--info :',pohon^.info); MASUK(Pohon^.Kiri,Hrf); writeln('--kiri :',pohon^.info); end Else If Pohon^.Info < Hrf then {Jika Hrf lebih besar, cabang kanan} 97

begin writeln('--info :',pohon^.info); MASUK(Pohon^.Kanan,Hrf); writeln('--kanan :',pohon^.info); end Else begin Writeln('Karakter', Hrf, 'Sudah ada di Tree'); End; End; Procedure PREORDER(var Temp : Tree); Begin If Temp <> NIL Then Begin Writeln(Temp^.Info,' '); {Cetak isi simpul} PREORDER(Temp^.Kiri); {Kunjungi cabang kiri} PREORDER(Temp^.Kanan); {Kunjungi cabang kanan} End; End; Procedure INORDER(var Temp : Tree); Begin If Temp <> NIL Then Begin INORDER(Temp^.Kiri); {Kunjungi cabang kiri} Writeln(Temp^.Info,' '); {Cetak isi simpul} INORDER(Temp^.Kanan); {Kunjungi cabang kanan} End; End; Procedure POSTORDER(var Temp : Tree); Begin If Temp <> NIL Then Begin POSTORDER(Temp^.Kiri); {Kunjungi cabang kiri} POSTORDER(Temp^.Kanan); {Kunjungi cabang kanan} Writeln(Temp^.Info,' '); {Cetak isi simpul} End; End;

{PROGRAM UTAMA} begin writeln ('Program Pohon Biner'); write('Berapa data yg akan diinput :'); readln(n); for i:=1 to n do begin write('Masukan angka :'); readln(huruf); masuk(pohon,huruf); end; 98

writeln('Hasil Preorder :'); preorder(pohon); writeln('Hasil Inorder :'); inorder(pohon); writeln('Hasil Postorder :'); postorder(pohon); end. 9.13 Latihan 1. Buat diagram pohon di bawah ini kedalam diagram venn, notasi kurung, notasi tingkat dan notasi garis, serta tentukan level, depth, dan derajat yang terbentuk pada diagram pohon tersebut.

2. Buatlah struktur pohon bila diketahui kunjungan dari pohon beserta dengan derajatnya sebagai berikut : a. Preorder :H A C B D K J L

Derajat : 2 1 2 0 0 2 0 0 b. Postorder :B C A G I F H

Derajat : 0 0 2 0 0 2 2 c. Inorder : W V X U Z Y Derajat : 0 2 0 2 0 1

99

BAB XII GRAPH 9.1 Pengertian Graph secara umum didefinisikan sebagai kumpulan simpul/titik (nodes atau vertices) yang dihubungkan satu sama lain melalui sisi/busur/garis (arcs atau edges). Graph hampir sama seperti pohon namun tidak bersifat hirarkis. Perbedaan graph dengan pohon : Graf mungkin terjadi siklus (cycle) Graf dapat terdiri dari lebih dari satu sambungan

Graf terdiri dari dua himpunan : Verteks(simpul) : V = himpunan simpul yang terbatas dan tidak kosong Edge(sisi/busur) : E = himpunan busur yang menghubungkan sepasang simpul

Contoh graph :

Kondisi graph : Sebuah graph mungkin hanya terdiri dari satu simpul

Sebuah graph belum tentu semua simpulnya terhubung dengan busur

Sebuah graph mungkin mempunyai simpul yang tak terhubung dengan simpul yang lain

Sebuah graph mungkin semua simpulnya saling berhubungan

100

Jenis Graph :

Graph tak berarah (undirected graph atau non-directed graph) : Urutan simpul dalam sebuah busur tidak dipentingkan. Mis busur e1 dapat disebut busur AB atau BA Graph berarah (directed graph) : Urutan simpul mempunyai arti. Mis busur AB adalah e1 sedangkan busur BA adalah e8.

Graph Berbobot (Weighted Graph) Jika setiap busur mempunyai nilai yang menyatakan hubungan antara 2 buah simpul, maka busur tersebut dinyatakan memiliki bobot. Bobot sebuah busur dapat menyatakan panjang sebuah jalan dari 2 buah titik, jumlah ratarata kendaraan perhari yang melalui sebuah jalan, dll. 101

9.2 Representasi Graph dalam bentuk matrik a. Matrix Tetangga (Adjacency Matrix)

b. Matrix Beban

c. Matrix Jalur Terpendek Pandang D suatu graf berarah yang hingga dengan tiap-tiap arc mempunyai bobot. Jadi D merupakan suatu network. Kita hendak menentukan Jalur Terpendek antara 2 simpul u dan v. Gambar berikut merupakan suatu network. Kita ingin menghitung jalur terpendek dari simpul u ke simpul v. 102

Untuk dapat menentukan jalur terpendeknya, kita gunakan cara berikut : Buat table jarak, dengan tiap kolom mewakili simpul yang ada, dan kita isikan data jarak dari satu simpul ke simpul lainnya sesuai dengan kolom yang ada. Usahakan diurut dari yang kecil ke besar. U UZ = 2 UX = 4 UY = 6 Kita mulai dengan simpul u sebagai simpul awal. Beri harga = 0. Ambil simpul dengan jarak terdekat dari u, dalam hal ini z (uz =2), kemudian tandai uz. Beri harga = 2 pada kolom z. Kemudian pada judul kolom yang telah diberi harga, kita tandai *. Hasil langkah tersebut dapat dilihat pada tabel berikut ini : U*(0) UZ = 2 UX = 4 UY = 6 Setelah memberi tanda nilai pada kolom U dan Z, maka selanjutnya ambil simpul dengan jarak terdekat dari Z, dalam hal ini Y (ZY=2), kemudian tandai ZY. Beri harga = 4 (penjumlahan antara harga pada kolom Z dan nilai jarak ZY) pada kolom Y dan beri tanda *. Hasil langkah tersebut dapat dilihat pada tabel berikut ini : U*(0) UZ = 2 UX = 4 UY = 6 Lakukan hal yang sama seperti diatas, ambil simpul dengan jarak terdekat dari Y, dalam hal ini C (YC=1), kemudian tandai YC. Beri harga=5 pada kolom C dan beri tanda *. Hasil langkah dapat dilihat pada table berikut ini : X XY = 3 XA =4 Y*(4) YC = 1 YB = 2 Z*(2) ZY = 2 ZC = 5 A AB = 2 AV = 3 B BV = 3 C CV = 3 V X XY = 3 XA =4 Y YC = 1 YB = 2 Z*(2) ZY = 2 ZC = 5 A AB = 2 AV = 3 B BV = 3 C CV = 3 V X XY = 3 XA =4 Y YC = 1 YB = 2 Z ZY = 2 ZC = 5 A AB = 2 AV = 3 B BV = 3 C CV = 3 V

103

U*(0) UZ = 2 UX = 4 UY = 6

X XY = 3 XA =4

Y*(4) YC = 1 YB = 2

Z*(2) ZY = 2 ZC = 5

A AB = 2 AV = 3

B BV = 3

C*(5) CV = 3

Selanjutnya pada kolom C hanya tersisa satu simpul dengan jarak terdekat dari C menuju ke V, dalam hal ini CV=3 kemudian tandai CV, beri harga = 8 pada kolom Z dan beri tanda *. Hasil langkah dapat dilihat pada table berikut ini : U*(0) UZ = 2 UX = 4 UY = 6 X XY = 3 XA =4 Y*(4) YC = 1 YB = 2 Z*(2) ZY = 2 ZC = 5 A AB = 2 AV = 3 B BV = 3 C*(5) CV = 3 V*(8)

Dari tabel terakhir, data yang kita gunakan adalah data yang ditandai kotak. Terlihat dari judul kolom masing-masing simpul, harga yang merupakan jarak terpendek dari simpul awal (dalam hal ini simpul U) ke simpul V adalah 8. Jalur terpendek dari u ke v dapat ditentukan dengan cara mundur, yakni dari data yang ada yang berakhir dengan v adalah cv, kemudian yang berakhir dengan c adalah yc, yang berakhir dengan y adalah zy dan yang berakhir dengan z adalah u. Sehingga jalur yang dimaksud adalah : u z y c v Penggambaran dari solusi tersebut adalah sebagai berikut :

104

Contoh Program : Sebelum program dibuat terlebih dahulu membuat berkas teks yang berisi data sbb :

Simpan berkas bernama teks tersebut diatas dalam bentuk .txt dan simpan dalam drive c: pada computer masing-masing. program graph; uses wincrt; const max = 25; garis = '-----'; takTerhingga = 5000; type larik = array[1..max,1..max]of word; var MatTetangga, MatJalur, MatBeban, MatBebanMin : larik; ukuran : byte; T : text; procedure InitMatrix(var M : larik); var i,j : byte; begin for i:=1 to max do for j:=1 to max do M[i,j] := 0; end; procedure CetakMatrix(M : larik; N : byte); var i,j : byte; begin write (' ':7); for i:=1 to N do write(I:5); writeln(''); 105

write(' ':5); for i:=1 to N+1 do write(garis); writeln(''); for i:=1 to N do begin write(i:5,' |'); for j:=1 to N do write(M[i,j]:5); writeln(''); end; end; procedure MatrixTetangga(var MT,MB : larik; var ukuran : byte); var i,j : byte; T1,T2,B : word; begin reset(T); readln(T,ukuran); while not eof(T)do begin readln(T,T1,T2,B); MT[T1,T2] := 1; MB[T1,T2] := B; end; end; function Opor(P1,P2:byte):byte; begin if (P1=0) and (P2=0) then Opor:=0 else Opor:=1; end; function Opand(P1,P2:byte):byte; begin if (P1=1) and (P2=1) then Opand:=1 else Opand:=0; end;

function minimum(P1,P2:word):word; begin if P1<P2 then minimum:=P1 else minimum:=P2; end; procedure MatrixBebanMinimal(var MBM:larik; MB:larik; N:byte); var i,j,k:byte; begin for i:=1 to N do 106

for j:=1 to N do if MB[i,j]=0 then MBM[i,j]:=TakTerhingga else MBM[i,j]:=MB[i,j]; for k:=1 to N do begin for i:=1 to N do for j:=1 to N do MBM[i,j]:=minimum(MBM[i,j],MBM[i,k]+MBM[k,j]); end; end; procedure Normal(var MBM:larik; N:byte); var i,j : byte; begin for i:=1 to N do for j:=1 to N do if MBM[i,j] = TakTerhingga then MBM[i,j]:=0; end; begin assign(T,'c:teks.txt'); reset(T); InitMatrix(MatTetangga); InitMatrix(MatBeban); MatrixTetangga(MatTetangga,MatBeban,ukuran); MatrixBebanMinimal(MatBebanMin,MatBeban,ukuran); normal(MatBebanMin,ukuran); writeln('Matrix Tetangga :'); CetakMatrix(MatTetangga,ukuran); writeln; writeln('Matrix Beban :'); CetakMatrix(MatBeban,ukuran); writeln; writeln('Matrix Beban terkecil/jarak terpendek'); CetakMatrix(MatBebanMin,ukuran); end.

9.3 Latihan 1. Buatlah matriks ketetanggaan untuk graph di bawah ini a. 1 4

2 3

107

b.

2. Tentukan jarak terpendek dari simpul A menuju simpul D dari graph dibawah ini, serta tuliskan juga jalur simpulnya beserta langkah-langkahnya.

108