Link List

LINK LIST
Linked list adalah sekumpulan elemen bertipe sama, yang mempunyai keterurutan tertentu, yang setiap
elemennya terdiri dari dua bagian Linked list juga merupakan suatu cara untuk menyimpan data dengan
struktur sehingga dapat secara otomatis menciptakan suatu tempat baru untuk menyimpan data
yangdiperlukan. Struktur ini lebih dinamis karena banyaknya elemen dengan mudah ditambah atau
dikurangi, berbeda dengan array yang ukurannya tetap. berikut gambaran kecil mengenai linked list.

Didalam Linked List terdapat beberapa bagian lagi.

1. Linked List Circular
Double Linked List
Pengertian secara umumnya DLLC itu Linked list yang menggunakan pointer, dimana setiap node
memiliki 3 field, yaitu:
1 field pointer yang menunjuk pointer berikutnya "next",
1 field menunjuk pointer sebelumnya " prev ",
1 field yang berisi data untuk node tersebut .
Double Linked List Circular pointer next dan prev nya menunjuk kedirinya sendiri secara circular. Bentuk
Node DLLC

contoh program Double Linked List

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
struct node
{
struct node *prev;
int data;
struct node *next;
};
typedef struct node node;
node *pHead = NULL;
node *alokasiNodeBaru()
{

node *pNew = NULL;

pNew = (node *) malloc(sizeof(node));
return(pNew);
}
void tambahAwal(node *pNew)
{
printf("masukkan bilangan: "); scanf("%d",&pNew->data);
if(pHead == NULL)
{
pNew->prev = pHead;
pNew->next = pHead;
pHead = pNew;
}
else
{
//cari node yang menunjuk ke pHead
pNew->prev = pHead;
pNew->next = pHead;
pHead->prev= pNew;
pHead = pNew;
}
}
void cetak()
{
node *pWalker = pHead; int i=1;
while(pWalker!=NULL)
{
printf("node ke-%d = %d\n",i,pWalker->data);
i++;
pWalker=pWalker->next;
}
printf("NULL\n");
}
void tambahTengah(node *pNew)
{
node *pWalker;
pWalker=pHead;
int nilai,sisip;
printf("masukkan nilai yang ingin ditambahkan: "); scanf("%d",&pNew->data);
cetak();
printf("data disisipkan setelah nilai : "); scanf("%d",&sisip);
while(pWalker!=NULL && pWalker->data!=sisip)
{
pWalker=pWalker->next;
}
if(pWalker==NULL) {printf("\ndata tidak ditemukan"); getch();
}
else

{
pNew->next=pWalker->next;
pWalker->next->prev=pNew;
pWalker->next=pNew;
pNew->prev=pWalker;
}
}
void tambahAkhir(node *pNew)
{
node *pEnd;
pEnd=pHead;
printf("masukkan nilai yang ingin ditambahkan: "); scanf("%d",&pNew->data);
while(pEnd->next!=NULL)
{
pEnd=pEnd->next;
}
pEnd->next=pNew;
pNew->prev=pEnd;
pNew->next=NULL;
}
void hapusAwal()
{
node *pHapus;
pHapus=pHead;
pHead=pHead->next;
pHead->prev=NULL;
free(pHapus);
}
void hapusTengah()
{
node *pCari;int hapus;
pCari=pHead;
cetak();
printf("masukkan bilangan yang ingin dihapus: "); scanf("%d",&hapus);
while(pCari!=NULL && pCari->data!=hapus)
{
pCari=pCari->next;
}
pCari->prev->next=pCari->next;
pCari->next->prev=pCari->prev;
free(pCari);
}
void hapusAkhir()
{
node *pEnd;
pEnd=pHead;
while(pEnd->next!=NULL)
{
pEnd=pEnd->next;
}
pEnd->prev->next=NULL;

free(pEnd);
}
int main(int argc, char *argv[])
{
node *pNew; int pilih,bil;
do{system("cls");
printf("----------MENU-----------");
printf("\n1.tambah awal");
printf("\n2.tambah tengah");
printf("\n3.tambah akhir");
printf("\n4.hapus awal ");
printf("\n5.hapus tengah");
printf("\n6.hapus akhir");
printf("\n7.cetak");
printf("\n9.exit");
printf("\npilihan : ");scanf("%d",&pilih);
if(pilih==1){pNew=alokasiNodeBaru();
tambahAwal(pNew);
}
else if(pilih==2){pNew=alokasiNodeBaru();
tambahTengah(pNew);
}
else if(pilih==3){pNew=alokasiNodeBaru();
tambahAkhir(pNew);
}
else if(pilih==4){hapusAwal();
}
else if(pilih==5){hapusTengah();
}
else if(pilih==6){hapusAkhir();
}
else if(pilih==7){cetak();getch();
}
}
while(pilih!=9);
printf("\n");
system("PAUSE");
return 0;
}
Single Linked List
Single Linked List Circular (SLLC) adalah Single Linked List yang pointer nextnya menunjuk pada
dirinya sendiri. Jika Single Linked List tersebut terdiri dari beberapa node, maka pointer next pada node
terakhir akan menunjuk ke node terdepannya.

contoh program Single Linked List

// Program for singly linked Circular list #include <iostream>
#include <string> struct SLinkCircularList
{
std::string data;
SLinkCircularList *next;
SLinkCircularList() : data(""), next(this)
{
}
SLinkCircularList(const char *value) : data(value), next(this)
{
} SLinkCircularList* InsertNext(const char *data)
{
SLinkCircularList *node = new SLinkCircularList(data);
if(this->next == this) // only one node in the circular list
{
// Easy to handle, after the two lines of executions,
// there will be two nodes in the circular list
node->next = this;
this->next = node;
}
else
{
// Insert in the middle
SLinkCircularList *temp = this->next;
node->next = temp;
this->next = node;
}
return node;
} bool DeleteNext()
{
if(this->next == this)
{
std::cout << "\nThe node can not be deleted as there is only one node in the circular list\n";
return false;
}
SLinkCircularList *pNode = this->next;
this->next = this->next->next;
delete pNode;
} void Traverse(SLinkCircularList *node = NULL)
{
if(node == NULL)
node = this;

std::cout << "\n\nTraversing in Forward Direction\n\n";

SLinkCircularList *startnode = node;
do
{
std::cout << node->data;
std::cout << "\n";
node = node->next;
}
while(node != startnode);
} int GetNumberOfNodes(SLinkCircularList *node = NULL)
{
if(node == NULL)
node = this;
int count = 0;
SLinkCircularList *startnode = node;
do
{
count++;
node = node->next;
}
while(node != startnode);
std::cout << "\nCurrent Node Value: " << node->data.c_str();
std::cout << "\nTotal nodes in Circular List: " << count;
std::cout << "\n";
return count;
}
}; int main()
{
SLinkCircularList *node1 = new SLinkCircularList("ONE");
node1->DeleteNext(); // Delete will fail in this case.
SLinkCircularList *node2 = node1->InsertNext("TWO");
node1->DeleteNext(); // It will delete the node2.
node2 = node1->InsertNext("TWO"); // Insert it again
SLinkCircularList *node3 = node2->InsertNext("THREE");
SLinkCircularList *node4 = node3->InsertNext("FOUR");
SLinkCircularList *node5 = node4->InsertNext("FIVE");
node1->GetNumberOfNodes();
node3->GetNumberOfNodes();
node5->GetNumberOfNodes();
node1->Traverse();
node3->DeleteNext(); // delete the node "FOUR"
node2->Traverse();
std::cout << "\n";
node1->GetNumberOfNodes();
node3->GetNumberOfNodes();
node5->GetNumberOfNodes();

std::cout << "\n";

return 0;
}
2. Linked List Non Circular Double Linked List Non Circular (DLLNC)
adalah Double Linked List yang memiliki 2 buah pointer yaitu pointernext dan prev. Pointer next
menunjuk pada node setelahnya dan pointer prev menunjuk pada node sebelumnya.
Pengertian:
Double : artinya field pointer-nya dua buah dan dua arah, ke node sebelum dan sesudahnya.
Linked
List
:
artinya
node-node
tersebut
saling
terhubung
satu
sama
lain.
Non Circular : artinya pointer prev dan next-nya akan menunjuk pada NULL.

Single Linked List Non Circular (SLLNC)

Adalah Linked List yang pointer nya selalu mengarah ke Node yang menampung *next bernilai
NULL, jadi arahnya tidak menunjuk pointer didepannya sehingga tidak dapat kembali ke pointer - pointer
sebelumnya. SLLNC ini juga memiliki 2 bagian, ada Tambah dan ada Hapus, masing - masing bagian ini
juga masih meliputi 3 fungsi lain yaitu Belakang, Tengah, dan depan. untuk Contoh Tambah & Hapus
(Depan & belakang).

Contoh Program Single Linked List Non Circular (Tambah : Depan & belakang dan Hapus : Depan &
Belakang)
#include <iostream.h>
#include <conio.h>
#include <stdio.h>
#include <alloc.h>
int pil;
void pilih();
void buat_baru();
void tambah_belakang();
void tambah_depan();
void hapus_belakang();
void hapus_depan();
void tampil();

struct simpul
{
char nim[8], nama [20];
int umur;
struct simpul *next;
} mhs, *baru, *awal=NULL, *akhir=NULL,*hapus,*bantu;
int main()
{
do
{
clrscr();
cout<<"MENU SINGLE LINKEDLIST"<<endl;
cout<<"1. Tambah Depan"<<endl;
cout<<"2. Tambah Belakang"<<endl;
cout<<"3. Hapus Depan"<<endl;
cout<<"4. Hapus Belakang"<<endl;
cout<<"5. Tampilkan"<<endl;
cout<<"6. Selesai"<<endl;
cout<<"Pilihan Anda : ";
cin>>pil;
pilih();
} while(pil!=6);
return 0;
}
void pilih()
{
if(pil==1)
tambah_depan();
else if(pil==2)
tambah_belakang();
else if(pil==3)
hapus_depan();
else if(pil==4)
hapus_belakang();
else if(pil==5)
tampil();
else
cout<<"selesai";
}
void buat_baru()
{
baru=(simpul*)malloc(sizeof(struct simpul));
cout<<"input nim : ";cin>>baru->nim;
cout<<"input nama : ";cin>>baru->nama;
cout<<"input umur : ";cin>>baru->umur;
baru->next=NULL;
}
void tambah_belakang()
{
buat_baru();
if(awal==NULL)

{
awal=baru;
}
else
{
akhir->next=baru;
}
akhir=baru;
akhir->next=NULL;
cout<<endl<<endl;
tampil();
}
void tambah_depan()
{
buat_baru();
if(awal==NULL)
{
awal=baru;
akhir=baru;
akhir->next=NULL;
}
else
{
baru->next=awal;
awal=baru;
}
cout<<endl<<endl;
tampil();
}
void hapus_depan()
{
if (awal==NULL)
cout<<"Kosong";
else
{
hapus=awal;
awal=awal->next;
free(hapus);
}
cout<<endl<<endl;
tampil();
}
void hapus_belakang()
{
if (awal==NULL)
cout<<"Kosong";
else if(awal==akhir)
{
hapus=awal;
awal=awal->next;
free(hapus);

}
else
{
hapus=awal;
while(hapus->next!=akhir)
hapus=hapus->next;
akhir=hapus;
hapus=akhir->next;
akhir->next=NULL;
free(hapus);
}
cout<<endl<<endl;
tampil();
}
void tampil()
{
if (awal==NULL)
cout<<"Kosong";
else
{
bantu=awal;
while(bantu!=NULL)
{
cout<<"nim : "<<bantu->nim;
cout<<" nama : "<<bantu->nama;
cout<<" umur : "<<bantu->umur<<endl;
bantu=bantu->next;
}
}
getch();
}

LINKED LIST
ARRAY : Struktur Data yang sangat membantu dalam pemograman, tetapi array memiliki 2
keterbatasan
1. Mengubah ukuran array, harus membuat array baru dan meng-copy semua data dari array
dengan ukuran lama ke array dengan ukuran baru. (penambahan/penghapusan data di
array tidak mungkin dapat dilakukan, demikian pula menghapus array adalah tidak
mungkin)
2. Data dalam array merupakan berurutan (sequential) berikutnya ke setiap data yang
lainnya didalam memory sehingga menyisipkan sebuat item ke dalam array
membutuhkan pemindahan data lain dalam array ini (statis)
Keterbatasan ini dapat diatasi dengan menggunakan struktur data linked list
Sejarah linked list :
1. Dikembangkan tahun 1955-1956 oleh Allen Newel, Cliff Shaw dan Herbert Simon di
Rand Corporation, sebagai struktur data utama untuk bahasa information processing
language (IPL). IPLS dibuat untuk mengembankan program artificial intelligence, seperti
pembuatan chess solver.
2. Victor Yngve di Massachussetts Institute of Technology (MIT) juga menggunakan
Linked List pada natural language processing dan machine transitions pada bahasa
pemograman commit.
Linked list adalah salah satu bentuk struktur data berisi kumpulan data (node) yang tersusun
secara sekuensial, saling sambung menyambung, dinamis dan terbatas. Linked List disebut juga
senarai berantai. Struktur Linked List adalah sejumlah node yang menyampaikan data dan
menghubungkan (Links) ke node yang lain.
Node (simpul) dapat dialokasikan ke bebarapa tempat/lokasi di memory dan melewatkan (pass)
dari node struktur linked list yang satu ke node yang lain dengan menyimpan refrensi ke node
yang lainnya dalam struktur linked list.
Linked list saling terhubungkan dengan variable pointer. Masing-masing data dalam Linked List
disebut dengan node (simpul) yang menempati alokasi memory secara dinamis dan biasanya
berupa struct (dalam bahasa C/C++) atau Record (dalam bahasa Pascal) atau Class (dalam
bahasa Java) yang terdiri dari beberapa field. Bentuk umum node single linked list :

Menempati alamat memory tertentu

Ilustrasi single list dari bilangan bulat (integral)
Deklarasi Node dalam bahasa C :
Typedef stmct TNode {
Int data;
TNode * Next;
};
Keterangan :
Pembuatan STMCT bernama TNode yang berisi 2 field, yaitu field data bertipe integer
dan field next yang bertipe pointer dari TNode
Setelah pembuatan struct, buat variable head yang bertipe pointer dari TNode yang
berguna sebagai kepala Linked List.
Deklarasai node dalam bahasa Pascal :
Type perubah = ^simpul;
Simpul = record
Info : tipe;
Berikut : perubah
End;
Dimana perubah adalah nama variable yang bertipe pointer
Simpul : nama simpul (Node)
Info : nama medan dari data yang bisa bertipe sembarang
Tipe : tipe data masing-masing medan (bisa integer, float, dsb)
Berikut : nama medan yang bertipe data pointer
Penerapan Linked List dalam bahasa Java

//***SL Node Java***

//Deklarasi class node
Public Class SLLNode <T> next;
Public SLL Node () {
Next=null;
}
Public SLLNode (Tel) {
Info=el;next=null;
}
Public SLLNode (Tel,
SLLNode <T>ptr{
Info=el;next=ptr;
}
}
//***SLL.JAVA***
//Proses Linked List
Public Class SLL<T>{
Protected SLLNode<T>head, tail;
Public SLL(){
Head=tail=null;//deklarasi head&tail
}
Public Boolean is empty () {
Return head==null;

}
Public boid add To Head (Tel) {
Head=new SLLNode<T>(el,head);
If (tail==null)
Tail=head;//Tambah node dari depan
}
Public boid add To Tail (Tel) {
If (!isEmpty()) {
Tail.next=new SLLNode<T> (el);
Tail=tail.next; //tambah node dari belakang
}
Else head=tail=new SLLNode<T>(el);
}
Public T delete Form Head () {
If (IsEmpty())
Return null;
Tel=head.info;
If (head==fail)
Head=tail=null;
Else head=head.next;
Return el;
}
Public TdeleteFromTaill() }

If (IsEmpty ())
Return null;
Tel=tail.info;
If (head==tail)
Head=tail=null;
Else {
SLLNode<T>tmp;
For (tmp=head;temp.next!=fail;tmp=tmp.next);
Tail=tmp;
Tail.next=null;
}
Return el;
}
Public void delete(Tel){
If (!IsEmpty())
If (head==tail&&el==head.info)
Head=tail=null;
Else if (el==head.info)
Head=head.next;
Else {
SLLNode<T>pred,tmp;
For(pred=head,temp=head.next;tmp!null&&temp.info!=el;pred=pred.next,tmp=tmp.next);
If (tmp!=null) {

Pred.next=tmp.next;
If (tmp==tail)
Tail=pred
}
}
}
Public Boolean IslnList (Tel) {
SLLNode <T> tmp;
For (tmp=head;tmp!=null&&tmp.info!=el;tmp=tmp.next);
Return tmp!=null;
}
}
Double Linked List Non Circular

DLLNC adalah Double Linked List yang memiliki 2 buah pointer yaitu pointer next dan
prev. Pointer next menunjuk pada node setelahnya dan pointer prev menunjuk pada node
sebelumnya.

Pengertian:
o Double : artinya field pointer-nya dua buah dan dua arah, ke node sebelum dan
sesudahnya.
o Linked List : artinya node-node tersebut saling terhubung satu sama lain.
o Non Circular : artinya pointer prev dan next-nya akan menunjuk pada NULL.

Ilustrasi DLLNC

Setiap node pada linked list mempunyai field yang berisi data dan pointer ke node
berikutnya & ke node sebelumnya

Untuk pembentukan node baru, mulanya pointer next dan prev akan menunjuk ke nilai
NULL.

Selanjutnya pointer prev akan menunjuk ke node sebelumnya, dan pointer next akan
menunjuk ke node selanjutnya pada list.

Deklarasi dan node baru DLLNC

Deklarasi node
Dibuat dari struct berikut ini:
typedef struct TNode{
int data;
TNode *next;
Tnode *prev;
};
Pembentukan node baru
Digunakan keyword new yang berarti mempersiapkan sebuah node baru berserta alokasi
memorinya.

TNode *baru;

baru = new TNode;

baru->data = databaru;

baru->next = NULL;

baru->prev = NULL;

DLLNC dengan HEAD

Dibutuhkan satu buah variabel pointer: head

Head akan selalu menunjuk pada node pertama

Deklarasi Pointer Penunjuk Kepala Double Linked List

Manipulasi linked list tidak bisa dilakukan langsung ke node yang dituju, melainkan
harus melalui node pertama dalam linked list. Deklarasinya sebagai berikut:

TNode *head;

Fungsi Inisialisasi Single LinkedList Circular

void init(){
o head = NULL;

Function untuk mengetahui kosong tidaknya DLLNC

int isEmpty(){

if(head == NULL) return 1;

else return 0;

Penambahan data di depan

Penambahan node baru akan dikaitan di node paling depan, namun pada saat pertama
kali (data masih kosong), maka penambahan data dilakukan pada head nya.

Pada prinsipnya adalah mengkaitkan data baru dengan head, kemudian head akan
menunjuk pada data baru tersebut sehingga head akan tetap selalu menjadi data terdepan.
Untuk menghubungkan node terakhir dengan node terdepan dibutuhkan pointer bantu.

DLLNC menggunakan Head

void insertDepan(int databaru){

TNode *baru;

baru = new TNode;

baru->data = databaru;

baru->next = NULL;

baru->prev = NULL;

if(isEmpty()==1){

head=baru;

head->next = NULL;

head->prev = NULL;

else {

baru->next = head;

head->prev = baru;

head = baru;

cout<<Data masuk\n;

Penambahan data di belakang

Penambahan data dilakukan di belakang, namun pada saat pertama kali data langsung
ditunjuk pada head-nya.

Penambahan di belakang lebih sulit karena kita membutuhkan pointer bantu untuk
mengetahui data terbelakang, kemudian dikaitkan dengan data baru. Untuk mengetahui
data terbelakang perlu digunakan perulangan.

void insertBelakang (int databaru){

TNode *baru,*bantu;

baru = new TNode;

baru->data = databaru;

baru->next = NULL;

baru->prev = NULL;

if(isEmpty()==1){

head=baru;

head->next = NULL;

head->prev = NULL;

else {

bantu=head;

while(bantu->next!=NULL){

bantu=bantu->next;

bantu->next = baru;

baru->prev = bantu;

cout<<Data masuk\n;

Function untuk menampilkan isi DLLNC

void tampil(){

TNode *bantu;

bantu = head;

if(isEmpty()==0){

while(bantu!=NULL){

cout<<bantu->data<< ;

bantu=bantu->next;

cout<<endl;

} else cout<<Masih kosong\n;

Bagaimana cara membaca data list secara terbalik?

Function untuk menghapus data di depan:

void hapusDepan (){

TNode *hapus;

int d;

if (isEmpty()==0){

if(head->next != NULL){

hapus = head;

d = hapus->data;

head = head->next;

head->prev = NULL;

delete hapus;

} else {

d = head->data;

head = NULL;

cout<<d<< terhapus\n;

} else cout<<Masih kosong\n;

Function untuk menghapus node terbelakang

void hapusBelakang(){

TNode *hapus;

int d;

if (isEmpty()==0){

if(head->next != NULL){

hapus = head;

while(hapus->next!=NULL){

hapus = hapus->next;

d = hapus->data;

hapus->prev->next = NULL;

delete hapus;

} else {

d = head->data;

head = NULL;

cout<<d<< terhapus\n;

} else cout<<Masih kosong\n;

Tidak diperlukan pointer bantu yang mengikuti pointer hapus yang berguna untuk
menunjuk ke NULL

Karena pointer hapus sudah bisa menunjuk ke pointer sebelumnya dengan menggunakan
elemen prev ke node sebelumnya, yang akan diset agar menunjuk ke NULL setelah
penghapusan dilakukan.

Function untuk menghapus semua elemen

void clear(){

TNode *bantu,*hapus;

bantu = head;

while(bantu!=NULL){

hapus = bantu;

bantu = bantu->next;

delete hapus;

head = NULL;

DLLNC dengan HEAD dan TAIL

Dibutuhkan dua buah variabel pointer: head dan tail

Head akan selalu menunjuk pada node pertama, sedangkan tail akan selalu menunjuk
pada node terakhir.

Inisialisasi DLLNC

TNode *head, *tail;

Fungsi Inisialisasi DLLNC

void init(){
o head = NULL;
o tail = NULL;

Function untuk mengetahui kosong tidaknya DLLNC

int isEmpty(){

if(tail == NULL) return 1;

else return 0;

Tambah Depan

void insertDepan (int databaru){

TNode *baru;

baru = new TNode;

baru->data = databaru;

baru->next = NULL;

baru->prev = NULL;

if(isEmpty()==1){

head=baru;

tail=head;

head->next = NULL;

head->prev = NULL;

tail->prev = NULL;

tail->next = NULL;

else {

baru->next = head;

head->prev = baru;

head = baru;

cout<<Data masuk\n;

Penambahan node di belakang

Penambahan node di belakang akan selalu dikaitkan dengan tail dan kemudian
node baru tersebut akan menjadi tail

void insertBelakang(int databaru){

TNode *baru;

baru = new TNode;

baru->data = databaru;

baru->next = NULL;

baru->prev = NULL;

if(isEmpty()==1){

head=baru;

tail=head;

head->next = NULL;

head->prev = NULL;

tail->prev = NULL;

tail->next = NULL;

else {

tail->next = baru;

baru->prev = tail;

tail = baru;

tail->next = NULL;

cout<<Data masuk\n;

Function untuk menampilkan isi linked list

void tampil(){

TNode *bantu;

bantu = head;

if(isEmpty()==0){

while(bantu!=tail->next){

cout<<bantu->data<< ;

bantu=bantu->next;

cout<<endl;

} else cout<<Masih kosong\n;

Function untuk menghapus data di data terdepan

void hapusDepan(){

TNode *hapus;

int d;

if (isEmpty()==0){

if(head->next != NULL){

hapus = head;

d = hapus->data;

head = head->next;

head->prev = NULL;

delete hapus;

} else {

d = head->data;

head = NULL;

tail = NULL;

cout<<d<< terhapus\n;

} else cout<<Masih kosong\n;

Function untuk menghapus node terbelakang

void hapusBelakang(){

TNode *hapus;

int d;

if (isEmpty()==0){

if(head->next != NULL){

hapus = tail;

d = tail->data;

tail = tail->prev;

tail->next = NULL;

delete hapus;

} else {

d = head->data;

head = NULL;

tail = NULL;

cout<<d<< terhapus\n;

} else cout<<Masih kosong\n;

Pointer hapus tidak perlu di loop untuk mencari node terakhir. Pointer hapus hanya perlu
menunjuk pada pointer tail saja.

Karena pointer hapus sudah bisa menunjuk ke pointer sebelumnya dengan menggunakan
elemen prev, maka pointer prev hanya perlu diset agar menunjuk ke NULL. Lalu pointer
hapus didelete.

Function untuk menghapus semua elemen LinkedList

void clear(){

TNode *bantu,*hapus;

bantu = head;

while(bantu!=NULL){

hapus = bantu;

bantu = bantu->next;

delete hapus;

head = NULL;

tail = NULL;

Menggunakan pointer bantu yang digunakan untuk bergerak sepanjang list, dan
menggunakan pointer hapus yang digunakan untuk menunjuk node-node yang akan
dihapus.

Pada saat pointer hapus menunjuk pada node yang akan dihapus, pointer bantu akan
bergerak ke node selanjutnya, dan kemudian pointer hapus akan didelete.

Single Linked List Circular

SLLC adalah Single Linked List yang pointer nextnya menunjuk pada dirinya sendiri.
Jika Single Linked List tersebut terdiri dari beberapa node, maka pointer next pada node
terakhir akan menunjuk ke node terdepannya.

Pengertian:
o Single : artinya field pointer-nya hanya satu buah saja dan satu arah.

o Linked List : artinya node-node tersebut saling terhubung satu sama lain.
o Circular : artinya pointer next-nya akan menunjuk pada dirinya sendiri sehingga
berputar
Ilustrasi SLLC

Setiap node pada linked list mempunyai field yang berisi pointer ke node berikutnya, dan
juga memiliki field yang berisi data.

Pada akhir linked list, node terakhir akan menunjuk ke node terdepan sehingga linked list
tersebut berputar.

Deklarasi dan node baru SLLC

Deklarasi node
Dibuat dari struct berikut ini:
typedef struct TNode{
int data;
TNode *next;
};
Pembentukan node baru
Digunakan keyword new yang berarti mempersiapkan sebuah node baru
berserta alokasi memorinya.
TNode *baru;
baru = new TNode;
baru->data = databaru;
baru->next = baru;
SLLC dengan HEAD

Dibutuhkan satu buah variabel pointer: head

Head akan selalu menunjuk pada node pertama

Deklarasi Pointer Penunjuk Kepala Single

Linked List

Manipulasi linked list tidak bisa dilakukan langsung ke node yang dituju, melainkan
harus melalui node pertama dalam linked list. Deklarasinya sebagai berikut:

TNode *head;
Fungsi Inisialisasi Single LinkedList Circular
void init(){
head = NULL;
}
Function untuk mengetahui kosong tidaknya SLLC
int isEmpty(){
if(head == NULL) return 1;
else return 0;
}
Penambahan data di depan

Penambahan node baru akan dikaitan di node paling depan, namun pada saat pertama
kali (data masih kosong), maka penambahan data dilakukan pada head nya.

Pada prinsipnya adalah mengkaitkan data baru dengan head, kemudian head akan
menunjuk pada data baru tersebut sehingga head akan tetap selalu menjadi data terdepan.
Untuk menghubungkan node terakhir dengan node terdepan dibutuhkan pointer bantu.

void insertDepan(int databaru){

TNode *baru,*bantu;
baru = new TNode;
baru->data = databaru;

baru->next = baru;
if(isEmpty()==1){
head=baru;
head->next=head;
}
else {
bantu = head;
while(bantu->next!=head){
bantu=bantu->next;
}
baru->next = head;
head = baru;
bantu->next = head;
}
printf(Data masuk\n);
}
Penambahan data di belakang

Penambahan data dilakukan di belakang, namun pada saat pertama kali data langsung
ditunjuk pada head-nya.

Penambahan di belakang lebih sulit karena kita membutuhkan pointer bantu untuk
mengetahui data terbelakang, kemudian dikaitkan dengan data baru. Untuk mengetahui
data terbelakang perlu digunakan perulangan.

void insertBelakang (int databaru){

TNode *baru,*bantu;
baru = new TNode;

baru->data = databaru;
baru->next = baru;
if(isEmpty()==1){
head=baru;
head->next=head;
}
else {
bantu = head;
while(bantu->next != head){
bantu=bantu->next;
}
bantu->next = baru;
baru->next = head;
}
printf(Data masuk\n);
}
Function untuk menampilkan isi single linked list
void tampil(){
TNode *b;
b = head;
if(isEmpty()==0){
do{
printf(%d ,b->data);

b=b->next;
}while(b!=head);
printf(\n);
} else printf(Masih kosong\n);
}
void hapusDepan (){
TNode *hapus,*bantu;
if (isEmpty()==0){
int d;
hapus = head;
d = head->data;
if(head->next != head){
bantu = head;
while(bantu->next!=head){
bantu=bantu->next;
}
head = head->next;
delete hapus;
bantu->next = head;
}else{
head=NULL;
}
printf(%d terhapus\n,d);

} else printf(Masih kosong\n);

}
void hapusBelakang(){
TNode *hapus,*bantu;
if (isEmpty()==0){
int d;
hapus = head;
if(head->next == head){
head = NULL;
}else{
bantu = head;
while(bantu->next->next != head){
bantu = bantu->next;
}
hapus = bantu->next;
d = bantu->data;
bantu->next = head;
delete hapus;
}
printf(%d terhapus\n,d);
} else printf(Masih kosong\n);
}
Function untuk menghapus semua elemen Linked List

void clear(){
TNode *bantu,*hapus;
bantu = head;
while(bantu->next!=head){
hapus = bantu;
bantu = bantu->next;
delete hapus;
}
head = NULL;
}

Dibutuhkan dua buah variabel pointer: head dan tail

Head akan selalu menunjuk pada node pertama, sedangkan tail akan selalu menunjuk
pada node terakhir.

SLLC dengan HEAD dan TAIL

Inisialisasi SLLC
TNode *head, *tail;
Fungsi Inisialisasi SLLC
void init(){
head = NULL;
tail = NULL;
}
Function untuk mengetahui kosong tidaknya SLLC
int isEmpty(){
if(tail == NULL) return 1;

else return 0;
}
Pengkaitan node baru ke linked list di depan
Penambahan data baru di depan akan selalu menjadi head.
void insertDepan(int databaru){
TNode *baru;
baru = new TNode;
baru->data = databaru;
baru->next = baru;
if(isEmpty()==1){
head=baru;
tail=baru;
head->next=head;
tail->next=tail;
}
else {
baru->next = head;
head = baru;
tail->next = head;
}
printf(Data masuk\n);
}
void tambahBelakang(int databaru){

TNode *baru;
baru = new TNode;
baru->data = databaru;
baru->next = baru;
if(isEmpty()==1){
head=baru;
tail=baru;
head->next=head;
tail->next=tail;
}
else {
tail->next = baru;
tail = baru;
tail->next = head;
}
cout<<Data masuk\n;
}
Function untuk menampilkan isi linked list:
void tampil(){
TNode *b;
b = head;
if(isEmpty()==0){
do{

printf(%d,b->data);
b=b->next;
}while(b!=tail->next);
printf(\n);
} else printf(Masih kosong\n);
}
Function untuk menghapus data di depan
void hapusDepan(){
TNode *hapus;
if (isEmpty()==0){
int d;
hapus = head;
d = head->data;
if(head != tail){
hapus = head;
head = head->next;
tail->next = head;
delete hapus;
}else{
head=NULL;
tail=NULL;
}
printf(%d terhapus\n,d);

} else printf(Masih kosong\n);

}

Function di atas akan menghapus data terdepan (pertama) yang ditunjuk oleh head pada
linked list

Penghapusan node tidak boleh dilakukan jika keadaan node sedang ditunjuk oleh pointer,
maka harus dilakukan penunjukkan terlebih dahulu dengan variabel hapus pada head,
kemudian dilakukan pergeseran head ke node berikutnya sehingga data setelah head
menjadi head baru, kemudian menghapus variabel hapus dengan menggunakan perintah
delete.

Jika tail masih NULL maka berarti data masih kosong!

Function untuk menghapus data di belakang:

void hapusBelakang(){
TNode *hapus,*bantu;
if (isEmpty()==0){
int d;
if(head == tail){
d = tail->data;
head = NULL;
tail = NULL;
}else{
bantu = head;
while(bantu->next != tail){
bantu = bantu->next;
}
hapus = tail;
tail = bantu;

d = hapus->data;
tail->next = head;
delete hapus;
}
printf(%d terhapus\n,d);
} else printf(Masih kosong\n);
}

Function di atas akan menghapus data terbelakang (terakhir) yang ditunjuk oleh tail
pada linked list

Penghapusan node tidak boleh dilakukan jika keadaan node sedang ditunjuk oleh pointer,
maka harus dilakukan penunjukkan terlebih dahulu dengan variabel hapus pada tail,
kemudian dibutuhkan pointer bantu untuk membantu pergeseran dari head ke node
berikutnya sampai sebelum tail, sehingga tail dapat ditunjukkan ke bantu tersebut, dan
bantu tersebut akan menjadi tail yang baru. Setelah itu hapus variabel hapus dengan
menggunakan perintah delete.

Jika tail masih NULL maka berarti data masih kosong!

Function untuk menghapus semua elemen LinkedList

void clear(){
TNode *bantu,*hapus;
if(isEmpty() == 0){
bantu = head;
while(bantu->next!=head){
hapus = bantu;
bantu = bantu->next;
delete hapus;
}

head = NULL;
tail = NULL;
}
}

Menggunakan pointer bantu yang digunakan untuk bergerak sepanjang list, dan
menggunakan pointer hapus yang digunakan untuk menunjuk node-node yang akan
dihapus.

Pada saat pointer hapus menunjuk pada node yang akan dihapus, pointer bantu akan
bergerak ke node selanjutnya, dan kemudian pointer hapus akan didelete.