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

1. Tunggal : Integer, Real, Boolean, Karakter

2. Majemuk : String

• 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, Tree,
G

§ 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 Operator
Jumlah karakter dalam string LENGTH
Gabungan 2 buah string CONCAT
Sub bagian dari string SUBSTR
Menyisipkan string ke dalam string yang lain INSERT
Menghapus karakter dalam string 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 & TWO’S ONE’S

INTEGER MAGNITUDE COMPLEMENT COMPLEMENT

-7 -111 1001 1000
-6 -110 1010 1001
-5 -101 1011 1010
-4 -100 1100 1011
-3 -011 1101 1100
-2 -010 1110 1101
-1 -001 1111 1110
0 000 0000 0000
1 001 0001 0001
2 010 0010 0010
3 011 0011 0011
4 100 0100 0100
5 101 0101 0101
6 110 0110 0110
7 111 0111 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 PTR1S 7
STRING2 PTR2S 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 START TERM

STRING1 PTR1S PTR1T
STRING2 PTR2S PTR2T

Format penyimpanannya dapat berupa :

ABCDEFGBCD atau ABCDEFG

PTR1T PTR2T PTR2T PTR1T

PTR2S
PTR1S PTR2S PTR1S
m CARA 3
Menggunakan tabel informasi :
- nama string (NAME)
- alamat awal (START)
- suatu tanda yang menunjukkan batas string

NAME START
STRING1 PTR1S
STRING2 PTR2S

Penyimpanannya :

ABCDEFG#BCD#
 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 2 3 ... N
L2 U2
L1 1
2

.
 U1

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 2 3 ... 100
L2 U2
L1 1

A C A
2

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 : Alamat awal dari A(4) ® I = 4

A(2:6) B + (I – L) * S
2 3 4 5 6 B + (4 – 2) * S = B + 2 * S
25 20 10 15 12

DIMENSI DUA

Memori komputer adalah linier.

Contoh : AA(1:4, 1:6)

L2 U2
1 2 3 4 5 6
L1 1
2
AA(2,4)
 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 5 6 1 2 3 4 5 6 1 2 3 4 5 6 1 2 3 4 5 6

Baris 1 2 3 4

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 4 1 2 3 4 1 2 3 4 1 2 3 4 1 2 3 4

Kolom 1 2 3 4 5 6

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 1 2 0 3
A= 3 4 5 AT = 1 4
2 5

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

A(1,2) = AT(2,1) A(2,2) = AT(2,2)
A(1,3) = AT(3,1) 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 x x x x x x 0 0 0 0 0
0 x x x x x x x 0 0 0 0
0 0 x x x x x x x 0 0 0
0 0 0 x x x x x x x 0 0
0 0 0 0 x x x x x x x 0
0 0 0 0 0 x x x x x 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/2 N(N + 1)
I=1

Upper Triangular T disimpan secara baris dalam array dim-1, S.

T(1,1) Õ S(1) T(2,2) Õ S(n+1)

T(1,2) Õ S(2)
. .
. .
. .
T(1,n) Õ S(n) 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 2 3 7 0

A= 0 4 5 B= 8 9

0 0 6

maka akan disimpan di C : 3 x 3

1 2 3

C= 7 4 5

8 9 6

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
1 2 3 7 0 0
A= 0 4 5 B= 8 9 0
0 0 6 11 12 13

7 1 2 3

C= 8 9 4 5

11 12 13 6

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

1 0 0 0 0 1 0 0 2 0 0
2 0 1 0 0 0 0 0 0 0 0
3 1 0 0 0 0 0 0 0 0 0
4 0 0 0 0 0 0 0 0 0 0
5 0 0 0 4 0 0 0 0 0 0
6 0 0 0 0 0 0 0 2 0 0
7 0 0 0 0 0 0 0 0 0 0
8 2 1 0 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 Kolom Nilai

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

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 S Keterangan :
·
· STACK S
 · TOP-PTR : subskrip dari elemen TOP(S) dari stack.
1

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 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
yang ( ( A + B ) * C / D + E ^ F ) / G ;
diamati
TOP dari + + ^ ^

STACK
 ( ( ( ( * * / / + + + +

( ( ( ( ( ( ( ( ( ( ( ( ( ( / /
OUTPUT A B + C * D / E F ^+ G /

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
 • · FREE STORAGE LIST

ITEM • · • · • · … 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. INFO[NEW] := ITEM. [Menyalin data baru ke dalam simpul baru.]

2. LINK[NEW] := START. [Simpul baru sekarang menuding ke simpul semula.]
3. START := NEW. [Mengubah START agar menuding ke simpul yang baru.]
4. 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. Karena AVAIL <> NULL, ke langkah 2.

2. NEW = 9, maka AVAIL = LINK[9] = 10.
3. TEST[9] = 75.
4. LINK[9] = 5.
5. GEOM = 9.
6. 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 LINK
1 16
2 74 14
3 1
ALG 11 4 82 0
5 84 12
6 78 0
7 74 8
GEOM 9 8 100 13
9 75 5
10 3
11 88 2
12 62 7
AVAIL 10 13 74 6
14 93 4
15 0
16 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. [List hampa?] Jika START = NULL, maka LOC := NULL, dan Return.
2. [Kasus khusus?] Jika ITEM < INFO[START], maka LOC := NULL, dan Return.
3. SAVE := START dan PTR := LINK[START]. [Mengawali Penuding]
4. 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 LINK
START 5 1 Kirk 7
2 6
3 Dean 11
4 Maxwell 12
5 Adams 3
AVAIL 2 6 0
7 Lane 4
8 Green 10
9 Samuels 0
10 Jones 1
11 Fields 8
12 Nelson 9

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.
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 LINK
START 5 1 Kirk 7
2 6
3 Dean 11
4 Maxwell 12
5 Adams 3
AVAIL 8 6 0
7 Lane 4
8 2
Samuels 0
 10 Jones 1
11 Fields 10
12 Nelson 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
• · • · • ·

• · • · • · • · • · x

Node N

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) e3 = (A, D)
e4 = (C, D) e5 = (B, D)

A e3 D

• •

e1 e5 e4

• •
B e2 C

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) e3 = (A, D)
e4 = (C, D) e5 = (B, C) e6 = (B, C)
 A e2 e3 D

• •

e1 e4
e5
• •
B e6 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 e5 D

G • •

e1 e3 e4

• •
B e2 C

A D

G’ • • G’ subgraf dari G
(namun bukan dibentuk
oleh V’ = {A,B,D})
e1 e3
•
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 B F

G • • •

• • • 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 v4 v5
• • •
e4 e8

e1 e2 e6 e7

• •
v2 e3 v3
Matriks Ruas

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

Matriks Adjacency : N x N

v1 v2 v3 v4 v5

v1 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 e2 e3 e4 e5 e6 e7 e8

v1 1 1 0 1 1 0 0 0
v2 1 0 1 0 0 0 0 0
v3 0 1 1 0 0 1 1 0
v4 0 0 0 1 0 1 0 1
v5 0 0 0 0 1 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

Q T

R U
S

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

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

A S 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 C B C

HBT
E D

F Bukan HBT
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

B C

D E G H

F J K

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 Avail

2 10 INFO LEFT RIGHT

1 L 0 0
2 A 7 5
3 8
4 G 0 0
5 C 4 17
6 13
7 B 16 12
8 6
9 F 0 0
10 3
11 J 1 0
12 E 9 0
13 15
14 19
15 18
16 D 0 0
17 H 11 20
18 14
19 0
20 K 0 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 45
2 22
3 77
4 11
5 30
6
7 90
8
9 15
10 25
11
12
13
14 88
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].

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 L

Langkah Pertama
A

B C D

E F G H I J

K L
Langkah kedua
A

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) Jika Pohon Hampa, maka penghapusan yang dilakukan gagal. Berhenti.
(2) Jika n < Ro (akar), subpohon kiri dari Ri diselidiki sampai ditemukan simpul yang telah
ditentukan untuk dihapus.
(3) Jika n > Ro, maka subpohon kanan dari Ri diselidiki sampai ditemukan simpul yang
telah ditentukan untuk dihapus.
(4) Jika n = Ro, subpohon kiri dan subpohon kanan hampa, maka hapus Ro.
(5) 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.
(6) 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.
(7) 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.

Pohon Cari Binar

38

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. Mula-
mula 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 : 77, 33, 44, 11, 88, 22, 66, 55

Setelah diurutkan :

DATA : 11, 22, 33, 44, 55, 66, 77, 88

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 A[0] A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8]

K = 1: -∞ 77 33 44 11 88 22 66 55

K = 2: -∞ 77 33 44 11 88 22 66 55

K = 3: -∞ 33 77 44 11 88 22 66 55

K = 4: -∞ 33 44 77 11 88 22 66 55

K = 5: -∞ 11 33 44 77 88 22 66 55

K = 6: -∞ 11 33 44 77 88 22 66 55

K = 7: -∞ 11 22 33 44 77 88 66 55
 K = 8: -∞ 11 22 33 44 66 77 88 55

Urutan : -∞ 11 22 33 44 55 66 77 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].

Proses 2 : 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 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 A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8]

K = 1 ; LOC = 4 77 33 44 11 88 22 66 55

K = 2 ; LOC = 6 11 33 44 11 88 22 66 55

K = 3 ; LOC = 6 11 22 44 77 88 33 66 55

K = 4 ; LOC = 6 11 22 33 77 88 44 66 55

K = 5 ; LOC = 8 11 22 33 44 88 77 66 55

K = 6 ; LOC = 7 11 22 33 44 55 77 66 88

K = 7 ; LOC = 7 11 22 33 44 55 66 77 88

Urutan : 11 22 33 44 55 66 77 88

Tabel 1.2

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 67
B = 9 12 21 42

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

12 15 45 56 10 13

10 12 13 15 45 56

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

7 2
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 6
25
6 2, 6
7 7
*

Proses selanjutnya :
 6 6
25
6 2, 6
7 7
14

Proses ketiga :

10 10
25
7 2, 6, 7
7 7
14

Proses keempat :

10 10
25
9 2, 6, 7, 9
9 9
14

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

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

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
25
25 2, 6, 7, 9, 10, 14, 14, 22, 25
*12 *
*8

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
1
1 2, 6, 7, 9, 10, 14, 14, 22, 25
12 8 1
8

Proses 11, elemen 30 :

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

Proses 12 :

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

Sekarang input list kosong. Sehingga proses 13 :

13 13
30
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 A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8] A[9]

Awal 23 45 12 24 56 34 27 23 16

Jarak = 4 23 45 12 24 56 34 27 23 16
23 45 12 24 56 34 27 23 16
23 34 12 24 56 45 27 23 16
23 34 12 24 56 45 27 23 16
23 34 12 23 56 45 27 24 16
23 34 12 23 16 45 27 24 56

Jarak = 2 23 34 12 23 16 45 27 24 56
12 34 23 23 16 45 27 24 56
12 23 23 34 16 45 27 24 56
12 23 16 34 23 45 27 24 56
12 23 16 34 23 45 27 24 56
12 23 16 34 23 45 27 24 56
12 23 16 34 23 24 27 45 56
12 23 16 34 23 24 27 45 56

Jarak = 1 12 23 16 34 23 24 27 45 56
12 23 16 34 23 24 27 45 56
12 16 23 34 23 24 27 45 56
12 16 23 34 23 24 27 45 56
12 16 23 23 34 24 27 45 56
12 16 23 23 24 34 27 45 56
12 16 23 23 24 27 34 45 56
12 16 23 23 24 27 34 45 56
12 16 23 23 24 27 34 45 56

Akhir 12 16 23 23 24 27 34 45 56

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