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 operasi-
operasi 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 <iostream.h>

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 isOneElmt(List L);

//I: L terdefinisi tidak kosong,
//O: 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 isFound(List L, int X);

//I: L terdefinisi tidak kosong, X terdefinisi
//O: 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 Clone(List L);

//I: L terdefinisi tidak kosong
//O: 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{
cout<<P->info<<" ";
P=P->next;

4
 }while(P!=L.first);

cout<<endl;
}
}
void printFrom(List L, address P)
{
address prev=prevNode(L,P);
for(address a=P;a!=prev;a=a->next)
{
cout<<a->info<<" ";
}
cout<<prev->info<<endl;
}
int nbNode(List L)
{
int cacah=0;
if(isEmpty(L)) return 0;
else
{
for(address P=L.first;P->next!=L.first;P=P->next) cacah++;
return ++cacah; //plus one first for last node before return
//bisa gunakan do while, tanpa ++ lagi
}
}
int nbNode2(List L) //nBNode versi 2
{
int cacah=0;
address P=L.first;
if(!isEmpty(L))
{
do
{
cacah++;
P=P->next;
}while(P!=L.first);
}
return cacah;
}
bool isFound(List L, int X)
{
address P;
address last;
if(isEmpty(L)) return false;
else
{
last=findLast(L);
for(P=L.first;P!=last&&P->info!=X;P=P->next){}
return P->info==X || last->info==X; //X is either in last node
//or other nodes, if none then return false
}
}
address search(List L, int X)
{
address P;
address last;
if(isEmpty(L)) return NULL;
else
{
last=findLast(L);
for(P=L.first;P!=last && P->info!=X;P=P->next){}
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<<"Banyaknya node : "<<x<<endl;
cout<<"Node terakhir : "<<y->info<<endl;
address z=search(LC,13);
if(z!=NULL) cout<<"Isi z (by search) adalah : "<<z->info<<endl;
else cout<<"tdk ditemukan by search"<<endl;
if(isFound(LC,9)) cout<<"isFound menemukan"<<endl;
else cout<<"tdk ditemukan by isFound"<<endl;
printFrom(LC,z);
}