STRUKTUR DATA HIRARKIS : TREE

  STRUKTUR DATA HIRARKIS : TREE

  Tree merupakan salah satu struktur data yang paling penting, karena banyak aplikasi menggunakan informasi dan data yang secara alami memiliki struktur hirarkis berguna dalam membantu memecahkan banyak masalah algoritmis.

  Aplikasi pohon biner :

  a. sebagai representasi ekspressi matematika b. aplikasi pohon biner dalam Huffman Coding.

  Cara Penggambaran Tree :

• Notasi Kurung • Diagram Venn • Notasi Tingkat

  Terminologi :

• – Tree (atau pohon) sejumlah node yang berhubungan secara hirarkis dimana suatu node pada suatu hirarki merupakan cabang dari node dengan hirarki yang lebih tinggi dan juga memiliki cabang ke beberapa node lainnya dengan hirarki yang lebih rendah.
>– Root (atau akar) Node dengan hirarki tertinggi dinamakan r>– leaf (atau daun) node yang tidak memiliki cabang. node yang tidak memiliki cabang.
• – Internal node (atau node dalam) node yang bukan merupakan leaf.
• – edge (atau sisi atau cabang) menyatakan hubungan hirarkis antara kedua node yang terhubungkan, biasanya digambarkan berarah (berupa panah) untuk menunjukkan node asal edge lebih tinggi dari node tujuan dari edge.

  Level (atau tingkat) suatu node (Kadang dimulai level 0 atau 1) – Bilangan yang menunjukan hirarki dari suatu node, root memiliki level 1, node cabang dari root memiliki level 2, node cabang berikutnya dari node adalah level 3, dan seterusnya.

  Height (atau tinggi) suatu tree – Sama dengan level dengan angka terbesar (hirarki terendah) suatu node yang ada dalam tree atau bisa juga didefinisikan sebagai jumlah sisi terbanyak dari root hingga suatu leaf yang ada di tree.

  Depth (atau kedalaman) suatu node – Jumlah sisi dari root hingga node ybs.

• – Subtree (atau subpohon) Subtree (atau subpohon) – sebagian dari tree mulai dari suatu node N melingkupi node-node sebagian dari tree mulai dari suatu node N melingkupi node-node yang berada dibawah hirarkinya sehingga dapat dipandang sebagai suatu tree juga yang mana N sebagai root dari tree ini. Tree kosong – Suatu tree yang tidak memiliki satu node pun. Tree dengan urutan – letak geometris node-node yang merupakan cabang yang sama dari suatu node adalah penting; biasanya urutan dari kiri ke kanan.

  B, C, D dan E memiliki induk (parent) yang sama yaitu A, sehingga ke- - 4 node tersebut disebut saudara (siblings) Semua node di bawah suatu node induk hanya dapat diakses melalui - induknya Lintasan (path) sebuah node X adalah urutan akses untuk - mendapatkan X yang dimulai dari Akar. Path(M) = [A – B – G – M] Panjang lintasan (path length) X adalah jumlah node yang harus - diakses untuk mendapatkan X; sehingga |Path(M)| = 4. Ada juga yang menyatakan panjang lintasan sebuah node adalah jumlah garis dari akar sampai node tersebut akar sampai node tersebut Tinggi (height) dari sebuah pohon adalah panjang lintasan terpanjang. - Tinggi pohon di bawah ini = 4 Jika ada sebuah lintasan dari node a ke node b, maka a adalah - pendahulu (ancestor) dari b dan b disebut keturunan (descendent) dari a Kedalaman (depth) dari sebuah node adalah panjang lintasan dari - akar ke node tersebut. Depth (G) = 3 Karakteristik :

  a. Terdapat 1 node yang unik, yang tidak memiliki predecessor, yang disebut dengan root (akar) b. Terdapat satu atau beberapa node yang tidak memiliki successor yang disebut dengan leaf (daun) c. Setiap node kecuali root pasti memiliki satu predecessor

  d. Setiap node kecuali leaf pasti memiliki 1 atau lebih successor

  Contoh : Root

  Node/Vertex/Simpul Edge/ Link

  A B E D C F

  J

  I G

H

O M L K

  N BINARY TREE Karakteristik : Maksimum child adalah 2 (Left Child dan Right Child) Complete Binary Tree : Bila semua node kecuali Leaf memiliki 0 atau 2 child. Subtree pada Heap Tree dapat memiliki path length yang berbeda Skewed Binary Tree (Miring) : Bila semua node, kecuali Leaf memiliki hanya 1 child Full Binary Tree : Bila semua node kecuali Leaf memiliki 2 Child dan semua subtree harus memiliki path yang sama Representasi :

  Ekspressi Matematika (EM) didefenisikan sebagai berikut: (1). Variabel dan Bilangan adalah EM (2). Jika E, E1 dan E2 adalah EM maka

• – E, + E dan (E) adalah EM E1 + E2, E1 – E2, E1 * E2, E1 / E2, E1 div E2, E1 mod E2 dan

  E1^E2 juga adalah EM Contoh : 4 adalah EM

  X adalah EM 4 + X adalah EM 2 + 4 * 3 adalah EM 2 + 4 * 3 adalah EM (2 + 4) * 3 adalah EM

  ((3 + 2) * (5 – 2)) / (2 + 3) adalah EM dan seterusnya Contoh: Diketahui: Ekspressi Matematika ((2 + 3) * (5 – 2) + 5) * (5 + 3 * 2) Ditanya: Gambarkan pohon ekspressi dengan cara Bootom Up Penyelesaian: Ekspressi tersebut terbagi dua menjadi E1 dan E2 oleh operator *; sehingga Huffman Code: Hubungan Level dengan Jumlah Data :

  … … … TRAVERSAL BINARY TREE

• Operasi penelusuran node-node dalam binary tree
• Traversal dibagi 3, yaitu :

  a. Preorder

  b. Inorder

  c. Postorder

• Algoritma :

  Procedure Preorder (n : BST); Begin

  If (n<> NIL) Then If (n<> NIL) Then Begin

  Write(n^.Info); Preorder(n^.Kiri); Preorder(n^.Kanan);

  End; End; Procedure Inorder (n : BST); Begin

  If (n<> NIL) Then Begin

  Inorder(n^.Kiri); Write(n^.Info); Inorder(n^.Kanan);

  End; End; Procedure Postorder (n : BST); Begin

  If (n<> NIL) Then Begin

  Postorder(n^.Kiri); Postorder(n^.Kanan); Contoh : B B B B B B B B B B B B

  Implementasi Binary Tree :

  a. Array

  b. Linked List Implementasi BT pada array :

  Indeks pada array menyatakan nomor kode - Node root mempunyai indeks array = 1 - Leftchild suatu node dengan nomor p adalah (2p) -

• Rightchild suatu node dengan nomor p adalah (2p+1)

  Parent dari suatu node dengan nomor p adalah (p div 2) - Implementasi Binary Tree dengan Linked List Uses crt; Type

  Pointer =^Cell; Cell = Record

  Kiri : Pointer; Info : Char; (* boleh diganti dg integer / tipe data lain *)

Implementasi Binary Search Tree :

  Ketentuan :

  a. Semua left child harus lebih kecil dari parent

  b. Semua right child harus lebih besar dari parent Keuntungan : Pencarian node target menjadi lebih efisien dan cepat Operasi-Operasi Standar BST :

  Mengosongkan BST - Mengosongkan BST -

• Mencek apakah BST kosong

  Mencari Tree Minimum - Mencari Tree Maksimum - Memasukkan data baru ke dalam BST - Mencari elemen tertentu dalam BST - Menghapus data tertentu dari dalam BST - a. Mengosongkan BST (Makenull) Procedure Makenul (T: BST); Begin

  T := Nil; End;

  b. Memeriksa Apakah BST Kosong Function Empty(T : BST) : Boolean; Begin Begin

  Empty := (T = Nil) End; Function TREE_MINIMUM (T : BST ) : BST; Begin

  If (Not Empty (T)) Then Begin

  While (T^.Kiri <> NIL) do Begin

  T = T^.Kiri; T = T^.Kiri; End; return T;

  End; End; Function TREE_MAKSIMUM(T : BST ) : BST; Begin

  If (Not Empty (T)) Then Begin

  While (T^.Kanan <> NIL) do Begin

  T = T^.Kanan; T = T^.Kanan; End; return T;

  End; End; Operasi Insert :

• Pencarian lokasi untuk node yang akan diinsert selalu dimulai dari root
• Jika node yang diinsert lebih kecil dari root , maka insert di daun pada left subtree
• Jika node yang diinsert lebih besar dari root , maka insert di daun pada right subtree

  Procedure Insert(x : TipeData; Var T : BST); Begin

  If (T = Nil) Then (* Jika ditemukan T yang nil *) Begin

  New(T);(* ciptakan node baru ditunjuk oleh T *) T^.Kiri := Nil; (* Set pointer kiri = nil *) T^.Info := x; (* Isi data pada node = x *) T^.Kanan := Nil; (* Set pointer kanan = nil *) T^.Kanan := Nil; (* Set pointer kanan = nil *)

  End Else (If x = T^.Data) Then (* x sudah ada dalam T *)

  Writeln(‘Error : data tersebut sudah ada *) Else (If x < T^.Data) Then

  Insert(x, T^.Ki) (*jika x < data yg ditunjuk T, maka sisipkan x ke kiri*) Else (* x > data yang ditunuk T sisipkan x ke kanan *) Function Search (x: TipeData, T : BST) : Boolean; Begin

  If (T = Nil) Then Search := False

  Else If (x = T^.Info) Then Search := True (* x ditemukan *)

  Else If (x < T^.Info) Then Else If (x < T^.Info) Then Search := Search(x, T^.Kiri) (*cari x ke kiri *)

  Else (*x > T^.Info *) Search:= Search(x, T^.Kanan) (* cari secara rekursif ke kanan *)

  End; a. Berasal dari left subtree yang diambil adalah node yang paling kanan (nilai terbesar) kanan (nilai terbesar) b. Berasal dari right subtree yang diambil adalah node yang paling kiri (nilai terkecil)

  Operasi Delete Ketentuan Delete :

• Jika yang didelete adalah leaf maka tidak perlu dilakukan modifikasi terhadap lokasi
• Jika yang didelete adalah node yang hanya memiliki satu anak, maka anak tersebut langsung menggantikan posisi dari parent-nya
• Jika yang didelete adalah node dengan 2 anak (2 subtree), maka node yang diambil menggantikan node yang dihapus adalah :

  Procedure Delete (x : TipeData; Var T : BST); Var

  Bantu : Pointer; Begin

  If (T = Nil) Then Writeln(‘Error : ‘, x, ‘ tidak ditemukan ‘)

  Else If (x < T^.Info) Then Delete(x, T^.Kiri) (* rekursif ke kiri *)

  Else If (x > T^.Info) Then Else If (x > T^.Info) Then Delete(x, T^.Kanan) (*rekursif ke kanan *)

  Else (*x ditemukan *) If (T^.Kiri = Nil And T^.Kanan = Nil) Then (*Kasus x adalah daun *) Begin

  Bantu := T; (*Tangkap node dengan pointer Bantu *) T := Nil; (*potong T yang tadinya menunjuk node berisi x *) Dispose(Bantu) (*deallocate Bantu atau lepaskan node *) Else If (T^.Kiri = Nil) Then (*x berada pada node dimana kirinya nil *) Begin

  Bantu := T; T := T^.Kanan; (* Set T = pointer kanannya *) Bantu^.Kanan := Nil; (*putuskan hubungan node dgn kanannya *) Dispose (Bantu); (*lepaskan node berisi x *)

  End Else If (T^.Kanan = Nil) Then (*x berada dinode dimana kanannya nil *) Begin

  Bantu := T; T := T^.Kiri ; (* Set T = pointer kirinya *) T := T^.Kiri ; (* Set T = pointer kirinya *) Bantu^.Kiri := Nil; (*putuskan hubungan node dengan kirinya *) Dispose (Bantu); (* lepaskan node yang berisi x *)

  End Else (* pointer kiri dan kanan T tidak kosong *)

  T^.Info :=

  DeleteMin(T^.Kanan)

  End;

  Fungsi Untuk Mendukung Operasi Delete :

  Function DeleteMin (Var A : BST) : TipeData; Var

  Bantu : Pointer; Begin

  If (T^.Kiri = Nil) Then (*ditemukan data terkecil *) Begin

  Bantu := T ; (* tangkap node yang berisi data terkecil *) DeleteMin := T^.Info; (*Ambil&simpan data terkecil *) T := T^.Kanan; (* Set T = pointer kanannya *) T := T^.Kanan; (* Set T = pointer kanannya *) Bantu^.Kanan := Nil; (*lepas hubungan node tsb dgn anaknya *) Dispose (Bantu); (*lepaskan node yang berisi data terkecil *)

  End Else

  DeleteMin := DeleteMin(T^.Ki); (*rekursif ke kiri *) End; Procedure Tampil(T); Var Pilih : Integer; Begin

  Clrscr; Writeln(‘1. Tampil Secara Preorder’); Writeln(‘2. Tampil Secara Inorder’); Writeln(‘3. Tampil Secara Postorder’); Writeln; Write(‘Silahkan Pilih : ‘); Readln(Pilih); Write(‘Silahkan Pilih : ‘); Readln(Pilih); If (Pilih = 1) Then

  Preorder(T) Else If (Pilih = 2) Then

  Inorder (T) Else

  Postorder(T); Readln

AVL TREE

  Definisi : BST yang mempunyai ketentuan bahwa maks

perbedaan tinggi antara subtree kiri dan kanan adalah satu

Height-Balanced Tree :

• - BST adalah Height Balanced p-tree yang artinya maksimum

  perbedaan height antara subtree kiri dan kanan adalah p
• AVL Tree adalah height balanced 1-tree yang berarti

  maksimum perbedaan height antara subtree kiri dan kanan maksimum perbedaan height antara subtree kiri dan kanan

  adalah satu

  

a. TallLeft bila subtree kiri lebih panjang dari subtree kanan (simbol -) b. TallRight bila subtree kanan lebih panjang dari subtree kiri (simbol +) Search Path :

Path pencarian lokasi untuk dilakukan operasi insert dimulai

dari Root Pivot Point :

• - Adanya node pada search path yang balancenya TallLeft

  (tanda -) atau TallRight (tanda +) dan terletak paling dekat dengan node yang baru dengan node yang baru

• - Contoh : Jika diinsert node baru dengan nilai 5, maka pivot

  pointnya di node 25 Operasi Insert :
• Kasus-1

• Kasus 2 Jika ada PP tetapi subtree yang akan ditambahkan node baru memiliki height yang lebih kecil, maka bisa langsung di insert
• Kasus 3 Jika ada PP dan subtree yang akan ditambahkan node baru memiliki height yang lebih besar, maka tree harus digenerate supaya tetap menghasilkan AVL Tree

  Regenerate :

• Single Rotation

  a. Single Left Rotation

  b. Single Right Rotation

• Double Rotation

Algoritma Single Right Rotation :

  Function SRR (R : Node) : Node; Begin

  Node P := R^.Left; R^.Left := P^.Right; P^.Right := R; SRR := P;

  End;

Algoritma Single Left Rotation :

  Function SLR (R : Node) : Node; Begin

  Node P := R^.Right; R^.Right := P^.Left;

Algoritma Double Right Rotation :

  Function DRR (R : Node) : Node; Begin

  Node P := R^.Left; Node Q := P^.Right; R^.Left := Q^.Right; P^.Right := Q^.Left; Q^.Right := R; Q^.Left := P; Q^.Left := P; DRR := Q;

  End;

Algoritma Double Left Rotation :

  Function DLR (R : Node) : Node; Begin

  Node P := R^.Right; Node Q := P^.Left; R^.Right := Q^.Left; P^.Left := Q^.Right; Q^.Left := R; Q^.Right := P; Q^.Right := P; DLR := Q;

  End;

HEAP TREE :

  Definisi :

• Heap adalah Tree yang memenuhi persamaan :

  R[ I ] < R[ 2*I ] dan R[ I ] < R[2*I + 1]

• Heap disebut juga Complete Binary Tree - Minimum Heap : Jika nilai parentnya selalu lebih kecil dari pada kedua childrennya
• Maximum Heap : Jika nilai parentnya selalu lebih besar dari pada kedua - Maximum Heap : Jika nilai parentnya selalu lebih besar dari pada kedua childrennya

Algoritma :

  Procedure Heapify(A:T; I : Integer); Begin

  L := 2*I; R := 2*I+1; If (L<=Heap_Size[A] And A[L] > A[I]) Then besar := L Else besar := I; If (R<=Heap_Size[A] And A[R] > A[besar]) Then besar := R; If (besar <> I) Then Begin

  Swap(A[I], A[besar]); Heapify(A, besar); Heapify(A, besar);

  End; End; Procedure Bentuk_Heap(A : T); Begin

  Heap_Size[A] = Length[A]; For I:=Length[A]/2 DownTo 1 Do Algoritma Heap Sort : Procedure Heap_Sort(A : T); Begin Bentuk_Heap(A);

  For I:= Length[A] Downto 2 Do Begin Swap(A[1], A[I]); Swap(A[1], A[I]); Heap_Size[A] := Heap_Size[A] -1; Heapify(A,1); End;

  End;

B-Tree :

• Definisi : Tree yang setiap nodenya dapat berisi lebih dari pada satu elemen
• Jumlah elemen dalam sebuah node tergantung kepada order dari B-Tree tersebut
• Jumlah minimum elemen dalam setiap node (kecuali root) adalah d, dan jumlah max adalah 2d, dimana d adalah order. Untuk Root, jumlah minimum elemen 1, dan jumlah maksimum adalah 2d
• Jumlah minimum children dari suatu node dalam B-Tree adalah 0, dan jumlah Max-nya adalah jumlah elemen+1 jumlah Max-nya adalah jumlah elemen+1

  Operasi dalam B-Tree :

• Insert Jika node belum penuh (jumlah elemen < 2d), maka elemen bisa langsung di-insert Contoh : d = 2

  23 25 30 35 23 30 35 Insert (25) Jika node sudah penuh, maka perlu dilakukan node split

  Langkah Node Split : Split node menjadi 2 - Letakkan d elemen terkecil di node kiri - Letakkan d elemen terbesar di node kanan - Contoh : Insert(20)

  Delete :

• - Jika target node yang akan dihapus berisi elemen lebih dari

  d, maka target elemen bisa langsung dihapus tanpa perlu regenerate 14 25 30 35 14 20 30 35

  25 regenerate

• - Jika target node yang akan dihapus berisi d node,

  penghapusan langsung akan menyebabkan underflow

• - Regenerate dilakukan dengan meminjam elemen yang

  berada di node kiri atau dikanan (yang memiliki elemen lebih dari d). Parent/ Separator akan berubah

• - Jika node dikiri atau dikanan yang akan dilakukan

  peminjaman ternyata mempunyai elemen kurang dari d, yang mana jika dilakukan peminjaman, node tersebut akan terjadi underflow

• - Regenerate akan dilakukan dengan menggabungkan node

  yang akan dihapus dengan node dikiri/kanan

Struktur Data Graph :

  Pendahuluan :

  1. Graph : struktur data yang berbentuk network/jaringan, hubungan antar elemen adalah many-to-many

  2. Struktur Data Linear = keterhubungan sekuensial antara entitas data

  3. Struktur Data Tree = keterhubungan hirarkis 4. Struktur Data Graph = keterhubungan tak terbatas antara entitas data.

  Contoh graph : Informasi topologi jaringan dan keterhubungan antar kota-kota

  5. Keterhubungan dan jarak tidak langsung antara dua kota = data Keterhubungan dan jarak tidak langsung antara dua kota = data keterhubungan langsung dari kota-kota lainnya yang memperantarainya.

  5.

  6. Penerapan struktur data linear atau hirarkis pada masalah graph dapat dilakukan tetapi kurang efisien. Struktur data graph secara eksplisit menyatakan keterhubungan ini sehingga pencariannya langsung (straightforward) dilakukan pada strukturnya sendiri.

  Masalah-masalah Graph Masalah path minimum (Shortest path problem) mencari route dengan jarak terpendek dalam suatu

jaringan transportasi.

Masalah aliran maksimum (maximum flow problem) menghitung volume aliran BBM dari suatu reservoir ke suatu titik tujuan melalui jaringan pipa. Masalah pencarian dalam graph (graph searching problem) mencari langkah-langkah terbaik dalam program permainan catur komputer. Masalah pengurutan topologis (topological ordering problem) menentukan urutan pengambilan mata-mata kuliah yang saling berkaitan dalam hubungan prasyarat (prerequisite). Masalah jaringan tugas (Task Network Problem) membuat penjadwalan pengerjaan suatu proyek yang memungkinkan waktu penyelesaian tersingkat. Masalah pencarian pohon rentang minimum (Minimum Spanning Tree Problem) mencari rentangan kabel listrik yang totalnya adalah minimal untuk menghubungkan sejumlah kota.

  Travelling Salesperson Problem tukang pos mencari lintasan terpendek melalui semua alamat penerima pos tanpa harus mendatangi suatu tempat lebih dari satu kali. Graph terdiri dari himpunan verteks (node) dan himpunan sisi (edge, arc). Verteks menyatakan entitas-entitas data dan sisi menyatakan keterhubungan antara verteks.

  Notasi matematis graph G adalah : G = (V, E)

  x

  y

  disebut origin dan

  x

  ;

  x

  ke

  y

  dari

  y, bukan

  ke

  Misalnya : {x,y} yaitu arah

  Sebuah sisi antara verteks

  Jenis Graph : a. Directed Graph (Digraph) : jika sisi-sisi graph hanya berlaku satu arah.

  bagian dari V dan E1 himpunan bagian dari E .

  V1 , E1 ) disebut subgraph dari graph G jika V1 adalah himpunan Graph H = ( V1 , E1 ) disebut subgraph dari graph G jika V1 adalah himpunan

  Subgraph : graph yang merupakan suatu subset (bagian) graph yang connected Graph H = (

  y }.

  ,

  x

  ditulis {

  y

  dan

  x

  disebut terminus. Secara notasi sisi digraph ditulis sebagai Contoh Digraph G = {V, E} : V = {A, B, C, D, E, F, G, H, I,J, K, L, M} E = {(A,B),(A,C), (A,D), (A,F), (B,C), (B,H), (C,E), (C,G), (C,H), (C,I), (D,E), (D,F), (D,G), (D,K), (D,L), (E,F), (G,I), (G,K), (H,I), (I,J), (I,M), (J,K), (J,M), (L,K), (L,M)}.

  B A H C

  M F

  I E D D G K L b. Graph Tak Berarah (undirected graph atau undigraph): setiap sisi { x , y } berlaku pada kedua arah: baik ke maupun ke . Secara grafis sisi

  x y y x

  pada undigraph tidak memiliki mata panah dan secara notasional menggunakan kurung kurawal.

  Contoh Undigraph G = {V, E} V = {A, B, C, D, E, F, G, H, I,J, K, L, M} E = { {A,B},{A,C}, {A,D}, {A,F}, {B,C}, {B,H}, {C,E}, {C,G}, {C,H}, {C,I}, {D,E},

  {D,F}, {D,G}, {D,K}, {D,L}, {E,F}, {G,I}, {G,K}, {H,I}, {I,J}, {I,M}, {J,K}, {J,M}, {L,K}, {L,M}}.

  Khusus graph, undigraph bisa sebagai digraph (panah di kedua ujung edge berlawanan) Struktur data linear maupun hirarkis adalah juga graph. Node-node pada struktur linear ataupun hirarkis adalah verteks-verteks dalam pengertian graph dengan sisi-sisinya menyusun node-node tersebut secara linear atau hirarkis. Struktur data linear adalah juga tree dengan pencabangan pada setiap node

  B A H C

  M F

  I E D D G K L B A H C

  M F

  I E D D G K L

  Konektivitas pada Undigraph

• Adjacency: Dua verteks x dan y yang berlainan disebut terhubung langsung (adjacent) jika ada sisi { x , y } dalam E.
• Path : Urutan dari kumpulan node-node, dimana tiap node dengan node berikutnya dihubungkan dengan Edge • Simple Path : Jika node dalam path tsb hanya muncul 1 kali • Panjang dari path: jumlah sisi yang dilalui path.
• Siklus (cycle) : suatu path dengan panjang lebih dari satu, dimana vertex awal dan akhir sama.
• Siklus sederhana: dalam undigraph, siklus yang terbentuk dari tiga atau lebih verteks yang berlainan, dimana tidak ada vertex muncul lebih satu kali kecuali verteks awal/akhir.
• Dua verteks

  x

  dan

  y

  yang berbeda dalam suatu undigraph disebut berkoneksi (connected) apabila ada path penghubung.

• Suatu komponen terkoneksi (connected components) adalah subgraph (bagian dari graph) yang berisikan satu himpunan

  Konektivitas pada Digraph

  Terminologi pada Undigrap berlaku, kecuali dalam digraph harus dikaitkan dengan arah tertentu karena pada arah yang sebaliknya belum tentu terdefinisi. Adjacency ke/dari : Jika ada sisi ( x , y ) maka pada digraph dikatakan bahwa

  "adjacent ke" atau "adjacent dari" . Demikian pula jika terdapat

  x y y x

  path dari x ke y maka belum tentu ada path dari y ke x. Jadi dalam digraph keterkoneksian didefinisikan lebih lanjut lagi sebagai berikut

  .

• Terkoneksi Kuat : Bila setiap pasangan verteks berbeda x dan y dalam S, dalam S, x x berkoneksi dengan berkoneksi dengan y y dan dan y y berkoneksi dengan berkoneksi dengan x x Terkoneksi Lemah : Bila setiap pasangan verteks berbeda dan -

  x y

  dalam S, salah satu: x berkoneksi dengan y (atau y berkoneksi dengan ) dan tidak kebalikan arahnya (hanya terdefinisi satu path:

  x dari x ke y atau sebaliknya dari y ke x ).

  Graph berbobot (weighted graph)

  Graph dengan sisi mempunyai Bobot/ Biaya. “Biaya" ini bisa mewakili banyak aspek: biaya ekonomi suatu aktifitas, jarak geografis/tempuh, waktu tempuh, tingkat kesulitan, dan lain sebagainya.

  Contoh : Graph ini merupakan Undirected Weighted Graph. Order dari verteks A = 4, verteks B = 3, dst. Adjacentcy list dari D adalah = {A, E, F, G, K, L}.

  Representasi Graph Representasi Graph Representasi Matriks Keterhubungan Langsung (Adjacency Matrix)

  Matriks digunakan untuk himpunan adjacency setiap verteks. Baris berisi vertex asal adjacency, sedangkan kolom berisi vertex tujuan adjacency.

  Bila sisi graph tidak mempunyai bobot, maka [x, y] adjacency disimbolkan dengan 1 dan 0 bila tidak adjacency.

  Bila sisi graph mempunyai bobot, maka [x, y] adjacency disimbolkan dengan

  _Dari\Ke Direpresentasikan dalam matriks sbb. _{A B C D E F G H I J K L M}

• A
^{1 1 1 1}

  1 ^{- B 1 1} C - ^{1 1 1 1 1 1 1}

  1 ^{- D D 1 1 1 1 1 - 1 1 1 1 1} _G E _{1 1} ^{1 -} _{1 - 1} ¹ _{1 - F} ¹ _{1 1 I}

  1 ₁ ¹ _{1 - 1} ^{- H} ₁ ¹ _{- J 1 1 1 1}

  B 34 45

  A 43 18

  H

  35 31 25 C

  33 15 35 M

  16 22 F

  I 22 21

  19 E D D 39 19 25 15 G

  13 27 13

  19 K L

  10 Dari\Ke A B C D E F G H ^{I J K L M} _{A - 24 43 33} ∞

³¹

∞ ∞ ∞ ∞ ∞ ∞ ∞

  B ^{24 - 18} ∞ ∞ ∞ ∞ ⁴⁵ ∞ ∞ ∞ ∞ ∞

  C ^{43 18 -} ∞ ¹⁶

∞

^{22 35 15} ∞ ∞ ∞ ∞

  D ³³ ∞ ∞ ^{- 19}

²²

³⁹ ∞ ∞ ∞ ^{13 27} ∞

  E ∞ ∞ ^{16 19 -} _F

¹⁵ ∞ ∞ ∞ ∞ ∞ ∞ ∞ ₃₁ ∞ ∞ _G ^{22 15 -} ∞ ∞ ∞ ∞ ∞ ∞ ∞ ∞ ∞ ^{22 39} ∞ ∞ ^- ∞ ²¹ ∞ _H ¹³ ∞ ∞ ∞ ^{45 35} ∞ ∞ ∞ ∞ ^{- 25} ∞ ∞ ∞ ∞ _I ∞ ∞ ¹⁵ ∞ ∞ ∞ ^{21 25 - 19} ∞ ∞ ³⁵ _J ∞ ∞ ∞ ∞ ∞ ∞ ∞ ∞ ^{19 - 10} ∞ ¹⁵ _K ∞ ∞ ∞ ¹³ ∞ ∞ ¹³ ∞ ∞ ^{10 - 19} ∞ Adjacency List : ??? Perhatikan deklarasi berikut :

  Type

  Pointer = ^Simpul; Simpul = Record

  Elemen : TipeData; (* tipe data menurut pilihan kita *) Next : Pointer

  End; Var

  X : Array [1..N] Of Pointer;

  Algoritma-algoritma Pencarian Pencarian vertex adalah proses umum dalam graph.

  Terdapat 2 metoda pencarian: Depth First Search (DFS): pada setiap pencabangan, penelusuran verteks-verteks yang belum dikunjungi dilakukan secara lengkap pada pencabangan pertama, kemudian selengkapnya pada pencabangan kedua, dan seterusnya secara rekursif.

  Breadth First Search (BFS): pada setiap pencabangan penelusuran verteks-verteks yang belum dikunjungi dilakukan pada verteks-verteks adjacent, kemudian berturut-turut pada verteks-verteks adjacent, kemudian berturut-turut selengkapnya pada masing-masing pencabangan dari setiap verteks adjacent tersebut secara rekursif.

  Algoritma Depth First Search :

  a. Algoritma diawali pada vertex S dalam G

  b. Kemudian algoritma menelusuri graph dengan suatu insiden edge ( ,

  u v ) ke current vertex u .

  c. Jika edge ( , ) menunjuk ke suatu vertex v yang siap untuk

  u v

  dikunjungi, maka kita ikuti jalur mundur ke current vertex u. Jika pada sisi lain, edge (u, v ) menunjuk ke vertex v yang tidak dikunjungi, maka kita pergi ke dan menjadi current vertex.

  v v d. Kita proses ini hingga kita mencapai sasaran akhir.

  e. Pada titik ini, kita mulai jalur mundur. Proses ini berakhir ketika jalur mundur menunjuk balik ke awal vertex. mundur menunjuk balik ke awal vertex.

  void graph() { for semua node u do { colour[u]=white; p[u]=NULL; } time = 0; for semua node u do if colour[u] == white then DFS(u); } void DFS(u) void DFS(u) { visit(u); time = time + 1;

d[u] = time;colour[u] = grey;

for semua node v adjacent ke u do { if colour[v] == white then { p[v] = u; DFS(u); } }

time = time + 1; f[u] = time;

  Algoritma Breadth First Search :

  BFS diawali dengan vertex yang diberikan, yang mana di level 0. Dalam stage pertama, kita kunjungi semua vertex di level 1. Stage kedua, kita kunjungi semua vertex di level 2. Disini vertex baru, yang mana adjacent ke vertex level 1, dan seterusnya. Penelusuran BFS berakhir ketika setiap vertex selesai ditemui.

  Implementasi algoritma BFS

  Algoritma BFS menjadi kurang straightforward jika dinyatakan secara rekursif. Jadi sebaiknya diimplementasikan secara nonrekursif dengan rekursif. Jadi sebaiknya diimplementasikan secara nonrekursif dengan memanfaatkan queue sebagai struktur data pendukung void BFS() { Queue q = new Queue();

  Vertex v, w, t; for (setiap vertex v dalam G) v.Status = false; for (setiap vertex v dalam G)

  { if (v.Status == false) { v.Status = true; q.Enqueue(v); while (EmptyQueue(Q) == false)

  { w = q.Dequeue(); visit(w); for (setiap vertex T adjacent dari w) for (setiap vertex T adjacent dari w) { if (t.Status == false)

  { t.Status = true; q.Enqueue(t);

  } }

  } } Contoh :

Perhatikan graph berikut dimana penelusuran diawali pada vertex s.

  Input : Graph G dan vertex. Output : Edge dilabeli sebagai jelajah dan edge yang dilewati sesuai komponen terhubung.

  Langkah-1:

  

Langkah-2 :

Langkah-3 :

  

Langkah-4:

Langkah-5:

  

Langkah-6:

Langkah-7:

  Masalah Pencarian Lintasan Terpendek

  Pencarian shortest path (lintasan terpendek) adalah masalah umum dalam suatu weighted, connected graph. Misal : Pencarian jaringan jalan raya yang menghubungkan kota-kota disuatu wilayah

• Lintasan terpendek yag menghubungkan antara dua kota berlainan tertentu (Single-source Single-destination Shortest Path Problems)
• Semua lintasan terpendek masing-masing dari suatu kota ke setiap kota lainnya (Single-source Shortest Path problems)
• Semua lintasan terpendek masing-masing antara tiap • Semua lintasan terpendek masing-masing antara tiap kemungkinan pasang kota yang berbeda (All-pairs Shortest Path Problems)
Untuk memecahkan masing-masing dari masalah-masalah tersebut terdapat sejumlah solusi.

  Algoritma Dijkstra untuk Single-source Shortest Path • Algoritma Floyd-Warshall untuk masalah All-pairs Shortest • Path Algoritma Johnson untuk masalah All-pairs Shortest Path • pada sparse graph

  Dalam beberapa masalah graph lain, suatu graph dapat memiliki bobot negatif dan kasus ini dipecahkan oleh algoritma Bellman-Ford. Yang akan dibahas di sini adalah algoritma Dijkstra yaitu mencari lintasan terpendek dari suatu verteks asal tertentu vs ke setiap verteks lainnya. terpendek dari suatu verteks asal tertentu vs ke setiap verteks lainnya.

  Algoritma Dijkstra

  Algoritma Dijkstra's :

  a. Menyelesaikan problem single-source shortest-path ketika semua edge memiliki bobot tidak negatif.

  b. Algoritma greedy mirip ke algoritma Prim's.

  c. Algoritma di awali pada vertex sumber s, kemudian berkembang membentuk sebuah tree T, pada akhirnya periode semua vertex dijangkau dari S. Vertex di tambah ke T sesuai urutan. Misalnya : pertama S, kemudian vertex yang tepat ke S, kemudian yang tepat berikutnya dan seterusnya. tepat berikutnya dan seterusnya.

  DIJKSTRA (G, w, s) {

  INITIALIZE SINGLE-SOURCE (G, s) S ← { } Initialize priority queue Q Q ← V[G] while priority queue Q is not empty do

  u

  ← EXTRACT_MIN(Q) S ← S È {

  u }

  // Lakukan relaxation untuk setiap vertex v adjacent ke u // Lakukan relaxation untuk setiap vertex v adjacent ke u for setiap vertex v dalam Adj[u] do Relax (

  u

  ,

  v

  ,

  w

  ) } Relax (u, v , w) { If d[u] + w(u,

  v

  ) < d[

  v

  ] then Step1. Diberikan inisial graph G=(V, E). Semua node-node mempunyai biaya tak terhingga, kecuali node sumber s, dengan biaya 0.

  Step 2. Pertama, lakukan pemilihan node, yang mana tepat ke node sumber S. Kita inisialisasi d[S] ke 0. Tambahkan itu ke S. Relaksasi semua node adjacent dari sumber S. Update predecessor (lihat panah merah dalam diagram di bawah) untuk semua node yang di-update.

  Step 3. Pilih node paling tepat ke x. Relaksasi semua node adjacent ke vertex x. Update predecessor untuk node u, v dan y (kembali, perhatikan panah merah dalam diagram berikut).

  Step 4. Sekarang, node y adalah node tepat, sehingga di tambahkan ke S. Relaksasi node v dan periksa predecessor yang dimiliki (perhatikan panah merah!).

  Step 5. Sekarang kita memiliki node u yang tepat. Pilih node ini dan periksa bahwa itu merupakan tetangga dari node v.

  Step 6. Akhirnya, tambahan node v. Daftar predecessor sekarang mendefinisikan shortest path dari setiap node ke node asal, s.

  Dynamic Programming :

  Terdiri dari sederetan tahapan keputusan. Pada setiap tahapan berlaku prinsip optimality (apapun keadaan awal dan keputusan yang diambil, keputusan berikutnya harus memberikan hasil yang optimal dengan melihat hasil keputusan sebelumnya.

  Misalnya : Multistage Graph Dimana : Cost (i,j) = Min(C(j,l) + Cost(i+1,l)} Dengan : Dengan : C(j,l) = Bobot edge j dan l l = Elemen Vi+1 Dan <j,l> eemen E i=stage ke-I dan j = node dalam V Proses dimulai dari k-2, dimana k adalah banyak stage Perhatikan contoh untuk menentukan biaya termurah dari 1 hingga 12.

  Diketahui graph dengan stage sebagai berikut : S1 S2 S3 S4 S5

  11

  2

  5

  5

  11

  2

  11

  6

  8

  55

  3

  44

  

88

  77

  11

  11

  10

  10

  12

  3

  12

  4

  7

  9

  1

  2

  2

  6

  5

  4

  4

  7

  12

  11

  33

  22

  77

  66

  10

  10

  99

  12

Maka langkah-langkah yang dilakukan adalah :

  K=5, sehingga dimulai dari S3 Cost(3,6) = Min{6+Cost(4,9); 5+Cost(4,10)} = Min{6+4;5+2} = 7 Cost(3,7) = Min{4+Cost(4,9); 3+Cost(4,10)} = Min{4+4;3+2} = 5 Cost(3,8) = Min{5+Cost(4,10); 6+Cost(4,11)} = Min(5+2;6+5} = 7 Cost(2,2) = Min{4+Cost(3,6);2+Cost(3,7);1+Cost(3,8)}

  = Min{4+7;2+5;1+7} = 7 Cost(2,3) = Min{2+Cost(3,6); 7+Cost(3,7)} = Min(2+7; 7+5) = 9 Cost(2,3) = Min{2+Cost(3,6); 7+Cost(3,7)} = Min(2+7; 7+5) = 9 Cost(2,4) = Min{11+Cost(3,8)} = 18 Cost(2,5) = Min{11+Cost(3,7); 8+Cost(3,8)} = Min(11+5;8+7} = 15 Cost(1,1) = Min{9+Cost(2,2);7+Cost(2,3);3+Cost(2,4),2+Cost(2,5)}

  = Min{9+7;7+9;3+18;2+15} = 16 Jadi : Shorthest Path menjadi : Shortest Path Pertama adalah :

  4

  11

  5

  5

  11

  2

  11

  6

  8

  55

  3

  44

  

88

  77

  11

  11

  10

  10

  12

  2

  3

  9

  7

  1

  2

  2

  6

  5

  4

  4

  7

  11

  12

  33

  22

  77

  66

  10

  10

  99

  12

  12 Shortest Path Kedua adalah :

  4

  11

  5

  5

  11

  2

  11

  6

  8

  55

  3

  44

  

88

  77

  11

  11

  10

  10

  12

  2

  3

  9

  7

  1

  2

  2

  6

  5

  4

  4

  7

  11

  12

  33

  22

  77

  66

  10

  10

  99

  12

  12 Struktur Data graf: representasi & algoritma-algoritma Masalah Pencarian Pohon Rentangan Minimum

  Definisi Pohon rentangan atau spanning tree dari suatu connected graph didefinisikan sebagai free-tree yang terbentuk dari subset sisi-sisi serta menghubungkan setiap verteks dalam graph tersebut. Pohon rentangan Minimum (MST) adalah pohon rentangan dengan total bobot dari sisi- sisinya adalah minimal. Dalam penelusuran vertex tidak diperkenankan terbentuk siklus (cycle) Diketahui sebuah graph tak berarah dan tak berbobot sebagai berikut :

  Kemungkinan Spanning Tree :

  Bila jalur (edge) mempunyai biaya (cost) maka yang dicari adalah minimum cost spanning tree.

  Dua algoritma populer untuk menentukan minimum spanning tree (MST) :

  a. Kruskal Algorithm

  b. Prim’s Algorithm Algoritma Kruskal : Algoritma ini lebih sederhana jika dilihat dari konsepnya namun lebih sulit dalam implementasinya. Idenya adalah mendapatkan satu demi satu dalam implementasinya. Idenya adalah mendapatkan satu demi satu sisi mulai dari yang berbobot terkecil untuk membentuk tree; suatu sisi walaupun berbobot kecil tidak akan diambil jika membentuk siklik dengan sisi yang sudah termasuk dalam tree.

  Yang menjadi masalah dalam implementasinya adalah keperluan adanya pemeriksaan kondisi siklik tersebut.

  Salah satu pemecahaannya adalah dengan subsetting yaitu pembentukan subset-subset yang disjoint dan secara bertahap dilakukan penggabungan atas tiap dua subset yang berhubungan dengan suatu sisi dengan bobot terpendek. Algoritma lengkapnya:

  Tahap pertama, jika dalam V terdapat n verteks maka diinisialisasi n buah subset yang disjoint, masing-masing berisi satu verteks, sebagai subset-subset awal. Tahap berikutnya, urutkan sisi-sisi dengan bobot yang terkecil hingga terbesar.

  Mulai dari sisi dengan bobot terkecil hingga terbesar lakukan Mulai dari sisi dengan bobot terkecil hingga terbesar lakukan dalam iterasi: jika sisi tsb. menghubungkan dua verteks dalam satu subset (berarti membentuk siklik) maka skip sisi tersebut dan periksa sisi berikutnya jika tidak (berarti membentuk siklik) maka kedua subset dari verteks-verteks yang bersangkutan digabungkan menjadi satu subset yang lebih besar.

  { For setiap vertex v dalam V[G] Do

  { set S( } }

  v v

  ) ← { Inisialisasi priority queue Q yang berisi semua edge dari G, gunakan bobot sebagai keys.

  // A berisi edge dari MST A ← { } While A lebih kecil dari pada n-1 edge Do { set S( v ) berisi v dan S( u ) berisi u }

  IF S( ) != S( ) != S( ) Then ) Then

  IF S(

  v v u u

  { Tambahkan edge ( , ) ke A

  u v

  Merge S( v ) dan S( u ) menjadi satu set } Return A

  }

  Contoh : Diktahui sebuah graph sebagai berikut : Step 1. Dalam graph, Edge(g, h) adalah terpendek. Setiap vertex g atau vertex h dapat menjadi representatif. Misal, pilih vertex g secara bebas : Step 2. edge (c, i) menciptakan dua tree. Pilih vertex c sebagai representasi untuk dua tree

  Step 3. Edge (g, g) adalah edge terpendek berikutnya. Tambahkan edge ini dan pilih vertex g sebagai representatif : Step 4. Edge (a, b) menciptakan tiga tree.

  Step 5. Tambahkan edge (c, f) dan merge dua tree. Vertex c terpilih sebagai representatif.

  Step 6. Edge (g, i) adalah yang paling minimum berikutnya, tetapi jika kita tambahkan edge ini, sebuah cycle akan tercipta. Vertex c adalah representasi dari keduanya.

  Step 7. Sebagai alternatif, tambahkan edge (c, d).

  Step 8. Jika kita tambahkan edge (h, i), maka edge(h, i) akan membuat sebuah cycle.

  Step 9. Sebagai alternatif penambahan edge (h, i), tambahkan edge (a, h).

  Step 10. Kembali, jika kita tambahkan edge (b, c), akan menciptakan sebuah cycle. Tambahkan edge (d, e) sebagai alternatif untuk menyempurnakan spanning tree. Dalam spanning tree ini, semua tree digabung dan vertex c adalah sebuah representatif tunggal.

  Algoritma Prim

  Algoritma dimulai dari suatu verteks awal tertentu: bisa ditentukan oleh pemanggil atau dipilih sebarang oleh algoritma. Misalnya verteks awal tersebut adalah v. Pada setiap iterasi terdapat kondisi di mana himpunan verteks V terbagi dua dalam:

  W yaitu himpunan verteks yang sudah dievaluasi sebagai node di dalam pohon, serta (V-W) yaitu himpunan verteks yang belum dievaluasi. Di awal algoritma W diinisialisasi berisi verteks awal v. Di awal algoritma W diinisialisasi berisi verteks awal v. Selanjutnya, di dalam iterasinya:

  Pada setiap adjacency dari tiap verteks dalam W dengan verteks dalam (V-W) dicari sisi dengan panjang minimal. setelah diperoleh, sisi tersebut ditandai sebagai sisi yang membentuk tree dan verteks adjacent sisi tersebut dalam (V- W) dipindahkan ke W (menjadi anggota W). Dari contoh di atas misalnya dilakukan pencarian mulai dari verteks A (ingat tidak harus selalu dari verteks A!). Maka algoritma ini menghasilkan tahapan-tahapan iterasi pencarian sbb.:

  MST_PRIM (G, w , v ) { Q ← V[G] for setiap u dalam Q do key [ u

  ] ← ∞ key [ r ] ← 0 r

  π[ ] ← NIl while queue tidak kosong do { { u u ← EXTRACT_MIN (Q) ← EXTRACT_MIN (Q) for setiap vertex v dalam Adj[ u ] do { if v ada dalam Q dan w ( u , v ) < key [ v ] then

  { v w ( u , v ) ] ← π[ key [ v w ( u , v )

  ] ← } }