P. 1
Struktur Organisasi Data

Struktur Organisasi Data

|Views: 649|Likes:
Published by Alicia Greer

More info:

Published by: Alicia Greer on Apr 27, 2011
Copyright:Attribution Non-commercial

Availability:

Read on Scribd mobile: iPhone, iPad and Android.
download as PDF, TXT or read online from Scribd
See more
See less

05/24/2013

pdf

text

original

BAB 1 TIPE DATA Struktur data adalah suatu koleksi atau kelompok data yang dapat dikarakterisasikan oleh

organisasi serta operasi yang didefinisikan terhadapnya. Data secara umum dapat dikategorikan :

Tipe data sederhana atau data sederhana : : Integer, Real, Boolean, Karakter String

1. Tunggal 2. Majemuk

Struktur Data

1. Sederhana : Array dan Record 2. Majemuk terdiri atas • Linier : Linier Linked List, Stack, Queue

Non Linier :

Binary Tree, Binary Search Tree, General Tree, G

Tree,

§ INTEGER Anggota dari himpunan bilangan : {..., -(n+1), -n, ..., -2, -1, 0, 1, 2, ..., n, n+1, ...} Operasi dasar yaitu : penjumlahan, pengurangan, perkalian, pembagian dan perpangkatan Pembagian Integer (DIV) Hasil pembagian integer DIV adalah sebuah integer (menghilangkan bagian pecahan dari hasil pembagian) Contoh : 27 DIV 4 = 6 Selain itu terdapat operasi MOD (Modulo) adalah sisa dari pembagian Contoh : 27 MOD 4 = 3 Operator yang bekerja terhadap sepasang integer (operand) disebut Binary Operator. Sedangkan operator yang hanya bekerja terhadap satu operand saja disebut Unary Operator. Contoh dari unary operator adalah negasi. § REAL Data numerik yang bukan termasuk integer, digolongkan dalam jenis data real. Ditulis menggunakan titik desimal (atau koma desimal). Dimasukkan ke dalam memori komputer memakai sistem floating point, disebut Scientific Notation. Penyajiannya terdiri dari : mantissa (pecahan) dan eksponen.

Contoh : Di dalam sistem desimal, 123000 = 0.123 * 106 di sini 0.123 adalah mantissa atau pecahan, sedangkan 6 adalah eksponennya. Secara umum suatu bilangan real X dituliskan M * RE di sini : M dijadikan pecahan, R adalah radixnya dan E merupakan eksponennya. § BOOLEAN Disebut juga jenis data logical. Anggota { true atau false}. 1. Operator Logika, yaitu : AND, OR, NOT
• • •

Operator AND akan menghasilkan nilai true, jika kedua operand bernilai true. Operator OR akan menghasilkan nilai true, jika salah satu operand bernilai true Operator NOT merupakan “precedence” dari operator AND dan OR.

Dalam suatu ekspresi yang tidak menggunakan tanda kurung, operator NOT harus dievaluasi sebelum operator AND dan OR. B. Operator Relasional, yaitu : >, <, >=, <=, <> dan = Contoh : 6 < 8 = True 9 < 8 = False § KARAKTER Elemen dari suatu himpunan yang terdiri atas bilangan, abjad dan simbol khusus. (0,1,...,8,9, A, B, ..., Y,Z, +, -,*,Ö, ...} § STRING Barisan hingga karakter yang dibentuk oleh suatu kumpulan dari karakter. Karakter yang digunakan untuk membentuk suatu string disebut alfabet. Dalam penulisannya, suatu string berada dalam tanda “aphosthrope”. Contoh : Misal diberikan himpunan alfabet A = {C,D,1}. String yang dapat dibentuk dari alfabet di atas di antaranya : ‘CD1’,’CDD’,’DDC’,’CDC1’,... dan sebagainya, termasuk “null string” atau “empty string” Himpunan tak hingga dari string yang dibentuk oleh alfabet A disebut VOCABULARY, Notasi : VA atau A* Jika suatu string dibentuk dari alfabet {0,1}, maka string yang terbentuk disebut dengan “Bit String”. OPERASI Jumlah karakter dalam string Gabungan 2 buah string Sub bagian dari string Menyisipkan string ke dalam string yang lain Menghapus karakter dalam string Operator LENGTH CONCAT SUBSTR INSERT DELETE

LENGTH Nilai dari operasi ini adalah suatu integer yang menunjukkan panjang dari suatu string . Notasi : LENGTH(S) = N (integer) di sini S = String, N = integer Contoh :

Jika diberikan string S =‘a1a2 ... aN’

Maka LENGTH(S) = N

Jika diberikan string S =“SISTEMINFORMASI”

Maka LENGTH(S) = 15 • Jika diberikan string S =“SISTEM INFORMASI” Maka LENGTH(S) = 16 • Jika diberikan string S = “ABCD20” Maka LENGTH(S) = 6 CONCAT Operasi ini bekerja terhadap dua string dan hasilnya merupakan resultan dari kedua string tersebut. Jika S1 dan S2 masing-masing adalah suatu string, maka bentuk operasi CONCATENATION dinotasikan dengan : CONCAT(S1, S2). Contoh : Misal S1 = ‘a1a2 ... aN’ dan S2 =‘b1b2 ... bM’ Maka CONCAT(S1,S2) = ‘a1a2 ... aNb1b2 ... bM’ String S1 = "Sistem" String S2 = "Informasi" CONCAT(S1, S2)= "SistemInformasi" LENGTH(CONCAT(S1, S2)) = 15 LENGTH(S1) + LENGTH(S2) = LENGTH(CONCAT(S1, S2)) 6 + 9 = 15 15 = 15 SUBSTR Operasi ini adalah operasi membentuk string baru, yang merupakan bagian dari string yang diketahui. Notasi : SUBSTR(S, i, j) di sini : S = string yang diketahui i dan j = integer i = posisi awal substring 1 £ i £ LENGTH(S) j = banyak karakter yang diambil 0 £ j £ LENGTH(S) dan 0 £ i+j-1 £ LENGTH(S) Contoh : Diberikan S = ‘a1a2 ... aN’ ; i = 2 ; j= 4 Maka SUBSTR(S,i,j) = SUBSTR(S,2,4) =‘a2a3a4a5’

·

String S = "Sistem Informasi" SUBSTR(S,i, j) , i = 4 j = 8 SUBSTR(S,4,8) = "tem Info"

String S = "Sistem"

SUBSTR(S,1,3) = "Sis" LENGTH(SUBSTR(S,1,3)) = 3

String S = "Informasi"

SUBSTR(S,4,5) = "ormas" LENGTH(SUBSTR(S,4,5)) = 5 Catatan : 1. LENGTH(SUBSTR(S,i,j)) = j 2. SUBSTR(CONCAT(S1,S2),1,LENGTH(S1)) = S1 3. SUBSTR(CONCAT(S1,S2),LENGTH(S1)+1,LENGTH(S2)) = S2 INSERT Operasi ini adalah untuk menyisipkan suatu string ke dalam string lain. Bentuk umumnya adalah : INSERT(S1,S2,i). S1 dan S2 masing-masing adalah suatu string dan i adalah posisi awal S2 pada S1. Contoh : Misalkan : S1 = ‘a1a2 ... aN’ S2 = ‘b1b2 ... bM’ INSERT(S1, S2,3) = ‘a1a2b1b2 ... bMa3a4... aN’ String S1 = "Sistem" String S2 = "Informasi" INSERT(S1,S2,4) = “SisInformasitem” INSERT(S2,S1,4) = “InfSistemormasi” DELETE Operasi ini digunakan untuk menghapus sebagian karakter dalam suatu string. Bentuk umumnya adalah : DELETE(S,i,j) ® menghapuskan sebagian karakter dalam string S, mulai dari posisi i dengan panjang j.

Contoh : Diberikan string S = ‘a1a2 ... aN’ DELETE(S,3,4) = ‘a1 a2 a7a8 ... aN’ String S = "Sistem Informasi"

i = 4, j = 9 DELETE(S,i,j) = “Sismasi” DELETE(S,j,i) = “Sistem Imasi”

String S = “SistemInformasi”

DELETE(S, 4, 5) = “Sisformasi” DELETE(S, 5, 4) = “Sistformasi”

DEKLARASI DALAM BAHASA PEMROGRAMAN

§ PASCAL Var Count : integer; Switch : boolean; Betha : char; Alamat : packed array [1..25] of char;

§ COBOL DATA DIVISION 01 Count PICTURE S999. 01 Flda PICTURE X. 88 Switch VALUE ‘Y’. 01 Betha PICTURE X. 01 Alamat PICTURE X(25).

MAPPING KE STORAGE

§ INTEGER

Bentuk mapping ke storage dari integer dapat dilakukan dengan beberapa cara, yaitu : 1. Skema Sign and Magnitude 2. Skema One’s Complement 3. Skema Two’s Complement J SKEMA SIGN AND MAGNITUDE

Cara ini merupakan bentuk konvensional yang digunakan manusia untuk menyatakan suatu bilangan dalam bentuk biner. Di sini representasi bilangan positif dan negatif hanya dibedakan dengan tanda saja. Biasanya tanda positif atau negatif ditunjukkan oleh digit terdepan dari bentuk binernya, untuk representasi dengan jumlah digit tertentu. Contoh : +5 ê + 101 atau 5 ê 101 -5 ê - 101 Catatan : tanda (+) biasanya diabaikan J SKEMA TWO’S COMPLEMENT Jika x bilangan bulat non negatif maka x’ bilangan binary negatif dari x sedemikian sehingga x + x’ = R R = 2N N = jumlah digit maksimum x’ = R - x Contoh : Bila N = 4, maka R = 24 = 16 x = 5 ê 0101 x’ = R - x = 16 - 5 = 11 ê 1011 (-5) J SKEMA ONE’S COMPLEMENT Jika x bilangan bulat non negatif maka x’ bilangan binary negatif dari x sedemikian sehingga x + x’ = R R = 2N - 1 N = jumlah digit maksimum x’ = R – x

Contoh : Bila N = 4, maka R = 24 - 1= 15 x = 5 ê 0101 x’ = R - x = 15 - 5 = 10 ê 1010 (-5) Catatan Untuk R = 2N dan R = 2N - 1, bilangan bulat yang dapat disimpan dalam storage untuk ke-2 cara ini adalah :

2 (N-1) - 1 Untuk R = 24, bilangan bulat terbesar = 23 -1, maka r = 24 merepresentasikan bilangan dari -7 sampai dengan +7

SIGN & INTEGER -7 -6 -5 -4 -3 -2 -1 0 1 2 3 4 5 6 7 MAGNITUDE -111 -110 -101 -100 -011 -010 -001 000 001 010 011 100 101 110 111

TWO’S COMPLEMENT 1001 1010 1011 1100 1101 1110 1111 0000 0001 0010 0011 0100 0101 0110 0111

ONE’S COMPLEMENT 1000 1001 1010 1011 1100 1101 1110 0000 0001 0010 0011 0100 0101 0110 0111

§ KARAKTER

Ada banyak skema yang digunakan untuk merepresentasikan karakter dalam storage. Pada umumnya skema yang paling banyak digunakan adalah : 1. Extended Binary Coded Decimal Interchange (EBCDIC) Digunakan kode 8 bit untuk menyatakan sebuah karakter. Jika dihitung, kemungkinan kombinasi seluruhnya : 28 = 256. 2. American Standard Code for Information Interchange (ASCII) Digunakan kode 7 bit untuk menyatakan sebuah karakter. Jika dihitung, kemungkinan kombinasi seluruhnya : 27 = 128.

§ STRING

Untuk mengetahui bentuk mapping pada storage dari suatu string, perlu diketahui beberapa hal yang menyangkut ruang untuk string yang bersangkutan antara lain : - letak posisi awal (start) dan posisi akhir (terminal) - suatu pointer yang menunjukkan lokasi pada storage Ada tiga cara yang umum digunakan untuk mapping suatu string ke dalam storage. Misal diberikan dua string, yaitu : S1 = ‘ABCDEFG’ dan S2 = ‘BCD’ m CARA 1 Menggunakan tabel informasi : - nama string (NAME) - alamat awal (START) - panjang string (LENGTH) NAME START LENGTH

STRING1 STRING2

PTR1S PTR2S

7 3

Format penyimpanannya dapat berupa : ABCDEFGBCD atau

ABCDEFG

PTR2S PTR1S PTR2S PTR1S

m CARA 2 Menggunakan tabel informasi : - nama string (NAME) - alamat awal (START) - alamat akhir (TERM)

NAME STRING1 STRING2

START PTR1S PTR2S

TERM PTR1T PTR2T

Format penyimpanannya dapat berupa : ABCDEFGBCD atau PTR1T PTR2T

ABCDEFG PTR2T PTR2S PTR1S PTR1T

PTR1S PTR2S m CARA 3 Menggunakan tabel informasi : - nama string (NAME) - alamat awal (START) - suatu tanda yang menunjukkan batas string NAME STRING1 STRING2 Penyimpanannya : ABCDEFG#BCD# START PTR1S PTR2S

PTR1S

PTR2S

Cara lain yaitu : 1. Packed 2. Unpacked Suatu string yang direpresentasikan dalam bentuk packed terbagi atas beberapa word. Banyaknya karakter untuk masing-masing word tergantung dari kode yang digunakan oleh mesin (bit-nya). Secara umum jumlah word yang digunakan untuk merepresentasikan string S dalam storage dengan K karakter per word adalah :

LENGTH(S)

K Contoh : Misal diberikan string S =“ManajemenInformatika”, direpresentasikan dalam 4 karakter per word dalam bentuk packed. Maka secara fisik dapat digambarkan : Mana jeme nInf orma tika Jumlah word : 5 Jumlah karakter/word : 4 Sedangkan cara unpacked, setiap word terdiri hanya satu karakter, berarti jumlah word yang diperlukan untuk merepresentasikan suatu string S adalah : LENGTH(S) Contoh : Diberikan string S = “Gunadarma”. Representasinya dalam bentuk unpacked adalah : LENGTH(S) = 9 G u n a d a r m a

BAB 2 ARRAY Array adalah suatu himpunan hingga elemen, terurut dan homogen. ARRAY DIMENSI SATU Vektor adalah bentuk yang sederhana dari array, yang merupakan array dimensi satu. Array N dapat kita bayangkan :

N(1)

N(2)

N(3)

...

N(I)

Subskrip atau index dari suatu elemen menunjukkan posisi/urutan elemen dalam array. BENTUK UMUM Misal : Array N dengan tipe data T dan subskrip bergerak dari L sampai U, maka array N dapat ditulis : N(L:U) Banyaknya elemen adalah : U - L + 1

DEKLARASI ARRAY DALAM BAHASA PEMROGRAMAN

Misalkan : Hasil pencatatan temperatur suhu ruangan dalam 1 hari (24 jam) 1 2 3 24 28 30 29 ... 30 Disimpan dalam array TEMP sebagai berikut : TEMP (1:24) Deklarasi : PASCAL var TEMP : Array[1..24] of integer; BASIC DIM TEMP(24) COBOL 01 TABEL-TEMP 02 TEMP OCCURS 24 TIMES PIC 99. ARRAY DIMENSI DUA Adalah suatu array yang setiap elemennya merupakan tipe data array pula. Jika array B terdiri dari M elemen, yang setiap elemennya terdiri dari suatu array dengan N elemen, maka array B dapat digambarkan sebagai berikut : 1 L2 L1 1 2 2 3 ... N U2

. . .

U1 M

Memiliki 2 index (baris dan kolom). Dalam hal ini kita perlu memberi 2 harga subskrip untuk mengidentifikasikan masing-masing elemen pada array dimensi dua, yaitu :
• •

Subskrip pertama menunjukkan baris dari array, Sedangkan subskrip kedua menunjukkan kolom dari array.

BENTUK UMUM Misal : Array B dengan tipe data T, subskrip baris dari L1 sampai U1, subskrip kolom dari L2 sampai U2, ditulis sebagai berikut : B(L1:U1,L2:U2)

Banyaknya elemen adalah : (U1 - L1 +1) * (U2 - L2 +1) DEKLARASI ARRAY DALAM BAHASA PEMROGRAMAN Misal : Menyajikan nilai ujian dari 100 mahasiswa tingkat 2 sebanyak 8 mata kuliah. 1 L2 L1 1 A 2 C A 2 3 ... 100 U2

. . .

U1 8 B

Disimpan dalam array NILAI sebagai berikut : NILAI(1:8, 1:100) Deklarasi : PASCAL Var NILAI : array[1..8, 1..100] of char;

BASIC Dim NILAI(8,100)

COBOL 01. TABEL-NILAI 02. BRS OCCURS 8 TIMES 03. KOLOM OCCURS 100 TIMES PIC X.

PEMETAAN KE STORAGE : ARRAY DIMENSI SATU Alamat awal dari memori yang dialokasikan bagi array. Alamat awal dari array dinyatakan dengan B (Base Location), dan setiap elemen dari array menduduki S byte. Alamat awal dari array dengan elemen ke-I adalah :

B + (I -L) * S Contoh : A(2:6) 2 3 4 5 6 25 20 10 15 12 DIMENSI DUA Alamat awal dari A(4) ® I = 4 B + (I – L) * S B + (4 – 2) * S = B + 2 * S

Memori komputer adalah linier. Contoh : AA(1:4, 1:6) L2 1 L1 1 2 AA(2,4) U2 2 3 4 5 6

3

U1 4

AA(2,4)

I = 2, J = 4

Pelinieran array dimensi banyak dengan cara :

1. 1.

Secara Baris (ROW-MAJOR ORDER)

AA(2,4)

Kolom 1 2 3 4 1 5 6 1 2 3 4 2 5 6 1 2 3 4 3 5 6 1 2 3 4 4 5 6

Baris

B + (I - L1) * (U2 - L2 + 1) * S + (J - L2) * S

1. 2.

Secara Kolom (COLUMN-MAJOR ORDER)

AA(2,4)

Baris 1 2 3 4 1 2 3 2 4 1 2 3 4 3 1 2 3 4 4 1 2 3 5 4 1 2 3 6 4

Kolom 1

B + (J - L2) * (U1 - L1 + 1) * S + (I - L1) * S ARRAY DIMENSI TIGA Adalah suatu array yang setiap elemennya merupakan tipe data array juga yang merupakan array dimensi dua. Contoh :

Penyajian data mengenai banyaknya mahasiswa dari 20 perguruan tinggi di Jakarta, berdasarkan tingkat (1 sampai 5), dan jenis kelamin (pria atau wanita). Misalkan array tersebut dinamakan MHS. Ambil subskrip pertama, tingkat = 1, 2, ..., 5; subskrip kedua, jenis kelamin (pria = 1, wanita = 2), dan subskrip ketiga, perguruan tinggi adalah K = 1, 2, ..., 20. Jadi MHS(4,2,17) menyatakan jumlah mahasiswa tingkat 4, wanita, dari perguruan tinggi 17. CROSS SECTION (Penampang Array Berdimensi-2) Adalah pengambilan salah satu subskrip. Misal : Baris = tetap/konstan Kolom = berubah-ubah (*) Contoh : B(*,4) = semua elemen pada kolom ke-4. B(2,*) = semua elemen pada baris ke-2.

Pengertian cross-section pada array dimensi banyak, adalah sama seperti pada array dimensi dua. Misal : MHS(4,*,17) = jumlah mahasiswa tingkat 4 dari perguruan tinggi 17 (masing-masing untuk pria dan wanita). MHS(*,*, 3) = jumlah mahasiswa untuk masing-masing tingkat, pria dan wanita, dari perguruan tinggi 3. TRANSPOSE dari array dimensi-2. Adalah penulisan baris menjadi kolom atau kolom menjadi baris. Notasi : Array B (I,J), transpose dari array B adalah BT = (J,I) Contoh : 0 3 1 4 2 5 AT = 0 1 2 3 4 5

A=

A(1,1) = AT(1,1) A(1,2) = AT(2,1) A(1,3) = AT(3,1)

A(2,1) = AT(1,2) A(2,2) = AT(2,2) A(2,3) = AT(3,2)

TRIANGULAR ARRAY (ARRAY SEGITIGA) Triangular array dapat berupa : 1. Upper Triangular semua elemen di bawah diagonal utama = 0 1. Lower Triangular semua elemen di atas diagonal utama = 0 Array berukuran 6 x 6

x 0 0 0 0 0

x x 0 0 0 0

x x x 0 0 0

x x x x 0 0

x x x x x 0

x x x x x x

x x x 0 x x x x x x

0 0 0 x x x

0 0 0 x x x

0 0 0 x x x

0 0

0 0 x 0 x x

Upper Triangular

Lower Triangular

Jumlah baris (N) besar, elemen 0 tidak perlu disimpan dalam memori. Pendekatan : 1. Pelinieran array 2. Menyimpan bagian/elemen ¹ 0. Untuk lower triangular, jumlah maksimum elemen ¹ 0 pada baris ke-I = I Total elemen ¹ o tidak lebih dari : (Untuk upper dan lower triangular)

N S I=1

I = 1/2 N(N + 1)

Upper Triangular T disimpan secara baris dalam array dim-1, S. T(1,1) Õ S(1) T(1,2) Õ S(2) . . . T(1,n) Õ S(n) T(2,2) Õ S(n+1) . . . T(n,n) Õ S(1/2n (n+1))

Program dengan lebih dari 1 array triangular kita dapat menyimpan 2 array sekaligus.

Contoh 1 :

Array A (upper) : N x N B (lower) : (N-1) x (N-1) ÕC:NxN C(I,J) = A(I,J) untuk I £ J

C(I+1, J) = B(I,J) untuk I ³ J Misal : Array A (upper) : 3 x 3 B (lower) : 2 x 2

1 A= 0 0

2 4 0

3 5 6

7 B= 8

0 9

maka akan disimpan di C : 3 x 3 1 C= 7 8 Contoh 2 : Array A (upper) : N x N B (lower) : N x N Disimpan bersama dalam array C : N x (N + 1) C(I, J+1) = A(I,J) untuk I £ J C(I, J) = B(I,J) untuk I ³ J 2 4 9 3 5 6

1 2 3 A= 0 4 5 0 0 6 7 C= 8

7 0 0 B= 8 9 0 11 12 13 1 9 2 4 3 5 6

11 12 13

Misalkan sekarang ada 2 array, sama-sama Upper Triangular, yakni array A dan B. Kita dapat menyimpan bersama-sama dengan melakukan transpose terhadap salah satu array tersebut, misal A menjadi AT. (Lower Triangular). SPARSE ARRAY Suatu array yang sangat banyak elemen nol-nya dikenal sebagai sparse array. Contoh : 1 2 3 4 5 6 7 8 9 10 0 0 0 0 0 0 0 0

1 0 0 0 0 1 0 0 2 0 2 0 1 0 0 0 0 0 0 0 3 1 0 0 0 0 0 0 0 0 4 0 0 0 0 0 0 0 0 0 5 0 0 0 4 0 0 0 0 0 6 0 0 0 0 0 0 0 2 0 7 0 0 0 0 0 0 0 0 0 8 2 1 0 0 0 0 0 0 0 Keuntungan :

Menyimpan elemen ¹ 0 saja, disimpan sebagai TRIPEL, dengan bentuk : (sub baris, sub kolom, nilai elemen) TRIPEL tersebut disimpan sebagai vektor. Array disimpan sebagai TRIPEL Baris 1 1 2 3 5 6 8 8 Kolom 5 8 2 1 4 8 1 2 Nilai 1 2 1 1 4 2 2 1

V(1) V(2) V(3) V(4) V(5) V(6) V(7) V(8)

Kekurangan : Bila dilakukan up-dating, elemen = 0 ® ¹ 0 atau ¹ 0 ® = 0, menimbulkan kesulitan yaitu urutan vektor harus diperbaiki. Misal :

1. V(2) diubah menjadi 0, urutan V(3) - V(8) ® V(2) - V(7) 2. elemen dengan subskrip (4,6) menjadi 7 V(5) ® (4,6,7), urutan bergeser V(5) - V(8) ® V(6) - V(9). BAB 3 STACK(TUMPUKAN) LINIER LIST Suatu struktur data umum yang berisi suatu kumpulan terurut dari elemen; jumlah elemen di dalam list dapat berubah-ubah. Linier list A yang terdiri dari T elemen pada waktu t, dinotasikan sebagai : A = [ A1, A2, ..., AT] Jika T = 0, maka A disebut “Empty List” atau “Null List” Suatu elemen dapat dihilangkan/dihapus dari sembarang posisi dalam linier list, dan dapat pula dimasukkan elemen baru sebagai anggota list. Contoh : 1. File, dengan elemennya berupa record 2. Buku telepon 3. Stack 4. Queue 5. Linear link list STACK Stack adalah suatu bentuk khusus dari linier list, dengan operasi penyisipan dan penghapusan dibatasi hanya pada satu sisinya, yaitu puncak stack (TOP). Elemen teratas dari stack dinotasikan sebagai TOP(S). Untuk stack S, dengan S = [S1, S2, S3, ..., ST] maka TOP(S) = ST Jumlah elemen di dalam stack kita notasikan dengan NOEL(S). NOEL(S) menghasilkan nilai integer. Untuk stack S = [S1, S2, S3, ..., ST] maka NOEL (S) = T. Operator penyisipan (insertion) : PUSH Operator penghapusan (deletion) : POP Operasi stack : LIFO (Last In First Out), yaitu : yang terakhir masuk yang pertama keluar. Jika ada NOEL elemen didalam stack, maka elemen ke NOEL merupakan elemen puncak (TOP).

Stack secara umum : S = [S1, S2, ..., SNOEL] bahwa : SI berada di atas elemen SJ, untuk I > J

SI akan dikeluarkan lebih dulu dari elemen di bawahnya. Contoh stack : Tumpukan baki dalam cafetaria Empat operasi dasar yang berlaku pada stack : 1. CREATE(stack) 2. ISEMPTY(stack) 3. PUSH(elemen, stack) 4. POP(stack)

CREATE

adalah operator yang menunjukkan suatu stack kosong dengan nama S.

Jadi : NOEL(CREATE(S)) = 0 TOP(CREATE(S)) adalah TIDAK TERDEFINISI.

ISEMPTY

adalah operator yang menentukan apakah stack S kosong. Operandnya terdiri dari type data stack. Hasilnya merupakan type data Boolean. ISEMPTY(S) = True. Jika S hampa, yakni bila NOEL(S) = 0.

PUSH

adalah operator yang menambahkan elemen E pada puncak stack S. Hasilnya merupakan stack yang lebih besar. PUSH(E,S). E ditempatkan sebagai TOP(S).

POP(stack)

adalah operator yang menghapus sebuah elemen dari puncak stack S. Hasilnya merupakan stack yang lebih kecil.

• • •

POP(S) mengurangi NOEL(S) POP(CREATE(S)) ® kondisi error POP(PUSH(E,S)) = S

DEKLARASI STACK DALAM COBOL DAN PASCAL TOP-PTR ® 100 · · STACK S S Keterangan :

· 1

TOP-PTR : subskrip dari elemen TOP(S) dari stack.

COBOL 01 STACK-STRUCT ® kombinasi dari array dan indikator untuk TOP 02 S OCCURS 100 TIMES PIC 9(5) 02 TOP-PTR PIC 9(3)

PASCAL TYPE STACKSTRUCT = RECORD STACK : ARRAY [1..100] of integer; TOPPTR : integer; END;

VAR S : STACKSTRUCT; NOEL(S) = TOP-PTR, ISEMPTY(S) = true, bila TOP-PTR = 0. OPERASI PUSH & POP PUSH IF TOP-PTR < NOEL-MAX THEN COMPUTE TOP-PTR = TOP-PTR + 1 MOVE EON TO S(TOP-PTR) ELSE Overflow condition POP IF TOP-PTR > 0 THEN MOVE S(TOP-PTR) TO EOFF COMPUTE TOP-PTR = TOP-PTR - 1 ELSE Underflow condition EON : elemen yang di PUSH ke dalam S. EOFF : elemen yang di POP ke luar S. NOEL-MAX : panjang max stack. PUSH

Procedure PUSH (eon: integer); Begin if (s.topptr < noelmax) then Begin s.topptr := s.topptr + 1; s.stack [s.topptr] := eon; End;

else Overflow-condition End; POP Procedure POP (var eoff : integer); Begin if (s.topptr > 0) then Begin eoff := s.stack [s.topptr]; s.topptr := s.topptr - 1; End; else Underflow Condition End; APLIKASI STACK 1. Penjodohan Tanda Kurung/Matching Parantheses ALGORITMA a. Amati barisan elemen dari kiri ke kanan b. · bila bertemu ‘(‘, maka ‘(‘ di push ke dalam stack. · bila bertemu ‘)’, maka periksa stack hampa atau tidak. bila hampa ® ada ‘)’ dan tidak ada ‘(‘ (error) bila tidak hampa ® ada sepasang ‘(‘ & ‘)’ & POP elemen

keluar

2.

NOTASI POSTFIX ALGORITMA Amati barisan dari kiri ke kanan 1. Jika ‘(‘, maka PUSH ke dalam stack. 2. Jika ‘)’, POP elemen dalam stack sampai simbol ‘(‘. Semua di POP merupakan output kecuali ‘(‘ tadi. 3. Jika simbol operand, langsung merupakan output. 4. Jika simbol operator, maka : Jika elemen TOP stack dengan level >= maka POP sebagai output teruskan sampai ‘(‘. elemen TOP <, operator yang diamati di PUSH ke dalam stack. 5. Bila ‘;’ kita POP semua elemen dalam stack hingga hampa. APLIKASI STACK

Notasi Postfix Contoh : Notasi Infix : ((A+B) * C/D+E^F)/G; Simbol yang diamati TOP dari STACK 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 ( ( A + B ) * C / D + E ^ F ) / G ; + + ^ ^

( ( OUTPUT (

( ( A

( (

( ( ( B +

* (

*

/

/ ( D

+ ( /

+ ( E

+ (

+ ( F / ^+ / G

( ( C *

/

Soal : 1. A * B - (C + D) -(E - F) + F/H ^ I; 2. ((B * C) + C/D ^ F) + G; 3. A ^ B * C - D + E/F / (G + H); ALGORITMA PENYISIPAN Terdiri dari : 1. Algoritma Penyisipan Simpul pada bagian awal list. 2. Algoritma Penyisipan Simpul sesudah suatu simpul yang diketahui lokasinya. 3. Algoritma Penyisipan Simpul ke dalam suatu list terurut.

Semua algoritma diasumsikan bahwa Linked List tersimpan di dalam memori dalam bentuk LIST(INFO, LINK, START, AVAIL) dari variabel ITEM menyatakan informasi baru yang akan ditambahkan ke dalam list. Karena semua Algoritma Penyisipan kita tersebut membutuhkan simpul dari list AVAIL, maka selalu mengandung langkah : 1. Memeriksa ruang bebas dari list AVAIL, kalau ternyata tidak ada lagi, yakni dalam hal ini AVAIL = NULL, Algoritma mengirim pesan OVERFLOW. 2. Pemindahan simpul pertama dari list AVAIL, menggunakan variabel NEW. Pemindahan ini melalui sepasang statement

NEW := AVAIL AVAIL := LINK(AVAIL)

1. Menyalin informasi baru tersebut ke dalam simpul baru, atau dengan perkataan lain, memakai statement

INFO(NEW) := ITEM Diagram skematik untuk langkah 2 dan 3 adalah (Gambar 15a):

NEW

·

AVAIL

· ITEM

FREE STORAGE LIST ·

·

·

x

Gambar 15a PENYISIPAN PADA BAGIAN AWAL LIST Linked list tidak perlu terurut dan penyisipan tidak harus di suatu posisi tertentu. Maka posisi termudah untuk memasukkan simpul baru adalah di bagian awal list. ALGORITMA INSFIRST(INFO, LINK, START, AVAIL, ITEM) Algoritma ini menyisipkan ITEM sebagai simpul pertama dari list

1. [Apakah Overflow?] Jika AVAIL = NULL, maka tulis OVERFLOW, dan Exit. 2. [Memindahkan simpul pertama dari list AVAIL.] NEW := AVAIL dan AVAIL := LINK[AVAIL]. 1. 2. 3. 4. INFO[NEW] := ITEM. [Menyalin data baru ke dalam simpul baru.] LINK[NEW] := START. [Simpul baru sekarang menuding ke simpul semula.] START := NEW. [Mengubah START agar menuding ke simpul yang baru.] Exit.

Diagram skematik langkah 2 dan 3 terlihat pada Gambar 15a. Diagram skematik langkah 4 dan 5 dapat dilihat pada Gambar 15b. START • ·

·

·

x

NEW

·

ITEM

·

Gambar 15b Contoh : Pandang list pada Gambar 7 yang lalu.

Misalkan angka 75 akan disisipkan pada awal dari List Geometri. Dengan menggunakan algoritma di atas, perhatikan bahwa ITEM =75, INFO = TEST, dan START = GEOM. INSFIRST(INFO, LINK, START, AVAIL, ITEM)

1. 2. 3. 4. 5. 6.

Karena AVAIL <> NULL, ke langkah 2. NEW = 9, maka AVAIL = LINK[9] = 10. TEST[9] = 75. LINK[9] = 5. GEOM = 9. Exit.

Gambar 16 memperlihatkan keadaan setelah 75 dimasukkan ke dalam List Geomaetri. Perhatikan bahwa hanya 3 penuding yang berubah, yaitu AVAIL, GEOM dan LINK[9].

TEST 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 74 82 84 78 74 100 75 88 62 74 93

ALG

11

GEOM

9

AVAIL

10

LINK 16 14 1 0 12 0 8 13 5 3 2 7 6 4 0 15 Gambar 16

PENYISIPAN SESUDAH SIMPUL DIKETAHUI Pandang bahwa nilai dari LOC, yaitu lokasi dari simpul A di dalam linked list, atau nilai LOC = NULL. Berikut ini adalah Algoritma untuk menyisipkan ITEM ke dalam list, tepat sesudah simpul A, atau jika LOC = NULL, maka ITEM disisipkan sebagai simpul pertama dari list. Misalkan N adalah simpul baru, yang lokasinya adalah NEW. Jika LOC = NULL, maka penyisipan dikerjakan seperti pada algoritma yang lalu. Dalam hal lain, seperti terlihat pada gambar 9, jadikan N menuding simpul B (simpul yang sebelumnya mengikuti simpul A), dengan menggunakan statement

LINK[NEW] := LINK[LOC] Dan jadikan simpul A menuding simpul baru N dengan menggunakan statement LINK[LOC] := NEW

Algoritma : INSLOC(INFO,LINK,START,AVAIL<LOC<ITEM) {Algoritma ini dimaksudkan untuk menyisipkan ITEM, sehingga mengikuti simpul dengan lokasiLOC atau menyisipkan ITEM sebagai Simpul pertama, bila LOC = NULL. 1. [OVERFLOW ?] jika AVAIL = NULL, maka : Tulis: OVERFLOW, dan EXIT 2. [Memindahkan Simpul pertama dari List AVAIL] NEW := AVAIL AVAIL := LINK[AVAIL] 1. INFO[NEW] := ITEM. [Menyalin data baru ke dalam simpul baru] 2. Jika LOC = NULL, maka : [Sisipkan sebagai Simpul pertama] LINK[NEW] := START dan START := NEW. Dalam hal lain : [Sisipkan sesudah Simpul dengan lokasi LOC] LINK[NEW] := LINK[LOC] dan LINK[LOC] := NEW. [Akhir dari struktur jika] 5. EXIT PENYISIPAN KE DALAM LINKED LIST TERURUT Misalkan ITEM akan disisipkan ke dalam Linked List terurut LIST. ITEM harus disisipkan di antara simpul A dan B yang berturutan sedemikian sehingga INFO(A) < ITEM < INFO(B) Prosedur untuk mencari lokasi simpul A, yakni mencari lokasi dari simpul terakhir dari List yang nilainya kurang dari ITEM. Lakukan traversal list, pergunakan variabel penuding PTR, dan bandingkan ITEM dengan INFO(PTR) pada masing-masing simpul. Selama traversal, jaga jejak lokasi simpul sebelumnya dengan menggunakan variabel penuding SAVE (Gambar 17). Maka SAVE dan PTR ter-update dengan statement SAVE := PTR dan PTR := LINK[PTR] START • · SAVE

PTR ·

·

·

·

·

·

·

x

Gambar 17 Traversal dilanjutkan selama INFO[PTR] < ITEM, atau akan berhenti saat ITEM <= INFO[PTR]. Kemudian PTR menuding ke simpul B, maka SAVE berisi lokasi dari simpul A.

Kasus bahwa list adalah hampa, dan ITEM < INFO[START], sehingga LOC = NULL ditangani sendiri, karena tidak mengandung variabel SAVE. Prosedur : FINDA (INFO, LINK, START, ITEM, LOC) {Prosedur ini akan menemukan lokasi LOC dari simpul terakhir dalam list terurut, sedemikian sehingga INFO[LOC] < ITEM, atau menjadikan LOC = NULL}

1. 2. 3. 4.

[List hampa?] Jika START = NULL, maka LOC := NULL, dan Return. [Kasus khusus?] Jika ITEM < INFO[START], maka LOC := NULL, dan Return. SAVE := START dan PTR := LINK[START]. [Mengawali Penuding] Ulangi langkah 5 dan 6 sementara PTR <> NULL. 1. Jika ITEM < INFO[PTR], maka :

LOC := SAVE, dan Return. [Akhir dari struktur jika] 1. SAVE := PTR dan PTR := LINK[PTR]. [Mengupdate Penuding]. [Akhir dari loop langkah 4] 1. LOC := SAVE 2. Return.

Sekarang kita mempunyai Algoritma untuk menyisipkan ITEM ke dalam linked list terurut List, dengan memanfaatkan 2 prosedur terakhir. Algoritma : INSSRT(INFO, LINK, START, AVAIL, ITEM) {Algoritma ini menyisipkan ITEM ke dalam suatu linked list terurut}

1. [Gunakan Prosedur FINDA untuk mencari lokasi dari simpul sebelum ITEM] Call FINDA(INFO, LINK, START, ITEM, LOC). 1. [Gunakan Algoritma INSLOC untuk menyisipkan ITEM sesudah simpul dengan lokasi LOC] Call INSLOC(INFO, LINK, START, AVAIL, LOC, ITEM). 1. Exit.

Contoh : Perhatikan list yang terurut secara alfabetik dari para Pasien pada Gambar 6 yang lalu. Pandang bahwa Jones akan disisipkan ke dalam List tersebut. Gunakan Algoritma INSSRT di atas, yang pada hakikatnya melaksanakan prosedur FINDA, dan kemudian Algoritma INSLOC. Perhatikan bahwa ITEM = Jones, dan INFO = BED.

1. FINDA(BED, LINK, START, ITEM, LOC) 1. Karena START <> NULL, maka kita melangkah ke langkah 2.

2. Karena BED[5] = Adams < Jones, kendali beralih ke langkah 3. 3. SAVE = 5, dan PTR = LINK[5] = 3

1. Langkah 5 dan 6 diulang, sebagai berikut : 1. BED[3] = Dean < Jones, maka SAVE = 3, dan PTR = LINK[3] = 11 2. BED[11] = Fields < Jones, maka SAVE = 11, dan PTR = LINK[11] = 8 3. BED[8] = Green < Jones, maka SAVE = 8, dan PTR = LINK[8] = 1 4. Karena BED[1] = Kirk > Jones, maka LOC = SAVE = 8, dan Return.

1. INSLOC(BED, LINK, START, AVAIL, LOC, ITEM) 1. Karena AVAIL <> NULL, maka kita melangkah ke langkah 2. 2. NEW = 10, dan AVAIL = LINK[10] = 2 3. BED[10] = Jones 4. Karena LOC <> NULL, maka LINK[10] = LINK[8] = 1, dan LINK[8] = NEW = 10 1. Exit

Gambar 18 menunjukkan struktur data sesudah Jones disisipkan ke dalam List. Di sini hanya 3 penuding yang berubah, yakni AVAIL, LINK[10] dan LINK[8]. BED START 5 1 Kirk 2 3 Dean 4 Maxwell 5 Adams 6 7 Lane 8 Green 9 Samuels 10 Jones 11 Fields 12 Nelson Gambar 18 PENGHAPUSAN SIMPUL LINKED LIST Misalkan simpul N adalah simpul dari List yang terletak di antara simpul A dan simpul B (Gambar 19a). Simpul N tersebut akan dihapus dari List. Diagram skematik dari penghapusan terlihat pada Gambar 19b. LINK 7 6 11 12 3 0 4 10 0 1 8 9

AVAIL

2

Penghapusan terjadi begitu nextpointer dari A berubah menuding ke B. Dalam penghapusan ini, kita harus mengingat alamat dari simpul A, simpul pendahulu dari simpul yang akan dihapus tersebut.

Pandang linked list tersimpan di memori dalam bentuk : LIST(INFO, LINK, START, AVAIL) Gambar 19 tidak memperlihatkan fakta bahwa kita melakukan penghapusan simpul N, dan akan memulangkan ruang memori kepada list AVAIL. Diagram skematik yang lebih tepat terlihat pada Gambar 20. Perhatikan bahwa 3 field penuding berubah, yakni : 1. Nextpointer dari simpul A sekarang menuding ke B, yang tadinya dituding oleh N. 2. Nextpointer dari simpul N sekarang menuding ke simpul pertama dari ruang bebas, yang tadinya dituding oleh AVAIL. 3. AVAIL sekarang menuding ke simpul N.

START

·

·

Node A • ·

Node N • ·

Node B • ·

·

x

(a) Sebelum Penghapusan

START

·

·

Node A • ·

Node N • ·

Node B • ·

·

x

(b) Sesudah Penghapusan Gambar 19 Di sini terdapat 2 kasus istimewa yaitu : 1. Penghapusan simpul N sebagai simpul pertama dalam list. Dalam hal ini, START akan menuding ke simpul B.

2. Penghapusan simpul N sebagai simpul terakhir dari list, simpul A akan berisi penuding NULL.

START

·

·

Node A • ·

Node N • ·

Node B • ·

·

x

AVAIL

·

·

·

·

x

Gambar 20

Contoh : Perhatikan list Pasien pada Gambar 18. Misalkan Pasien Green sudah diperbolehkan pulang, maka BED[8] sekarang menjadi kosong. Agar linked list tersebut tetap terjaga, maka perlu dilakukan perubahan terhadap beberapa field penuding, yakni sebagai berikut : LINK[11] = 10 LINK[8] = 2 AVAIL = 8

Dari perubahan pertama, Fields yang tadinya mendahului Green, sekarang menuding ke Jones, yang tadinya mengikuti Green. Preubahan kedua dan ketiga akan menambah jumlah ranjang kosong baru pada list AVAIL. Ditekankan bahwa sebelum membuat penghapusan, harus mencari simpul BED[11], yang tadinya menuding ke simpul yang dihapus, BED[8]. BED START 5 1 Kirk 2 3 Dean 4 Maxwell 5 Adams 6 7 Lane 8 Samuels LINK 7 6 11 12 3 0 4 2 0

AVAIL

8

10 Jones 11 Fields 12 Nelson

1 10 9

Gambar 21 ALGORITMA PENGHAPUSAN 1. Penghapusan simpul sesudah suatu simpul yang diketahui. 2. Penghapusan simpul yang diketahui mempunyai informasi ITEM.

Asumsi : Linked list dalam bentuk LIST(INFO, LINK, START, AVAIL). Semua algoritma penghapusan selalu mengembalikan ruang memori dari simpul yang dihapus, ke bagian awal dari list AVAIL. Karenanya, Algoritma mengandung pasangan statement berikut ini: LINK[LOC] := AVAIL AVAIL := LOC Di sini LOC adalah lokasi dari simpul N yang dihapus. Kedua operasi di atas digambarkan pada Gambar 22. LOC

·

Node N

·

AVAIL

·

Free-storage list

·

·

·

x

Gambar 22 PENGHAPUSAN SIMPUL SESUDAH SIMPUL YANG DIKETAHUI Algoritma : DEL(INFO, LINK, START, AVAIL, LOC, LOCP) {Algoritma ini dimaksudkan untuk menghapus simpul N dengan lokasi LOC. LOCP adalah lokasi dari simpul yang mendahului N atau, apabila N adalah simpul pertama, LOCP = NULL}.

1. Jika LOCP = NULL, maka : START := LINK[START]. [Menghapus simpul pertama] Dalam hal lain : LINK[LOCP] := LINK[LOC]. [Menghapus simpul N]

[Akhir dari struktur jika] 1. [Mengembalikan simpul terhapus kepada list AVAIL] 2. Exit.

Gambar 23 merupakan diagram skematik dari statement START := LINK[START] START • · Node 1 • · Node 2 • · Node 3 • ·

Gambar 23 Gambar 24 merupakan diagram skematik dari statement LINK[LOCP] := LINK[LOC] START LOCP • · • · LOC • ·

·

·

· Node N

·

·

x

Gambar 24 PENGHAPUSAN SIMPUL SESUDAH SIMPUL YANG DIKETAHUI INFORMASINYA Algoritmanya yakni Algoritma DELLOC bekerja dengan memanfaat-kan Prosedur FINDB. Prosedur : FINDB(INFO, LINK, START, ITEM, LOC, LOCP) {Prosedur ini dimaksudkan untuk mencari lokasi LOC dari simpul N pertama yang mengandung ITEM dan lokasi LOCP dari simpul pendahulu N. Jika ITEM tidak terdapat pada List, maka prosedur akan menjadikan LOC = NULL, dan jika ITEM muncul pada simpul pertama, maka LOCP = NULL}.

1. [List hampa?] Jika START = NULL, maka : LOC := NULL dan LOCP := NULL, dan Return. [Akhir dari struktur jika] 1. [ITEM di dalam simpul pertama?] Jika INFO[START] = ITEM, maka : LOC := START dan LOCP := NULL, dan Return.

1. SAVE := START dan PTR := LINK[START] [Inisialisasi Penuding] 2. Ulangi langkah 5 dan 6 sementara PTR <> NULL. 3. Jika INFO[PTR] = ITEM, maka : LOC := PTR dan LOCP := SAVE, dan Return. [Akhir dari struktur jika] 1. SAVE := PTR dan PTR := LINK[PTR] [Mengupdate Penuding] [Akhir dari Loop langkah 4] 1. LOC := NULL [Cari tidak berhasil] 2. Return.

Algoritma : DELLOC(INFO, LINK, START, AVAIL, ITEM) {Algoritma ini dimaksudkan untuk menghapus dari suatu linked list, simpul N pertama yang berisi informasi ITEM}

1. [Gunakan Prosedur FINDB, untuk mencari lokasi dari N dan simpul pendahulunya] Call FINDB(INFO, LINK, START, ITEM, LOC, LOCP) 1. Jika LOC = NULL, maka : Tulis : ITEM tidak dalam list, dan Exit. 2. [Hapus simpul] Jika LOCP = NULL, maka : START := LINK[START]. [Hapus simpul pertama] Jika tidak : LINK[LOCP] := LINK[LOC]. [Akhir dari struktur jika] 1. [Mengembalikan simpul terhapus ke list AVAIL] LINK[LOC] := AVAIL dan AVAIL := LOC. 1. Exit.

HEADER LINKED LIST Header linked list adalah suatu list yang mengandung suatu simpul khusus yang terletak pada bagian awal dari list yang disebut simpul header. Berikut ini 2 jenis header linked list yang biasa digunakan yakni :

1. Grounded Header List : header list yang simpul terakhirnya berisi penuding NULL

1. Circular Header List : header list yang simpul terakhirnya menuding ke simpul header dari list tersebut.

LINK[START] = NULL è menunjukkan Grounded Header List hampa LINK[START] = START è menunjukkan Circular Header List hampa

BAB 6 GRAF Graf adalah : ♦ Himpunan V (Vertex) yang elemennya disebut simpul (atau point atau node atau titik) ♦ Himpunan E (Edge) yang merupakan pasangan tak urut dari simpul, anggotanya disebut ruas (rusuk atau sisi) Notasi : G(V,E) Simpul u dan v disebut berdampingan bila terdapat ruas (u,v). Graf dapat pula disajikan secara geometrik, simpul disajikan sebagai sebuah titik, sedangkan ruas disajikan sebagai sebuah garis yang menghubungkan 2 simpul. Contoh 1 : Graf G(V,E) dengan : 1. V terdiri dari 4 simpul, yaitu simpul A, B, C dan D 2. E terdiri dari 5 ruas, yaitu e1 = (A, B) e2 = (B, C) e4 = (C, D) e5 = (B, D)

e3 = (A, D)

A • e1 • B e5

e3

D • e4 • C

e2

Banyak simpul disebut ORDER, banyak ruas disebut SIZE dari graf. Graf yang lebih umum disebut Multigraf Contoh 2 : Graf G(V,E) dengan : 1. V terdiri dari 4 simpul, yaitu simpul A, B, C dan D 2. E terdiri dari 6 ruas, yaitu e1 = (A, C) e2 = (A, A) e4 = (C, D) e5 = (B, C) e6 = (B, C)

e3 = (A, D)

A e2 • e1 e5 • B e6

e3

D • e4 • C

Di sini ruas e2 kedua titik ujungnya adalah simpul yang sama, yaitu simpul A, disebut Gelung atau Self-Loop. Sedangkan ruas e5 dan e6 mempunyai titik ujung yang sama, yaitu simpul B dan C, disebut Ruas Berganda atau Ruas Sejajar. Suatu graf yang tidak mengandung ruas sejajar ataupun self-loop disebut Graf Sederhana atau Simple Graf. Suatu graf G’(V’,E’) disebut subgraf dari G(V,E), jika V’ himpunan bagian dari V dan E’ himpunan bagian dari E. Jika E’ mengandung semua ruas dari E yang titik ujungnya di V’, maka G’ disebut subgraf yang direntang oleh V’ (Spanning subgraf). Contoh : A G e1 • B • e3 e5 D • e4 • C

e2

A G’ •

D • G’ subgraf dari G (namun bukan dibentuk oleh V’ = {A,B,D}) e3

e1 • B

G’ subgraf yang dibentuk oleh V’ = (A,B,D)

A

e5

D

G’ e1

• e3 • B

GRAF BERLABEL

Graf G disebut graf berlabel jika ruas dan atau simpulnya dikaitkan dengan suatu besaran tertentu. Jika setiap ruas e dari G dikaitkan dengan suatu bilangan non negatif d(e), maka d(e) disebut bobot atau panjang dari ruas e.

DERAJAT GRAF

Derajat simpul V, ditulis d(v) adalah banyaknya ruas yang menghubungi v. Karena setiap ruas dihitung dua kali ketika menentukan derajat suatu graf, maka : Jumlah derajat semua simpul suatu graf (derajat) = dua kali banyaknya ruas graf (size graf). Suatu simpul disebut genap/ganjil tergantung apakah derajat simpul tersebut genap/ganjil. Kalau terdapat self-loop, maka self-loop dihitung 2 kali pada derajat simpul. Contoh : A G • B • F •

• • • E C D Di sini banyaknya ruas = 7, sedangkan derajat masing-masing simpul adalah : d(A) = 2 d(D) = 3 derajat graf G = 14 d(B) = 5 d(E) = 1 (2 * 7) d(C) = 3 d(F) = 0 Catatan : E disebut simpul bergantung/akhir, yakni simpul yang berderajat satu. Sedangkan F disebut simpul terpencil, yakni simpul berderajat nol.

KETERHUBUNGAN

Walk atau perjalanan dalam graf G adalah barisan simpul dan ruas berganti-ganti : v1, e1, v2, e2, …, en-1, vn Di sini ruas e1 menghubungkan simpul vi dan vI+1

Banyaknya ruas disebut panjang walk. Walk dapat ditulis lebih singkat dengan hanya menulis deretan ruas : e1, e2, …, en-1 atau deretan simpul : v1, v2, …, vn-1, vn v1 disebut simpul awal, vn disebut simpul akhir Walk disebut tertutup bila v1 = vn , dalam hal lain walk disebut terbuka, yang menghubungkan v1 dan vn Trail adalah walk dengan semua ruas dalam barisan berbeda. Path atau jalur adalah walk dengan semua simpul dalam barisan berbeda. Jadi path pasti trail, sedangkan trail belum tentu path. Dengan kata lain : Suatu path adalah suatu trail terbuka dengan derajat setiap simpulnya = 2, kecuali simpul awal v1 dan vn simpul akhir berderajat = 1. Cycle atau sirkuit adalah suatu trail tertutup dengan derajat setiap simpul = 2. Contoh : Graf yang tidak mengandung cycle disebut acyclic, contoh : pohon atau tree. Suatu graf G disebut terhubung jika untuk setiap 2 simpul dari graf terdapat jalur yang menghubungkan 2 simpul tersebut. Subgraf terhubung suatu graf disebut komponen dari G bila subgraf tersebut tidak terkandung dalam subgraf terhubung lain yang lebih besar. Contoh : Graf G terdiri dari 3 komponen B • C •

•D

•F

•A

•E

Terlihat misalnya antara D dan A tidak ada jalur. Jarak antara 2 simpul dalam graf G adalah panjang jalur terpendek antara ke-2 simpul tersebut. Diameter suatu graf terhubung G adalah maksimum jarak antara simpul-simpul G.

Contoh : Graf G (graf terhubung) terdiri dari 1 komponen • C •E

A•

•D

•G

•B

• F

Jarak maksimum dalam graf G adalah 3 (yaitu antara A – G atau B – G ataupun C – G). Jadi diameter = 3. Kalau order dari G = n, size dari G = e, dan banyaknya komponen = k, maka didefinisikan : Rank(G) = n – k Nullity(G) = e – (n – k) MATRIKS PENYAJIAN GRAF Pandang bahwa G graf dengan N simpul dan M ruas. Untuk mempermudah komputasi, graf dapat disajikan dalam bentuk matriks, disebut Matriks Ruas, yang berukuran (2 x M) atau (M x 2) yang menyatakan ruas dari graf. Matriks adjacency dari graf G tanpa ruas sejajar adalah matriks A berukuran (N x N), yang bersifat : 1, bila ada ruas (vi, vj) aij = 0, dalam hal lain Matriks adjacency merupakan matriks simetri. Untuk graf dengan ruas sejajar, matriks adjacency didefinisikan sebagai berikut : p, bila ada p buah ruas menghubungkan (vi, vj) (p > 0) aij = 0, dalam hal lain Matriks Incidence dari graf G, tanpa self-loop didefinisikan sebagai matriks M berukuran (N x M) 1, bila ruas ej berujung di simpul vi, mij = 0, dalam hal lain Contoh : e5 v1 • e4 e1 e2 e6 v4 • e8 e7 v5 •

• v2

• e3 v3

Matriks Ruas

1 1 1 1 2 3 3 4 2 3 4 5 3 4 5 5

atau

1 1

2 3 1 1 2 3 3 4

4 5 3 4 5 5

Matriks Adjacency : N x N v1 v1 v2 v3 v4 v5 0 1 1 1 1 v2 1 0 1 0 0 v3 1 1 0 1 1 v4 1 0 1 0 1 v5 1 0 1 1 0

Matriks Incidence : N x M e1 v1 v2 v3 v4 v5 1 1 0 0 0 e2 1 0 1 0 0 e3 0 1 1 0 0 e4 1 0 0 1 0 e5 1 0 0 0 1 e6 0 0 1 1 0 e7 0 0 1 0 1 e8 0 0 0 1 1

GRAF BERARAH (DIGRAF) Suatu graf berarah (digraf) D terdiri atas 2 himpunan : 1. Himpunan V, anggotanya disebut simpul 2. Himpunan A, merupakan himpunan pasangan terurut, yang disebut ruas berarah atau arkus. Notasi : D(V, A) Simpul, anggota v, digambarkan sebagai titik (atau lingkaran kecil). Sedangkan arkus a=(u,v), digambarkan sebagai garis dilengkapi dengan tanda panah mengarah dari simpul u ke simpul v. Simpul u disebut titik pangkal, dan simpul v disebut titik terminal dari arkus tersebut. Contoh : Graf berarah D (V, A) dengan : 1. V mengandung 4 smpul, yaitu : 1, 2, 3 dan 4 2. A mengandung 7 arkus, yaitu : (1,4), (2,1), (2,1), (2,2), (2,3), (2,4), (4,3).

1 •

4 • Arkus (2, 2) : gelung / self loop Arkus (2,1) : arkus sejajar / arkus berganda

• 2

• 3 BAB 7

POHON BINAR Pohon (Tree) adalah graf terhubung yang tidak mengandung sirkuit. Karena merupakan graf terhubung maka pada pohon selalu terdapat path atau jalur yang menghubungkan kedua simpul di dalam pohon. Pohon dilengkapi dengan Root (akar). Contoh : Pohon berakar T
P

Q

T

R

S

U

V

W

Sifat utama pohon berakar : 1. Jika pohon mempunyai simpul sebanyak n, maka banyaknya ruas adalah (n-1). Pada contoh : banyak simpul adalah 8 maka banyaknya ruas adalah 7. 2. Mempunyai simpul khusus yang disebut Root (Akar), jika simpul tersebut memiliki derajat keluar ≥ 0 dan derajat masuk = 0. Simpul P merupakan root. 3. Mempunyai simpul yang disebut Leaf (Daun), jika simpul tersebut memiliki derajat keluar = 0 dan derajat masuk = 1. Simpul R, S, V, W merupakan daun pada pohon T. 4. Setiap simpul mempunyai tingkatan (level), dimulai dari root dengan level 0 sampai dengan level n pada daun yang paling bawah. Pada contoh : P mempunyai level 0 Q, T mempunyai level 1 R, S, U mempunyai level 2 V, W mempunyai level 3 Simpul yang mempunyai level yang sama disebut Bersaudara (Brother /Stribling) 5. Pohon mempunyai ketinggian (kedalaman / height) yaitu level tertinggi +1. Ketinggian pohon T adalah 3+1 = 3

6. Pohon mempunyai berat (bobot / weight) yaitu banyaknya daun pada pohon. Berat pohon T adalah 4 POHON BINAR (BINARY TREE) Pohon binar adalah himpunan simpul yang terdiri dari 2 subpohon (yang disjoint / saling lepas) yaitu subpohon kiri dan subpohon kanan. Setiap simpul dari pohon binar mempunyai derajat keluar maksimum = 2. Pendefinisian pohon binar bersifat rekursif. Pohon binar acapkali disajikan dalam bentuk diagram. Contoh : A

B

C

D

E

G

H

F

J

K

L Untuk menggambarkan suksesor kiri dan suksesor kanan, dibuat garis ke kiri bawah dan ke kanan bawah. B adalah suksesor kiri dari A, sedangkan C adalah suksesor kanan dari A. Subpohon kiri dari A mengandung simpul B, D, E dan F, sedangkan subpohon kanan mengandung simpul C, G, H, J, K dan L. Pada contoh di atas : Root adalah A Simpul yang mempunyai 2 anak adalah simpul A, B, C dan H. Simpul yang mempunyai 1 anak adalah simpul E dan J. Simpul yang tidak mempunyai anak disebut daun (terminal) adalah D, F, G, K dan L. Perhatikan pohon T1 dan T2 dan T3 ini : T1 A T2 S T3 A

B

C

T

U

B

C

D

E

V

W

D

E

Dua pohon binar disebut similar jika mempunyai struktur (bangun/susunan) pohon yang sama. Contoh : Pohon binar T1 dan T2 adalah similar. Kedua pohon binar disebut Salinan (Ekivalen/Copy) jika :

1. Mempunyai struktur pohon yang sama (similar) 2. Elemen yang sama pada simpul yang bersesuaian. Contoh : Pohon binar T1 dan T3 adalah ekivalen

TERMINOLOGI PADA POHON BINAR Terminologi hubungan keluarga banyak digunakan dalam terminologi pada pohon binar. Misalnya istilah anak kiri dan anak kanan, untuk menggantikan suksesor kiri dan suksesor kanan, serta istilah ayah untuk pengganti predesesor. Contoh : A

D

E

F

G

M

K

L

K misalnya adalah keturunan kanan dari D, tetapi bukan keturunan dari F, E ataupun M. Simpul G adalah ayah dari K dan L. Di sini K dan L adalah bersaudara, masing-masing anak kiri dan anak kanan dari G. Garis yang ditarik dari Simpul N ke suksesor disebut Ruas dan sederetan ruas yang berturutan disebut Jalur atau path. Sebuah jalur yang berakhir pada daun (terminal) disebut Cabang. Garis AD maupun GL adalah contoh ruas. Barisan ruas (AD, DG, GL) adalah jalur dari simpul A ke simpul L, jalur tersebut merupakan cabang, karena berakhir di simpul terminal (daun ) L. Dari contoh pohon binar di atas : Root : A Simpul Daun adalah : F, K, L dan M Level 0 adalah simpul A Level 1 adalah simpul D dan E Level 2 adalah simpul F, G dan M Level 3 adalah simpul K dan L Ketinggian (kedalaman) = 3 + 1 = 4 Berat (bobot) = 4 Cabang (AD, DG, GK) ataupun (AD, DG, GL) mengandung simpul dengan jumlah maksimum, yakni = 4, sedangkan cabang (AE, EM) serta (AD, DF) hanya mengandung 3 simpul. POHON BINAR LENGKAP Setiap simpul dari pohon binar paling banyak mempunyai dua anak. Simpul akar bertingkat = 0, hanya terdiri dari 1 simpul. Anaknya bertingkat = 1 terdiri paling banyak 2 simpul, demikian seterusnya, simpul dengan tingkat = r paling banyak ada 2r. Suatu pohon binar T dikatakan lengkap atau complete, bila setiap tingkatnya kecuali mungkin tingkat yang terakhir, mempunyai semua simpul yang mungkin, yakni 2r simpul untuk tingkat ke-r, dan bila semua simpul pada tingkat terakhir muncul di bagian kiri pohon.

Kita dapat memberi label pohon binar lengkap menggunakan integer 1, 2, …, n dari kiri ke kanan generasi demi generasi. Hal ini untuk mempermudah kita untuk mengetahui ayah serta anak dari suatu simpul pada pohon binar lengkap. Dalam hal ini anak kiri dari simpul K adalah 2 * K dan anak kanan dari simpul K adalah 2*K+1. Sedangkan ayah dari K adalah INT(K/2). Notasi INT(P) adalah integer terbesar yang lebih kecil atau sama dengan P. Jadi INT(3 2/3) = 3, INT(15/2) = 7, INT(4) = 4, dan sebagainya.

POHON-2 Pohon Binar T dikatakan Pohon-2 atau pohon binar yang dikembangkan bila setiap simpul mempunyai 0 atau 2 anak. Dalam kasus ini, simpul dengan 2 anak disebut simpul internal, sedangkan simpul tanpa anak disebut simpul eksternal. Dalam diagram, seringkali diadakan pembedaan antara simpul internal dan eksternal. Simpul internal digambarkan sebagai lingkaran, sedangkan simpul eksternal sebagai bujursangkar. Contoh :

POHON KETINGGIAN SEIMBANG Pohon binar yang mempunyai sifat bahwa ketinggian subpohon kiri dan subpohon kanan dari pohon tersebut berbeda paling banyak 1, disebut Pohon Ketinggian Seimbang atau Height Balanced Tree (HBT). Contoh : A A

B HBT

C

B

C

E
F Bukan HBT

D

KETINGGIAN MINIMUM DAN MAKSIMUM POHON BINAR

Jika banyaknya simpul = N, maka : 1. Ketinggian Minimum adalah : Hmin = INT(2log N) + 1 2. Ketinggian Maksimum adalah : N

Contoh : untuk N = 8 Ketinggian Minimum adalah : Hmin = INT(2log N) + 1 = INT(2log 8) + 1 = INT(2log 23) + 1 = INT(3) + 1 =3+1 =4 Ketinggian Maksimum adalah : 8

PENYAJIAN POHON BINAR DALAM MEMORI

Penyajian pohon binar dalam memori dengan dua cara, yaitu : 1. Penyajian Kait (link) 2. Penyajian Sequential. 1. PENYAJIAN KAIT Kalau tidak dinyatakan lain, suatu pohon binar T akan disimpan dalam memori secara penyajian kait. Penyajian ini menggunakan tiga array sejajar INFO, LEFT dan RIGHT, serta variabel penuding ROOT. Masing-masing simpul N dari pohon T berkorespondensi dengan suatu lokasi K, sedemikan sehingga : (1) INFO(K) berisi data pada simpul N. (2) LEFT(K) berisi lokasi dari anak kiri simpul N. (3) RIGHT(K) berisi lokasi dari anak kanan simpul N.

Contoh : Pohon Binar T A

B

C

D

E

G

H

F

J

K

L Skema Penyajian Kait dari pohon binar T Root • • A •

B

C

x

D

x

E

x

x

G

x

H

x

F

x

J

x

x

K

x

x

L

x

Root 2

Avail 10 INFO 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 LEFT L A G C B F J E RIGHT 0 7 8 0 4 13 16 6 0 3 1 9 15 19 18 0 11 14 0 0

0 5 0 17 12 0 0 0

D H

0 20

K

0

2. PENYAJIAN SEQUENTIAL Penyajian pada pohon binar T ini hanya menggunakan sebuah array linear tunggal TREE sebagai berikut : 1. Akar R dari pohon T tersimpan sebagai TREE[1] 2. Jika simpul N menduduki TREE[K] maka anak kirinya tersimpan dalam TREE[2*K] dan anak kanannya dalam TREE[2*K+1] Contoh : 45

22

77

11

30

90

15

25

88

TREE 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 . . . 29 Dapat dilihat bahwa penyajian membutuhkan 14 lokasi dalam array TREE, meskipun T hanya mempunyai 9 simpul. Kenyataannya, bila kita memasukkan elemen nol sebagai suksesor dari simpul terminal, dibutuhkan TREE[29] untuk suksesor kanan dari TREE[14]. 45 22 77 11 30 90 15 25

88

PENYAJIAN POHON UMUM SECARA POHON BINAR

Kita dapat menyajikan pohon umum secara pohon binar dengan algoritma sebagai berikut : 1. Tambahkan ruas baru yang menghubungkan 2 simpul bersaudara yang berdampingan, lalu kita hapus ruas dari simpul ayah ke anak, kecuali ruas ke simpul anak paling kiri. 2. Rotasikan sebesar 45° , searah putaran jarum jam terhadap pohon hasil langkah pertama.

Contoh Pohon Umum A

B

C

D

E

F

G

H

I

J

K Langkah Pertama A

L

B

C

D

E

F

G

H

I

J

K Langkah kedua A

L

B

E

C

F

D

G

H

K

I

L

J

NOTASI PREFIX, INFIX DAN POSTFIX SERTA TRAVERSAL POHON Traversal adalah proses kunjungan dalam pohon, dengan setiap Simpul hanya dikunjungi tepat satu kali. Tiga kegiatan yang terdapat dalam traversal pohon binar adalah : 1. Mengunjungi simpul akar (root) 2. Melakukan traversal subpohon kiri, dan 3. Melakukan traversal subpohon kanan Terdapat tiga macam traversal pohon, yaitu : 1. Traversal Pre-order, dilakukan berturut-turut : a. Kunjungi simpul akar b. Lakukan traversal subpohon kiri c. Lakukukan traversal subpohon kanan 2. Traversal In-order, dilakukan berturut-turut : a. Lakukan traversal subpohon kiri b. Kunjungi simpul akar c. Lakukan traversal subpohon kanan 3. Traversal Post-order, dilakukan berturut-turut : a. Lakukan traversal subpohon kiri b. Lakukan traversal subpohon kanan c. Kunjungi simpul akar Contoh : F Untai yang dihasilkan secara Pre-order FDBACEG

D

G

B

E

A

C

F

Untai yang dihasilkan secara In-order ABCDEFG

D

G

B

E

A

C F Untai yang dihasilkan secara Post-order ACBEDGF D G

B

E

A

C

POHON CARI BINAR Pandang T suatu pohon binar, maka T disebut pohon cari binar (pohon terurut binar) bila masing-masing simpul N dari T mempunyai sifat : Nilai dari N selalu lebih besar dari setiap nilai simpul pada subpohon kiri dari N, dan selalu lebih kecil dari setiap nilai simpul pada subpohon kanan dari N. Definisi di atas menjamin bahwa traversal in-order terhadap pohon cari binar selalu menghasilkan untai terurut. Contoh : 38

14

56

8

23

45

82

18 72 Dicatat bahwa dalam definisi Pohon Cari Binar di atas, semua nilai/label simpul adalah berbeda. Kalau diijinkan terjadi adanya label yang sama, dapat dilakukan sedikit modifikasi.

Definisi Pohon Cari Binar menjadi : Bila N adalah simpul dari Pohon maka nilai semua simpul pada subpohon kiri dari N adalah lebih kecil atau sama dengan nilai simpul N, dan nilai semua simpul pada subpohon kanan dari N adalah lebih besar dari nilai simpul N. Contoh : Hari

Cahyo

Lilik

Budi

Gita

Kurdi

Rudi

Daud

Ely

Dewi

Dewi

Badu

Cokro

Ali

Cokro

Badu

Ali (a) (b)

Ali

Cokro

Badu

Badu

Ali

Dewi

Ali

Dewi

Cokro

Badu

Cokro

Dewi (c) (d) (e)

Buatlah 10 pohon cari binar yang berbeda dari (a, b, c, d, e) di atas!

CARI DAN PENYISIPAN SIMPUL POHON CARI BINAR Pandang bahwa diberikan sebuah ITEM informasi. Algoritma di bawah ini akan menemukan lokasi dari ITEM dalam Pohon Cari Binar T, atau menyelipkan ITEM dalam Pohon Cari Binar T, atau menyelipkan ITEM sebagai simpul baru dari T dalam posisi yang tepat.

ALGORITMA Algoritma bekerja sebagai berikut : (a) Bandingkan ITEM dengan simpul akar N dari Pohon, jika ITEM < N, proses subpohon kiri dari N, jika ITEM > N proses subpohon kanan dari N. (b) Ulangi langkah (a) sampai dari hal berikut ditemui : (1) Ditemukan simpul n sedemikian sehingga ITEM = N, dalam hal ini pencarian berhasil. (2) Dijumpai subpohon hampa, ini menunjukkan bahwa pencarian tidak berhasil, dan kita selipkan ITEM mengisi subpohon yang hampa tadi. Contoh : Misalkan diberikan ITEM = 20. 38

14

56

8

23

45

82

18

72

20

PENGHAPUSAN SIMPUL POHON CARI BINAR Operasi penghapusan suatu simpul dari Pohon Cari Binar bukan merupakan hal yang mudah. Pertama-tama kita harus tetapkan lebih dahulu simpul yang akan kita hapus, bila merupakan simpul daun, maka proses akan berlangsung dengan mudah, karena simpul daun tersebut akan dapat langsung kita hapuskan dari Pohon Cari yang bersangkutan. Jika simpul yang akan dihapuskan mempunyai sebuah subpohon kanan, maka untuk menggantikan posisi simul yang dihapuskan tersebut, kita ambil simpul akar subpohon kiri dan sebaliknya. Jika simpul yang akan dihapuskan mempunyai dua buah subpohon yaitu subpohon kiri dan subpohon kanan, maka untuk menggantikan posisi dari simpul yang dihapuskan tersebut, kita tentukan simpul dari salah satu subpohon kiri atau subpohon kanan sedemikian sehingga bangun pohon yang terbentuk kembali, memenuhi sifat sebagai Pohon Cari Binar. PROSEDUR untuk penghapusan suatu simpul dari Pohon Cari Binar (1) (2) Jika Pohon Hampa, maka penghapusan yang dilakukan gagal. Berhenti. Jika n < Ro (akar), subpohon kiri dari Ri diselidiki sampai ditemukan simpul yang telah ditentukan untuk dihapus.

(3) (4) (5)

(6)

(7)

Jika n > Ro, maka subpohon kanan dari Ri diselidiki sampai ditemukan simpul yang telah ditentukan untuk dihapus. Jika n = Ro, subpohon kiri dan subpohon kanan hampa, maka hapus Ro. Jika n = Ro, dan subpohon kirinya hampa, maka hapus Ro, kemudian ambil akar dari subpohon kanan untuk menggantikan posisi Ro. Pohon baru akan memenuhi sifat sebagai Pohon Cari lagi. Jika n = Ro, dan subpohon kanannya hampa, maka hapus Ro, kemudian ambil akar dari subpohon kiri untuk menggantikan posisi Ro. Pohon baru akan memenuhi sifat sebagai Pohon Cari lagi. Jika n = Ro, subpohon kanan dan subpohon kiri tidak hampa, maka untuk menggantikan posisi Ro yang dihapus, kita tentukan suatu simpul mungkin dari subpohon kiri atau mungkin dari subpohon kanan, sedemikian sehingga Pohon yang terbentuk kembali memenuhi sifat sebagai Pohon Cari lagi. 38

Pohon Cari Binar

15

56

8

23

45

82

19

72

20 1. Dari pohon cari binar di atas, lakukan penghapusan simpul 56! 2. Dari pohon cari binar di atas, lakukan penghapusan berturut-turut terhadap simpul 45, 23 dan 56! 3. Bila diketahui data : 44, 55, 12, 42, 94, 18, 7, 67 Buatlah pohon cari binar dari data di atas! Cari dan sisipkan : 38 terhadap pohon cari binar yang terbentuk! HEAP Suatu pohon binar adalah Heap, jika nilai setiap simpul lebih besar atau sama dengan nilai anaknya, disebut Maxheap. Kalau nilai setiap simpul lebih kecil atau sama dengan nilai anaknya, disebut Minheap.

Contoh : 95

87

92

76

72

83

85

58

54

62

69

73

65

Kita dapat memasukkan elemen baru ke dalam sebuah Heap. Misalkan elemen = 93. Mulamula elemen tersebut diletakkan sebagai elemen terakhir dari heap, yaitu elemen tree[14] pada daftar berurutan. Selanjutnya memerika apakah elemen tersebut lebih besar dari ayahnya. Bila lebih besar, lakukan pertukaran, elemen tersebut sekarang menjadi ayah. Demikian seterusnya sampai kondisi ini tidak tercapai. 95

88

92

76

72

83

85

58

54

62

69

73

65

93

95

89

92

76

72

83

93

58

54

62

69

73

65

85

Sehingga heap yang terbentuk :

95

90

93

76

72

83

92

58

54

62

69

73

65

85

Kemudian lakukan heapsort! Algoritma heapsort : 1. Jatuhkan root ke posisi terakhir dari simpul dalam urutan almost complete. (Pertukarkan antara root dengan simpul terakhir dari urutan almost complete. Data pada simpul terakhir sudah terurut) 2. Sisanya bentuk heap kembali, kemudian lakukan sort kembali. Buatlah maxheap dari data berikut ini : 45, 22, 77, 11, 30, 90, 15, 25, 88. Tambahkan 35 ke dalam maxheap tersebut, kemudian lakukan heapsort!

BAB 8 & 9 SEARCHING & SORTING

Pendahuluan Sorting dan searching merupakan salah satu operasi dasar dalam ilmu komputer. Sorting merupakan suatu proses (operasi) yang mengurutkan data dalam suatu urutan yang diberikan (increasing atau decreasing). Searching merupakan suatu proses (operasi) untuk mencari lokasi dari data yang diberikan dalam suatu urutan data. Secara tidak langsung sorting dan searching menunjuk pada operasi file yang merupakan kumpulan suatu dari record. Masing-masing record dalam file F dapat berisi banyak field, tetapi terdapat 1 buah field yang memiliki nilai unique atau merupakan key yang unique dalam record tersebut. Misal field K merupakan key unique yang disebut primary key, maka proses sorting file F akan berdasarkan key unique tersebut dan proses searching untuk mencari record tertentu berdasarkan nilai key unique yang diberikan. Sorting Terdapat 2 katagori dasar dalam tehnik sorting : internal sort dan external sort. Metoda Internal sort digunakan apabila koleksi data yang akan diurutkan tidak dalam jumlah besar sehingga proses dapat dilakukan dalam main memory. Metoda External sort

digunakan apabila koleksi data yang akan diurutkan dalam jumlah besar dimana koleksi data tersebut ada dalam auxiliary memory device seperti magnetic tape atau disk. (Yang akan di bahas adalah Internal Sort). Misal A merupakan suatu daftar dari n elemen A1, A2, ..., An dalam memori. Sorting A merupakan operasi yang mengatur elemen dalam A sehingga ada dalam urutan yang terurut, misal dalam increasing order sehingga : A1 ≤ A2 ≤ A3 ≤ ..... ≤ An Contoh : Misal suatu array DATA berisi 8 elemen sebagai berikut : DATA : Setelah diurutkan : DATA : 11, 22, 33, 44, 55, 66, 77, 88 77, 33, 44, 11, 88, 22, 66, 55

Insertion Sort Misal array A dengan n elemen A[1], A[2], ..... , A[N] dalam memori. Algoritma Insertion Sort memeriksa A dari A[1] sampai dengan A[N], menyisipkan setiap elemen A[K] ke dalam posisi yang seharusnya dalam subarray terurut A[1], A[2], ..... , A[K-1]. Algoritma sorting ini umumnya digunakan apabila jumlah elemennya sedikit (n kecil). Masalah yang akan muncul dengan metoda ini adalah bagaimana cara menyisipkan A[K] ke dalam letak yang seharusnya pada subarray terurut A[1], A[2], ....., A[K-1]. Hal ini dapat dilakukan dengan membandingkan A[K] dengan A[K-1], kemudian A[K] dengan A[K-2], A[K] dengan A[K-3] dan seterusnya, sampai menemukan elemen A[J] dimana A[J] ≤ A[K]. Algoritma ini menggunakan sentinel elemen (A[0]) yang digunakan sebagai perbandingan. Yang dimaksud dengan sentinel elemen adalah elemen yang memiliki nilai yang sangat kecil. Penggambaran proses Insertion Sort : Proses K = 1: K = 2: K = 3: K = 4: K = 5: K = 6: K = 7: A[0] -∞ -∞ -∞ -∞ -∞ -∞ -∞ A[1] 77 77 33 33 11 11 11 A[2] 33 33 77 44 33 33 22 A[3] 44 44 44 77 44 44 33 A[4] 11 11 11 11 77 77 44 A[5] 88 88 88 88 88 88 77 A[6] 22 22 22 22 22 22 88 A[7] 66 66 66 66 66 66 66 A[8] 55 55 55 55 55 55 55

K = 8: Urutan :

-∞ -∞

11 11

22 22

33 33

44 44

66 55

77 66

88 77

55 88

Tabel 1.1 Contoh : Array A dengan 8 elemen sebagai berikut : 77, 33, 44, 11, 88, 22, 66, 55 Tabel 1.1 menggambarkan algoritma insertion sort. Elemen yang dilingkari menandakan A[K] dalam masing-masing proses dari algoritma, dan tanda panah menandakan letak yang seharusnya untuk menyisipkan A[K]. Algoritma Insertion Sort : 1. A[0] = 0 {sentinel elemen} 2. Repeat langkah 3 sampai 5 untuk K = 2,3,.....,N 3. Temp := A[K] ; PTR = K - 1 4. Repeat While Temp < A[PTR] a. A[PTR+1] = A[PTR] b. PTR = PTR - 1 [End Of Loop] 5. A[PTR+1] = Temp [End Loop Langkah 2] 6. Return Complexity Insertion Sort = O(n2) Selection Sort Array A dengan n elemen A[1], A[2], ....., A[N] dalam memori. Algoritma untuk mengurutkan A sebagai berikut : Pertama, cari elemen terkecil dalam array A dan letakkan pada posisi pertama dalam array tersebut. Kemudian cari elemen kedua terkecil dalam array A dan letakkan dalam posisi kedua dari array tersebut, dan begitu seterusnya. Proses 1 : Cari lokasi LOC yang merupakan elemen terkecil dalam array yang terdiri dari N elemen , A[1], A[2], ...., A[N] dan kemudian tukar posisi A[LOC] dengan A[1]. Cari lokasi LOC yang merupakan elemen terkecil dalam array yang terdiri dari N-1 elemen , A[2], A[3], ...., A[N] dan tukar posisi A[LOC] dengan A[2]. A[1] , A[2] terurut, jika dan hanya jika A[1] ≤ A[2].

Proses 2 :

Proses 3 :

Cari lokasi LOC yang merupakan elemen terkecil dalam array yang terdiri dari N-2 elemen, A[3], A[4],......, A[N] dan tukar posisi A[LOC] dengan A[3]. A[1], A[2], A[3] terurut, jika dan hanya jika A[2] ≤ A[3]. Dst................. Sehingga A akan terurut setelah N-1 proses.

Contoh ; Array A dengan 8 elemen sbb : 77, 33, 44, 11, 88, 22, 66, 55

Proses algoritma digambarkan dalam Tabel 1.2. Misalkan LOC berisi nilai lokasi elemen terkecil A[K], A[K+1],...,A[N] selama proses K. Elemen yang dilingkari merupakan elemen yang akan ditukar posisinya.

Proses K = 1 ; LOC = 4 K = 2 ; LOC = 6 K = 3 ; LOC = 6 K = 4 ; LOC = 6 K = 5 ; LOC = 8 K = 6 ; LOC = 7 K = 7 ; LOC = 7 Urutan :

A[1] 77 11 11 11 11 11 11 11

A[2] 33 33 22 22 22 22 22 22

A[3] 44 44 44 33 33 33 33 33

A[4] 11 11 77 77 44 44 44 44 Tabel 1.2

A[5] 88 88 88 88 88 55 55 55

A[6] 22 22 33 44 77 77 66 66

A[7] 66 66 66 66 66 66 77 77

A[8] 55 55 55 55 55 88 88 88

Algoritma : Procedure SELECTION (A, N) 1. Repeat langkah 2 dan 3 untuk K = 1,2,.....,N-1 2. Call MIN(A, K, N, LOC) 3. Temp = A[K] ; A[K] = A[LOC] ; A[LOC] = Temp [End Loop langkah 1] 4. Exit Procedure MIN (A,K,N,LOC) 1. Min = A[K] ; LOC = K 2. Repeat For J = K+1, K+2, ......, N If Min > A[J] Then Min = A[J] ; LOC = A[J] ; LOC = J [End Loop] 3. Return Complexity (kompleksitas) algoritma Selection Sort : O(n2) Merging Misal A merupakan himpunan data terurut dengan r buah elemen dan B himpunan data terurut dengan s buah elemen. Proses yang menggabungkan elemen-elemen dalam A dan B menjadi himpunan elemen data terurut tunggal, misal C dengan n = r + s buah elemen disebut dengan proses Merging.

Secara singkat, proses Merging dapat dijelaskan sebagai berikut ; ambil elemen pertama dari A, A[1] dan B, B[1]. Bandingkan kedua elemen tersebut. Jika A[1] > B[1], B[1] dimasukkan dalam C, jika tidak A[1] dimasukkan dalam C. Untuk himpunan data yang elemennya dimasukkan dalam C, elemen yang akan dibandingkan adalah elemen berikutnya. Dan seterusnya. Contoh : A = 11 12 23 33 45 B = 9 12 21 42

67

Disini A[1] = 11 dan B[1] = 9 dibandingkan dan A[1] > B[1], B[1] dimasukkan dalam C. Pembandingan berikutnya A[1] = 11 dibandingkan dengan B[2] = 12, A[1] dimasukkan dalam C, dan begitu seterusnya.

Algoritma MERGING : 1. NA = 1 ; NB = 1 dan PTR = 1 2. Repeat While NA ≤ R and NB ≤ S If A[NA] < B[NB] then a. C[PTR] = A[NA] b. PTR = PTR + 1 ; NA = NA + 1 Else a. C[PTR] = B[NB] b. PTR = PTR + 1 ; NB = NB + 1 [End If Structure] [End Loop] 3. If NA > R then Repeat For k = 0,1,2,3,.....,S-NB C[PTR+K] = B[NB+K] [End loop] Else Repeat for K = 0,1,2,3,.....,R-NA C[PTR+K] = A[NA+K] [End loop] [End If Structure] 4. Exit Kompleksitas algoritma Merging = O(n). Dengan kata lain algoritma Merging dapat dijalankan dalam waktu yang linear. Merge Sort Misal : Array A dangan n elemen A[1], A[2], ....., A[N] dalam memori. Algoritma Merge Sort yang akan mengurutkan A akan digambarkan sebagai berikut : Contoh : Array A berisi 6 elemen sbb : 15 12 45 56

13

10

Masing-masing proses dalam algoritma merge sort akan dimulai dari elemen awal dalam A dan menggabungkan (merge) pasangan subarray yang terurut sbb :

15

12

45

56

13

10

12 15

45

56

1013 10 13 56

12 15 45 56

10 12 13 15 45

Kompleksitas dari proses merge-sort = O(n). Tournament Sort Tournament Sort disebut juga dengan Tree Selection Sort. Misal terdapat elemen data sebagai berikut : 6, 25, 7, 2, 14, 10, 9, 22, 3, 14, 8, 12, 1, 30, 13. Asumsikan bahwa batasan proses dalam memori hanya 4 buah elemen setiap saatnya. Algoritma Tournament Sort membagi 4 elemen tersebut menjadi 2 pasangan elemen sbb : 6 25 7 2 Asumsikan bahwa data tersebut akan diurutkan secara ascending, sehingga elemen terkecil pada masing-masing pasangan di atas adalah 2 dan 6. 6 25 7 2 6

2

2 adalah elemen terkecil dan merupakan elemen pertama pada output dari urutan yang diurutkan. 6 6 25 2 2 7 2 2 Proses yang berikutnya akan ditentukan elemen kedua dalam list terurut. 2 tidak diikutsertakan kembali. 6 25 7 * Proses selanjutnya : 6 6 7 2, 6

6 25 7 14

6 6 7 2, 6

Proses ketiga : 10 25 7 14 Proses keempat : 10 25 9 14 Proses kelima : 10 25 22 14 10 10 14 2, 6, 7, 9, 10 10 9 9 2, 6, 7, 9 10 7 7 2, 6, 7

Pada proses keenam elemen 3 dimasukkan dalam tree : 3 25 22 14 14

Apabila 3 diikutkan dalam proses, maka urutan list terurut pada output akan berantakan. Untuk mengatasinya, terdapat aturan sbb : If Keynew < Keylastout then keynew diletakkan dalam tree tetapi untuk sementara waktu didiskualifikasikan. Catatan : Keylastout adalah key terakhir yang ada dalam list terurut. Elemen yang didiskualifikasikan akan ditandai dengan asterisk (*). Sehingga hasil dari proses enam adalah : *3 25 25 14 2, 6, 7, 9, 10, 14

22 14

14

Pada proses ketujuh, elemen berikutnya adalah 14. Karena elemen terakhir dalam list terurut tidak lebih kecil dari elemen yang akan dimasukkan, yakni 14, maka elemen 14 masuk dalam list terurut. *3 25 25 14 2, 6, 7, 9, 10, 14, 14 22 14 14 Proses kedelapan, elemen berikutnya 8 dan elemen ini untuk sementara akan didiskualifikasi karena 8 < dari elemen terakhir dalam list terurut yakni 14. *3 25 25 22 2, 6, 7, 9, 10, 14, 14, 22 22 22 *8 Proses kesembilan : *3 25 *12 *8 25 25 * 2, 6, 7, 9, 10, 14, 14, 22, 25

Proses kesepuluh, elemen berikutnya 1 : *3 *1 *12 *8 Sekarang semua elemen yang ada adalah elemen yang didiskualifikasikan. Dan saat ini baru 9 elemen yang diurutkan. Sekarang elemen yang untuk sementara didiskualifikasikan, dilepaskan dari diskualifikasi dan proses dimulai kembali. Kali ini akan terbentuk list terurut kedua dari elemen-elemen yang didiskualifikasi sebelumnya. Sehingga proses 10 :

3 1 12 8 Proses 11, elemen 30 : 3 30

1 1 8 2, 6, 7, 9, 10, 14, 14, 22, 25 1

3

3 12 8 Proses 12 : 13 30 12 8 13 8 8 8

2, 6, 7, 9, 10, 14, 14, 22, 25 1, 3

2, 6, 7, 9, 10, 14, 14, 22, 25 1, 3, 8

Sekarang input list kosong. Sehingga proses 13 : 13 30 13

12 2, 6, 7, 9, 10, 14, 14, 22, 25 12 12 1, 3, 8, 12 * Proses 14 dan 15 tidak terdapat elemen yang dimasukkan dalam tree. Hasil akhir dari proses tournament sort ini menghasilkan 2 himpunan elemen data yang terurut : 2, 6, 7, 9, 10, 14, 14, 22, 25 1, 3, 8, 12, 13, 30 Kedua himpunan data yang terurut tersebut dapat digabungkan menjadi satu list data terurut dengan menggunakan algoritma Merging. Shell Sort Disebut juga dengan metoda pertambahan menurun (diminishing increment). Metoda ini dikembangkan oleh Donald L. Shell tahun 1959. Metoda ini memanfaatkan penukaran sepasang elemen untuk mencapai keadaan urut. Dalam hal ini jarak dua elemen yang dibandingkan dan ditukarkan tertentu. Pada langkah pertama, ambil elemen pertama dan kita bandingkan dengan elemen pada jarak tertentu dari elemen pertama tersebut. Kemudian elemen kedua dibandingkan dengan elemen lain dengan jarak yang sama. Demikian seterusnya sampai seluruh elemen dibandingkan. Pada contoh berikut, proses pertama kali jarak diambil separoh banyaknya elemen yang akan diurutkan. Proses kedua jaraknya diambil separuh jarak yang pertama, dst.... Misal terdapat elemen sebagai berikut : 23 45 12 24 56 34 27 23 16

Proses pengurutan menggunakan metoda Shell ada pada tabel 1.3. Dalam hal ini elemen yang ditulis miring adalah elemen yang dibandingkan dan kemudian ditukar, jika perlu.

Jarak Awal Jarak = 4

A[1] 23 23 23 23 23 23 23 23 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12

A[2] 45 45 45 34 34 34 34 34 34 23 23 23 23 23 23 23 23 16 16 16 16 16 16 16 16

A[3] 12 12 12 12 12 12 12 12 23 23 16 16 16 16 16 16 16 23 23 23 23 23 23 23 23

A[4] 24 24 24 24 24 23 23 23 23 34 34 34 34 34 34 34 34 34 34 23 23 23 23 23 23

A[5] 56 56 56 56 56 56 16 16 16 16 23 23 23 23 23 23 23 23 23 34 24 24 24 24 24

A[6] 34 34 34 45 45 45 45 45 45 45 45 45 45 24 24 24 24 24 24 24 34 27 27 27 27

A[7] 27 27 27 27 27 27 27 27 27 27 27 27 27 27 27 27 27 27 27 27 27 34 34 34 34

A[8] 23 23 23 23 23 24 24 24 24 24 24 24 24 45 45 45 45 45 45 45 45 45 45 45 45

A[9] 16 16 16 16 16 16 56 56 56 56 56 56 56 56 56 56 56 56 56 56 56 56 56 56 56

Jarak = 2

Jarak = 1

Akhir Searching

Pencarian data sering disebut juga dengan istilah table look-up atau storage and retrieval information, adalah suatu proses untuk mengumpulkan sejumlah informasi di dalam pengingat komputer dan kemudian mencari kembali informasi yang diperlukan.

Sequential Searching Metoda yang paling sederhana dari sejumlah metoda pencarian adalah metoda pencarian berurutan (sequential searching). Secara singkat metoda ini dapat dijelaskan sebagai berikut : Dari elemen-elemen yang diketahui, data yang dicari dibandingkan satu persatu sampai data tersebut ditemukan atau tidak ditemukan. Algoritma Sequential Searching : 1. Baca himpunan data yang diketahui, misalnya sebagai himpunan A dengan N elemen. 2. Baca data yang dicari, misal Data 3. Ada = False

4. For I = 1 to N proses langkah 5 5. If Data = A[I] then Ada = True ; Posisi = I ; I = N 6. If Ada = False Then N = N+1 ; A[I] = Data 7. Selesai Skema Move To The Front Pada skema pencarian sekuensial move to the front, apabila proses pencarian berhasil, maka record tersebut dipindahkan pada posisi pertama dari daftar tersebut. Record pertama menjadi record kedua dan seterusnya. Metoda move to the front ini, prosesnya lebih baik apabila menggunakan linked list dibandingkan dengan array. (cari alasannya, mengapa !) Skema Transposition Pada skema pencarian sekuensial transposition, apabila prose pencarian berhasil, maka record tersebut dipindahkan pada posisi berikutnya. Kedua skema di atas (move to the front dan transposition) didasarkan pada kemungkinan proses pencarian apabila elemen data yang di cari akan digunakan dan dicari kembali. (Cari kelebihan dan kekurangan kedua skema di atas dengan penggambaran secara linked list dan array !)

You're Reading a Free Preview

Download
scribd
/*********** DO NOT ALTER ANYTHING BELOW THIS LINE ! ************/ var s_code=s.t();if(s_code)document.write(s_code)//-->