Struktur Data Modul 09 Circular Linked L

MODUL 09 – CIRCULAR LINKED LIST
I.

TUJUAN
- Mengenalkan linked list sirkular kepada praktikan.
- Praktikan
dapat
memahami
penggunaan
linked
list
sirkuler
dan
mengimplementasikannya ke dalam program sederhana dan
mampu
mengembangkannya.
II. DASAR TEORI
Linked list sirkuler adalah list yang jika ditelusuri maka nantinya akan kembali ke
simpul pertama dan tidak berhenti pada simpul terakhir. Di situlah letak perbedaan
linked list sirkuler dengan linked list linear. Kelebihan linked list sirkuler adalah setiap
simpul dari list ini dapat dicapai dari sembarang simpul yang lain.

Berikut adalah contoh pendeklarasian simpul linked list dalam bahasa C:
typedef int infotype;
typedef struct tNode *address;
typedef struct tNode
{ infotype info;
address Next;
} Node;

Linked list sirkuler bisa diilustrasikan sebagai berikut:

A

B

C

Operasi-operasi yang bisa dilakukan pada linked list sirkuler sama dengan operasioperasi pada linked list linear.
Prosedur penambahan node bisa dilakukan dengan 3 cara, yaitu insert first
(penambahan di depan), insert after (penambahan di tengah), dan insert last (penambahan
di akhir).

Sementara penghapusannya pun bisa dilakukan dengan 3 cara, yaitu delete first
(penghapusan depan), delete after (penghapusan di tengah), dan delete last (penghapusan
akhir).
Pada saat melakukan penelusuran pada linked list sirkuler harus diketahui terlebih
dahulu simpul pertamanya. Oleh karena itu biasanya digunakan linked list berkepala.
III. DEMO
Ketikkan program di bawah ini dan pahami cara kerjanya :
header.h
//FILE HEADER
#include
typedef struct tNode
{
int info;
tNode* next;
}Node;
typedef Node* address;

1

typedef struct

{
address first;
}List;
//header
void createEmpty(List &L);
//IS: L sembarang,
//FS: L terdefinisi dan kosong
bool isEmpty(List L);
//I: L terdefinisi,
//O: returnkan true jika L kosong, returnkan false jika isi
bool
//I:
//O:
//

isOneElmt(List L);
L terdefinisi tidak kosong,
returnkan true jika L Cuma berisi 1 node saja, returnkan false jika
berisi lebih dari 1 node

address alokasi(int X);
//I: X terdefinisi, ada isinya,
//O: returnkan alamat node baru yg info-nya=X dan next-nya NULL
address findLast(List L);
//I: L terdefinisi mungkin kosong
//O: returnkan node terakhir dari L, kalau L kosong returnkan NULL
address prevNode(List L, address P);
//I: L terdefinisi tdk kosong, P valid dalam L
//O: returnkan node dalam L sebelum P
void insertFirst(List &L, address P);
//IS: L terdefinisi, mungkin kosong, P alamat terdefinisi tdk NULL
//FS: Node yg alamatnya P menjadi node pertama dalam List L
void insertLast(List &L, address P);
//IS: L terdefinisi, mungkin kosong, P alamat terdefinisi tdk NULL
//FS: Node yg alamatnya P menjadi node terakhir dalam List L
void insVFirst(List &L, int X);
//IS: L terdefinisi, mungkin kosong, X value terdefinisi tdk kosong
//FS: Node baru yg info-nya=X menjadi node pertama dalam List L
void insVLast(List &L, int X);
//IS: L terdefinisi, mungkin kosong, X value terdefinisi tdk kosong

//FS: Node baru yg info-nya=X menjadi node terakhir dalam List L
void delFirst(List &L);
//IS: L terdefinisi, mungkin kosong
//FS: Node awal dalam List L terhapus, kalau L kosong tdk terjadi apa2
void delAll(List &L);
//IS: L terdefinisi, tidak kosong
//FS: Semua Node dalam List L terhapus, L menjadi kosong
void print(List L);
//IS: L terdefinisi, mungkin kosong
//FS: Semua info Node dari List L tercetak ke layar monitor
void printFrom(List L, address P);
//IS: L terdefinisi, tidak kosong, P alamat valid dari salah node dalam L
//FS: Semua info Node dari List L tercetak mulai dari P sampai ke prev ke
//
layar monitor

2

int nbNode(List L);
//I: L terdefinisi, mungkin kosong

//O: returnkan cacah (banyaknya) node dalam L
int nbNode2(List L); //nBNode versi 2
//I&O: sama dengan nbNode
bool
//I:
//O:
//

isFound(List L, int X);
L terdefinisi tidak kosong, X terdefinisi
returnkan true jika ada node dalam L yang info-nya=X, returnkan false
jika tidak

address search(List L, int X);
//I: L terdefinisi tidak kosong, X terdefinisi
//O: returnkan alamat node dalam L yang info-nya=X, returnkan NULL jika
//
tidak ada node seperti itu
List
//I:

//O:
//

Clone(List L);
L terdefinisi tidak kosong
returnkan List yg sama sekali baru dan yang info-info serta urutannya
sama persis dengan L

//FILE IMPLEMENTASI
#include "circularList.h"
//implementasi
void createEmpty(List &L)
{
L.first=NULL;
}
bool isEmpty(List L)
{
if(L.first==NULL) return true;
else return false;
}

bool isOneElmt(List L)
{
if(L.first->next==L.first) return true;
else return false;
}
address alokasi(int X)
{
address P;
P=new Node;
P->info=X;
P->next=NULL;
return P;
}
address findLast(List L)
{
address P;
if(isEmpty(L)) return NULL;
else
{
for(P=L.first;P->next!=L.first;P=P->next){}

return P;
}
}
address prevNode(List L, address P)
{
address temp;

3

for(temp=L.first;temp->next!=P;temp=temp->next){}
return temp;
}
void insertFirst(List &L, address P)
{
address last;
if(isEmpty(L))
{
L.first=P;
L.first->next=L.first;
}

else
{
last=findLast(L);
P->next=L.first;
L.first=P;
last->next=L.first;
}
}
void insertLast(List &L, address P)
{
address temp;
if(isEmpty(L)) insertFirst(L,P);
else
{
temp=findLast(L);
temp->next=P;
P->next=L.first;
}
}
void insVFirst(List &L, int X)

{
insertFirst(L,alokasi(X));
}
void insVLast(List &L, int X)
{
insertLast(L, alokasi(X));
}
void delFirst(List &L)
{
if(!isEmpty(L))
{
address last=findLast(L);
address P=L.first;
L.first=L.first->next;
last->next=L.first;//jika dari isOneElmt,
//maka last ini tdk ada artinya.. tapi tdk error
delete P;
}
}
void delAll(List &L)
{
while(!isEmpty(L)) delFirst(L);
}
void print(List L)
{
if(!isEmpty(L))
{
address P=L.first;
do{
coutnext){}
if(P!=last) return P;
else if(last->info==X) return last;

5

else return NULL;
}
}
List Clone(List L)
{
List temp; address
P,last;
createEmpty(temp);
if(!isEmpty(L))
{
last=findLast(L);
for(P=L.first;P->next!=L.first;P=P->next)
insVLast(temp,P->info);
insVLast(temp,last->info);
}
return temp;
}

//FILE MAIN
#include "circularList.h"
void main()
{
List LC;
createEmpty(LC);
insVLast(LC,10);
insVLast(LC,11);
insVLast(LC,12);
insVLast(LC,13);
insVLast(LC,14);
insVFirst(LC,9);
print(LC);
int x=nbNode(LC);
address y=findLast(LC);
cout