Topik 1: Graf

Misalkan kita punya graf dengan 5 simpul {A, B, C, D, E} dan sisi-sisi yang digambarkan pada gambar
berikut.

Gambar 1. Graf Berarah

Dalam representasinya melalui Linked List, graf dapat direpresentasikan melalui 3 cara yaitu (1) Multi
Linked List dengan elemen edge, (2) Multi Linked List dengan list edge, (3) Multi Linked List dengan
elemen vertex.

Gambar 2. Representasi Multi Linked List dengan elemen edge

ADT
type infotypeVertex: char {sesuaikan}
type adrVertex: pointer to vertex
type adrEdge: pointer to edge
type vertex <info: infotype, firstEdge: adrEdge, next: adrVertex>
type edge <nextV: adrVertex, nextE: adrEdge>
type Graph <first: adrVertex>
 Gambar 3. Representasi Multi Linked List dengan list edge

ADT
type infotypeVertex: char {sesuaikan}
type adrVertex: pointer to vertex
type adrEdge: pointer to edge
type vertex <info: Infotype, next: adrVertex>
type edge <vertex1: adrVertex, vertex2: adrVertex, next: adrEdge>
type Graph <firstVertex: adrVertex, firstEdge: adrEdge>

Gambar 4. Representasi Multi Linked List dengan elemen vertex

ADT
type infotypeVertex: char {sesuaikan}
type adrVertex: pointer to vertex
type adrEdge: pointer to edge
type vertex <info: infotype, firstEdge: adrEdge, next: adrVertex>
type edge <info: infotype, next: adrEdge>
type Graph <first: adrVertex>

Untuk responsi ini hanya akan berfokus pada representasi Multi Linked List dengan elemen edge (1).
Latihan

Lengkapi fungsi dan prosedur berikut

procedure connect(in/out G: Graph, in v1,v2: infotypeVertex)
{
I.S. Terdefinisi graf G (mungkin kosong) dan v1, v2 adalah vertex yang akan dihubungkan
F.S. v1 dan v2 terhubung melalui suatu elemen edge.
}
//Cara baca prosedur: “kukasi graf dan dua vertex, hubungkan dua vertex ke satu sama lain”
kamus
function findVertex(G: Graph, idVertex: infotypeVertex)  adrVertex
ver1, ver2 : adrVertex
sisi, sisiBaru : adrEdge
algoritma
// search/find v1 dan v2
ver1 = findVertex(G, v1)
ver2 = findVertex(G, v2)

// pastiin ver1 dan ver2 ketemu

if ver1 != NULL and ver2 != NULL then
//beneran ada ga? Kalo ada, kasi edge/garis/sisi/hubungan/link
sisiBaru = alokasi()
nextV(sisiBaru) = ver2
nextE(sisiBaru) = firstEdge(ver1)
firstEdge(ver1) = sisiBaru
{endif}

function countDegree(G: Graph, idVertex: infotypeVertex)  integer

{mengembalikan banyaknya degree (out dan in) pada sebuah vertex}
//itungen, ada berapa edge (baik masuk ato keluar) dari suatu vertex
kamus
function findVertex(G: Graph, idVertex: infotypeVertex)  adrVertex
foundV, q: adrVertex
p, r : adrEdge
jumDerajat : integer
algoritma
// cari vertex
foundV = findVertex(G, idVertex)

if foundV != NULL then

jumDerajat = 0
//jangan sampe, disuru cari degree dari vertex yang bahkan gaada
// hitung outdegree (yang keluar)
p = firstEdge(foundV) //p adalah edge keluar dari vertex “FoundV”
while (p!=NULL) do //kalo misal ada yang keluar, lakuin ini
jumDerajat = jumDerajat + 1
p = nextE(p) //kita udah urus salah satu edge dari “FoundV”, geser ke edge selanjutnya
//di iterasi 1, p = edge(AB)
//di iterasi 2, p = edge (BC) yang kebetulan “out”
//di iterasi 3, p = edge (BC) tapi “in”
//di iterasi 4, p = edge (BD) dan ternyata “out”
{endwhile}
q = first(G)
while (q!=NULL) do
r = firstEdge(q)
while (r!=NULL) do
if (nextV(r) == foundV) then
jumDerajat = jumDerajat + 1
 endif
r = nextE(r)
endwhile
q = next(q)
endwhile
endif
return jumDerajat

function hasMultipleEdges(G: Graph, idVertex: infotypeVertex)  bool

{mengembalikan nilai boolean true jika vertex dengan idVertex memiliki multiple edges, dan false jika
sebaliknya.}
kamus
function findVertex(G: Graph, idVertex: infotypeVertex)  adrVertex
foundV : adrVertex
sisi, ambil, nextAmbil : adrEdge
algoritma
// cari vertex
foundV = findVertex(G, idVertex)

// pastiin ketemu
if foundV != NULL then
sisi = firstEdge(foundV)
while (sisi != NULL) do
ambil = sisi //ambil edge pertama
nextAmbil = nextE(ambil) //ambil edge selanjutnya
while (nextAmbil != NULL) do //kalo ada edge selanjutnya lakuin
if (nextV(nextAmbil) == nextV(ambil)) then
return true //kalo dua vertex dihubungkan dengan dua edge searah, balikin true, selesein
fungsinya
endif
nextAmbil = nextE(nextAmbil)
endwhile
sisi = next(sisi)
endwhile
endif
return false

function hasLoop(G: Graph, idVertex: infotypeVertex)  bool

{mengembalikan nilai boolean true jika vertex dengan idVertex memiliki loop, dan false jika sebaliknya.}
kamus
function findVertex(G: Graph, idVertex: infotypeVertex)  adrVertex
foundV : adrVertex
sisi, ambil, nextAmbil : adrEdge
algoritma
// cari vertex
foundV = findVertex(G, idVertex)

// pastiin ketemu
if foundV != NULL then
sisi = firstEdge(foundV)
while (sisi != NULL) do
if (nextV(sisi) = foundV) then
return true
endif
sisi = next(sisi)
endwhile
endif
return false
function isSimple(G: Graph)  bool
{mengembalikan nilai boolean true jika graph G merupakan simple graph, dan false jika sebaliknya.}
//Balikin true kalau grafku GAPUNYA multiple edge dan loop!
Kamus
function hasMultipleEdges(G: Graph, idVertex: infotypeVertex)  bool
function hasLoop(G: Graph, idVertex: infotypeVertex)  bool
p : adrVertex
algoritma
p = first(G)
while (p != NULL) do
if (hasMultipleEdges(G, info(p)) or hasLoop(G, info(p))) then
//cek deh, ada multiple edge atau loop ga? Kalo ada SALAH SATUNYA AJA balikin false, selesein
fungsinya.
// ada multiple edge doang? keluarin false
// ada loop doang? Keluarin false
// ada dua duanya? False lah
return false
endif
p = next(p)
endwhile
// gaada dua duanya? Keluarin true
return true
Topik 2: Tree (BST)

Gambar 5. Tree

Dalam representasinya dengan Linked List, tree direpresentasikan sebagai berikut.

Gambar 6. Representasi Tree dengan Linked List

ADT
type infotype: int {sesuaikan}
type address: pointer to node
type node <
info: infotype
left, right: address
>
type tree <
root: address
>
Latihan

Lengkapi fungsi dan prosedur berikut

procedure addNode(in/out root: address, in X: infotype)
{
I.S. terdefinisi root dari tree (mungkin NIL), dan sebuah infotype X
F.S. node dengan info X ditambahkan ke dalam tree
}
kamus
function createNode(x: infotype)  address

algoritma
if root == NIL then
root = createNode(X) //Base Case
else if X < info(root) then
addNode(left(root), X)
else if X > info(root) then
addNode(right(root), X)
endprocedure

function findNode(root: address, X: infotype)  address

{Mengembalikan alamat dari dari root apabila memiliki info sama dengan X, atau NIL apabila tidak
ditemukan}
kamus
algoritma
if (root == NULL) then // base case 1
return NULL
// Cara baca base case 1: “Kalo tree gapunya root, balikin NULL”
else if (info(root) == X) then // base cacse 2
return root
// Cara baca base case 2: “Kalo info yang dicari sama dengan infonya root, balikin root”
else
if (X < info(root)) then
findNode(left(root), X)
//Cara baca if: kalo x lebi kecil, turun ke kiri
else
findNode(right(root), X)
//Cara baca else: kalo x lebi gede, turun ke kanan
endif
endif
endfunction

function height(root: address)  integer

{ mengembalikan jumlah edge terpanjang dari root menuju daun}
kamus

algoritma
if (root == NULL) then
return 0
else if (left(root) == NULL and right(root) == NULL) then
return 0
else
kiri = height(left(root))
kanan = height(right(root))
if (kiri > kanan) then
return 1 + kiri
//kalo height pas turun kiri lebih panjang, turuno ke kiri, dan tambahin height + 1
else
return 1 + kanan
//kalo height pas turun kiri lebih panjang, turuno ke kanan

endfunction

procedure preOrder(in root: address)

{
I.S. terdefinisi root dari tree (mungkin NIL)
F.S. tree ditampilkan secara preorder
}
kamus
algoritma
output(root)
preorder(left(root))
preorder(right(root))
endprocedure

procedure inOrder(in root: address)

{
I.S. terdefinisi root dari tree (mungkin NIL)
F.S. tree ditampilkan secara inorder
}
kamus
algoritma
inorder(left(root))
output(root)
inorder(right(root))
endprocedure

procedure postOrder(in root: address)

{
I.S. terdefinisi root dari tree (mungkin NIL)
F.S. tree ditampilkan secara postorder
}
kamus
algoritma
postorder(left(root))
postorder(right(root))
output(root)
endprocedure

procedure printDescendent(in root: address, x: infotype)

{
I.S. terdefinisi root dari tree (mungkin NIL)
F.S. descendent dari node dengan info X ditampilkan
}
kamus
function findNode(root: address, X: infotype)  address
procedure preOrder(in root: address)
p : address
algoritma
p = findNode(root,x)
if (p != NULL) then
preorder(p)
 endif
endprocedure

procedure printAncestors(in root: address, x: infotype)

{
I.S. terdefinisi root dari tree (mungkin NIL)
F.S. ascentors dari node dengan info X ditampilkan
}
kamus
algoritma
if (root != NULL and info(root)!=x) then
if (X < info(root)) then
printAncestors(left(root), x)
output(info(root))
else
printAncestors(right(root), x)
output(info(root))
endif
endif
endprocedure

procedure PrintLeftMost(in root: address)

algoritma

if (root != NULL) then

if (left(root) == NULL) then

return info(root)

else

PrintLeftMost(left(root))

endelse

endif

endprocedure