LAPORAN SRUKTUR DATA

DOUBLE LINKED LIST CIRCULAR( DLLC )

Disusun Oleh :
Kelompok : 5
1.
2.
3.
4.

Sajid Muhammad wildan

Nopal
Awang faruk
Asri welas

NIM.1415015123
NIM.1415015142
NIM.1415015145
NIM.1415015146

Dosen :
Novianti, S.Kom, MT

JURUSAN TEKNIK INFORMATIKA

UP. FAKULTAS TEKNOLOGI INFORMASI DAN KOMPUTER
UNIVERSITAS MULAWARMAN
2016

KATA PENGANTAR
Segala puji bagi Tuhan yang telah menolong penyusun menyelesaikan
laporan ini dengan penuh kemudahan. Tanpa pertolongan Dia penyusun tidak
akan sanggup menyelesaikan dengan baik. Laporan ini disusun oleh
penyusun dengan berbagai rintangan. Baik itu yang datang dari diri penyusun
maupun yang datang dari luar. Namun dengan penuh kesabaran dan terutama
pertolongan dari Tuhan akhirnya laporan ini dapat terselesaikan.
Laporan ini memuat tentang Double Linked List Circular. Penyusun
juga mengucapkan terima kasih kepada dosen mata kuliah yang telah banyak
membantu penyusun agar dapat menyelesaikan makalah ini. Semoga
makalah ini dapat bermanfaat pada setiap orang
Walaupun makalah ini memiliki kelebihan dan kekurangan. Penyusun
mohon atas saran kritiknya agar kinerja dalam proses pembuatan laporan
berikutnya dapat lebih baik.

Samarinda, April 2016

Penyusun

ii

DAFTAR ISI

HALAMAN JUDUL ........................................................................................... i

KATA PENGANTAR ......................................................................................... ii
DAFTAR ISI ........................................................................................................ iii
DAFTAR GAMBAR ........................................................................................... v
BAB I PENDAHULUAN .................................................................................... 1
1.1

Latar Belakang ................................................................................... 1

1.2

Rumusan Masalah .............................................................................. 2

1.3

Batasan Masalah................................................................................. 3

1.4

Tujuan ................................................................................................ 4

1.5

Manfaat .............................................................................................. 4

BAB II TINJAUAN PUSTAKA......................................................................... 5

2.1

Landasan Teori ................................................................................... 5

2.1.1 Double Linked List Circular................................................... 5
2.1.2 Perbedaan Array dengan Linked List.6

2.2

Pembahasan Materi ............................................................................ 8

2.2.1 Pendeklarasian Node pada Double Linked List Circular. ...... 8
2.2.2 Pembuatan Node baru pada Double Linked List Circular . ... 8
2.2.3 Double Linked List Circular menggunakan Head dan tail.. ... 9
2.2.3.1 Penambahan data didepan dengan head dan tail ....... 10
2.2.3.2 Penambahan data dibelakang dan menampilkan data
dengan head dan tail .................................................. 13

iii

2.2.3.3 Menghapus data terdepan dengan head dan tail ........ 16

2.2.3.4 Menghapus data terbelakang dan hapus semua data
dengan head dan tail .................................................. 18
2.3

Pembahasan Program ........................................................................ 22

BAB III KESIMPULAN DAN SARAN ............................................................ 41

3.1

Kesimpulan ........................................................................................ 41

3.2

Saran ................................................................................................... 42

DAFTAR PUSTAKA .......................................................................................... 43

iv

DAFTAR GAMBAR
Gambar 2.1 SLLNC .............................................................................................. 5
Gambar 2.2 Array vs Linked List ......................................................................... 7
Gambar 2.3 Head .................................................................................................. 9
Gambar 2.4 cek head ............................................................................................. 9
Gambar 2.5 head tambah depan ............................................................................ 11
Gambar 2.6 ilustrasi head dan tail tambah depan ................................................. 12
Gambar 2.7 head dan tail tambah belakang .......................................................... 13
Gambar 2.8 ilustrasi head dan tail tambah belakang............................................. 14
Gambar 2.9 head tampil ........................................................................................ 15
Gambar 2.10 ilustrasi head dan tail tampil............................................................ 15
Gambar 2.11 head dan tail hapus depan................................................................ 17
Gambar 2.12 ilustrasi head dan tail hapus depan .................................................. 18
Gambar 2.13 head dan tail hapus belakang........................................................... 19
Gambar 2.14 ilustrasi head dan tail hapus belakang. ............................................ 20
Gambar 2.15 head dan tail hapus semua. .............................................................. 21
Gambar 2.26 program 1. ....................................................................................... 22
Gambar 2.27 program 2 ........................................................................................ 23
Gambar 2.28 program 3. ....................................................................................... 24
Gambar 2.29 program 4 ........................................................................................ 25
Gambar 2.30 program 5 ........................................................................................ 26
Gambar 2.31 program 6 ........................................................................................ 27
Gambar 2.32 program 7 ........................................................................................ 28

Gambar 2.33 program 8 ........................................................................................ 29

Gambar 2.34 program 9. ....................................................................................... 30
Gambar 2.35 program 10. ..................................................................................... 31
Gambar 2.36 program 11. ..................................................................................... 32
Gambar 2.37 program 12 ...................................................................................... 33
Gambar 2.38 program 13 ...................................................................................... 34
Gambar 2.39 program 14 ...................................................................................... 35
Gambar 2.41 output 1 ............................................................................................ 36
Gambar 2.42 output 2 ............................................................................................ 36
Gambar 2.43 output 3 ............................................................................................ 37
Gambar 2.44 output 4 ............................................................................................ 37
Gambar 2.45 output 5 ............................................................................................ 37
Gambar 2.46 output 6 ............................................................................................ 38
Gambar 2.47 output 7 ............................................................................................ 38
Gambar 2.48 output 8 ............................................................................................ 39
Gambar 2.49 output 9 ............................................................................................ 39
Gambar 2.50 output 10 .......................................................................................... 40
Gambar 2.51 output 11 .......................................................................................... 40

vi

BAB I
PENDAHULUAN
1.1

Latar Belakang
Dalam istilah ilmu komputer, Struktur Data adalah cara
penyimpanan, penyusunan dan pengaturan data di dalam media
penyimpanan komputer sehingga data tersebut dapat digunakan secara
efisien dan dalam teknik pemrograman, struktur data berarti tata letak data
yang berisi kolom-kolom data, baik itu kolom yang tampak oleh pengguna
(user) atau pun kolom yang hanya digunakan untuk keperluan pemrograman
yang tidak tampak oleh pengguna, oleh karena itu sebagai seorang
Mahasiswa jurusan Teknik Informatika mata kuliah Struktur Data sangat
penting sebagai dasar untuk dapat mempelajari materi lanjutan yang
tentunya akan berkaitan dengan Struktur Data.
Suatu struktur data dapat dikatakan efisien apabila penyimpanan
yang dipakai digunakan sesuai kebutuhan saja, namun dalam pemograman
kita sering menggunakan array yang mana bersifat statis yaitu dimana ketika
kita memesan memory sebanyak 20 elemen maka setiap kali program
dijalankan memory yang kita pesan akan tetap sama meskipun yang
digunakan hanya 10 sehingga memory yang tersisa adalah merupakan
pemborosan dari penggunaan array, hal inilah yang menyebabkan efisien
pada Struktur data tadi sulit diterapkan, namun dengan adanya Linked List
kita dapat membantu mengatasi permasalahan tersebut.

Linked List adalah suatu Struktur data yang merupakan suatu

rangkaian atau daftar record berjenis sama, dan dihubungkan dengan
bantuan pointer. Linked list dapat digunakan secara Dinamis, sehingga tidak
akan melakukan pemborosan memory.
Linked List terbagi menjadi beberapa jenis, salah satunya adalah
Double Linked List Circular. Double Linked List Circular ini merupakan
Linked List yang diakhir pembacaan datanya selalu menunjuk ke Node
Pertama sehingga tidak ada NULL, hal ini sangat sesuai dengan struktur
data dimana penggunaan penyimpanan memory menjadi lebih efisien.
Pada laporan kali ini, penyusun akan membahas mengenai Double
Linked List Circular beserta contoh programnya menggunakan Bahasa
Pemograman C.

1.2

Rumusan Masalah
1.

Bagaimana ilustrasi penambahan Linked List baru.

2.

Bagaimana cara pengalokasian memory Double Linked List Circular di

pemograman C sehingga dapat digunakan secara dinamis.

3.

Mengilustrasi cara kerja mengapa Head bisa selalu didepan dan Tail
selalu dibelakang.

4.

Bagaimana contoh program Double Linked List Circular yang

didalamnya menggunakan Head dan Head and Tail, dan juga
pengalokasiannya yang menggunakan fungsi malloc dan new sekaligus
dalam satu program.

5.

Membuat program Double Linked List Circular

yang bisa

menambahkan data didepan dan dibelakang, menghapus data didepan

dan dibelakang, mencari data tertentu, menghapus data tertentu yang
sama sekaligus dalam program, menghapus semua data, menyisipkan
data, menghapus data sesuai urutannya, melihat data secara spesifik,
dan keluar dari program.
6.

1.3

Penjelasan cara kerja dari program yang telah dibuat tadi.

Batasan Masalah
1. Program yang dibuat menggunakan standar input output pada Bahasa
C++ atau dikenal dengan header iostream.h.
2. Untuk saat ini program yang dibuat hanya mampu menerima inputan
angka.
3. Penambahan dan penghapusan data tidak dapat melebihi 1 data
sekaligus kecuali program yang menghapus data tertentu yang mana
akan menghapus semua data yang sama, namun tidak dapat menghapus
sebagian saja.
4. Program yang dibuat menggunakan software Borland C++ 5.02.

1.4

Tujuan
1. Dapat membantu memahami tentang Double Linked List Circular.
2. Pembuatan program Double Linked List Circular dengan menggunakan
Bahasa C++.

1.5

Manfaat
1. Menambah wawasan penulis dan pembaca mengenai Double Linked
List Circular.
2. Memahami cara kerja Double Linked List Circular.
3. Terciptanya suatu program Double Linked List Circular yang memiliki
11 function didalam program tersebut.

BAB II
TINJAUAN PUSTAKA

2.1

Landasan Teori
2.1.1 Double Linked List Circular
Double artinya field pointer-nya ada dua buah.Satu arah menuju
selanjutnya dan Satu Arah Menuju sebelumnya., pointernya menunjuk next
dan previous. sedangkan Linked List artinya node-node tersebut saling
terhubung satu sama lain.

Gambar2.1 SLLNC

Setiap node pada linked list mempunyai field yang berisi pointer ke
node berikutnya dan node sebelumnya, dan juga memiliki field yang berisi
data. Node terakhir akan menunjuk ke head yang akan digunakan sebagai
kondisi mengulang pada saat pembacaan isi linked list. Atau definisi lainnya
yaitu Double Link List atau Linked List adalah salah satu bentuk struktur
data, berisi kumpulan data (node) yang tersusun secara sekuensial, saling
sambung-menyambung, dinamis dan tidak terbatas. Linked List sering
disebut juga senarai berantai yang saling terhubung dengan bantuan variabel
pointer masing-masing data dalam Linked List disebut dengan node
(simpul) yang menempati alokasi memori secara dinamis dan biasanya
berupa struct yang terdiri dari beberapa field.
5

2.1.2 Perbedaan Array dengan Linked List

Array memiliki lokasi memory dan data yang statis yang mana tidak
akan dapat berubah sesuai dengan kebutuhan, namun pada Linked List
dimana data dan memorynya itu Dinamis sehingga dapat menyesuaikan
dengan kebutuhan oleh karena itu data dan penyimpanan memory dalam
Linked List dapat dihapus datanya dan dapat dibebaskan kembali
memorynya berbeda dengan Array yang mana memory yang telah dipesan
tidak dapat dikembalikan sisanya jika penggunaan hanya sedikit, namun
array memiliki kelebihan yaitu bersifat random access sehingga penggunaan
datanya dapat dipanggil secara cepat hanya dengan menuliskan urutan dari
array tersebut berbeda dengan Linked List yang mana pengaksesannya
secara sequential atau berurutan. Pada gambar 2.2 akan diperlihatkan
perbedaan keduanya.

Gambar2.2ArrayvsLinkedLIst

2.2

Pembahasan Materi

2.2.1 Pendeklarasian Node pada Double Linked List Circular.

struct TNode{
char data[30];
TNode *next;
TNode *prev;
};
Penjelasan :
a. Pembuatan struct bernama Tnode yang berisi 2 field, yaitu field data
bertipe char dan field next serta prev yang bertipe pointer dari Tnode.
b. Setelah pembuatan struct, buat variabel head yang bertipe pointer dari
Tnode yang berguna sebagai kepala linked list.

2.2.2 Pembuatan node baru pada Double Circular Linked List

1. Dengan keyword *baru
Digunakan keyword new yang berarti mempersiapkan sebuah node
baru berserta alokasi memorinya, kemudian node tersebut diisi data dan
pointer nextnya ditunjuk ke data baru.
TNode *baru;
int i;
baru = new TNode;
for(i=0;i<=30;i++){
baru->data[i] = databaru[i];
}

baru->next = baru;
baru->prev = baru;
Tanda operator -> digunakan untuk pengaksesan data pada struct bertipe
pointer, seperti yang kita ketahui bahwa struct baru bertipe pointer.

2.2.3 Double Linked List Circular menggunakan Head dan tail

Double Linked List dengan Head dan tail adalah salah satu cara
penggunaan Linked List yang mana head adalah sebuah pointer dari Linked
List yang berisi node yang sama dengan struct awal. Head akan selalu
menunjuk pada node pertama.

Gambar2.3Head dantail

Sehingga head adalah titik pusat untuk melakukan penambahan maupun

pengurangan data, karena kita ketahui bahwa Linked List hanya bekerja
secara sequential, jadi untuk pengaksesan data lain tidak dapat dilakukan
tanpa head yang dapat disebut sebagai titik pusat. Untuk pendeklarasian
head, dapat dilakukan dengan menuliskan struct yang akan kita gunakan
untuk data Linked List dan diikuti pointer yang kita beri nama head yaitu
seperti berikut Tnode *head;.
Pada awal program head kita inisialisasikan nilainya adalah NULL
karena pada awal masih belum ada data pada Linked List, tentu saja head

juga belum ada sehingga head masih bernilai NULL, kemudian kita buat
fungsi yang dapat mengecek apakah head bernilai NULL atau tidak, yang
dapat kita buat seperti gambar dibawah 2.4.

Gambar2.4cekhead

Pada fungsi yang diberi nama isEmpty, fungsi akan memberikan atau
mengembalikan nilai dengan fungsi return yang jika mengembalikan nilai 1
berarti head bernilai NULL dan jika mengembalikan nilai 0 berarti head
sudah ada dan berarti Linked Listnya sudah memiliki data. Dengan head,
kita dapan menambahkan data, menghapus, menampilkan, dan masih
banyak lagi karena dengan head yang merupakan titik akses dari data yang
lain, sehingga apapun yang kita inginkan pada program dapat terlaksana
dengan bantuan node head.
2.2.3.1 Penambahan data didepan dengan head dan tail
Penambahan node baru akan dikaitan di node paling depan, namun
pada saat pertama kali (data masih kosong), maka penambahan data
dilakukan dengan cara node head ditunjukkan ke node baru tersebut.
Pada prinsipnya adalah mengkaitkan node baru dengan head, kemudian
head akan menunjuk pada data baru tersebut sehingga head akan tetap
selalu menjadi data terdepan. Sehingga contoh programnya adalah seperti
gambar 2.5.

voidinsertDepan(chardatabaru[30]){
TNode*baru;
inti;
baru=newTNode;
for(i=0;i<=30;i++){
baru>data[i]=databaru[i];
}
baru>next=baru;
baru>prev=baru;
if(isEmpty()==1){
head=baru;
tail=baru;
head>next=head;
head>prev=head;
tail>next=tail;
tail>prev=tail;
}
else{
baru>next=head;
head>prev=baru;
head=baru;
head>prev=tail;
tail>next=head;
}
printf("\n\t\t\Datamasuk\n");
printf("\t\tPressEntertoContinue..");
Gambar2.5headtambahdepan

10

Pada fungsi yang kita beri nama Insert Depan, dengan memiliki parameter
bertipe char dengan nama databaru, yang berisikan variable pointer baru
yang merupakan node yang sama dengan Tnode karena Tnode melakukan
penginisialisasian nama, lalu isi dari baru adalah Tnode baru atau struct
node baru dan isi data dari baru adalah databaru yang telah diberikan nilai
oleh parameter fungsi dan baru untuk next adalah HEAD yang artinya next
adalah kembali ke node awal. Setelah itu dilakukan penyeleksian yang berisi
fungsi penentu nilai head, yaitu jika isEmpty bernilai 1 atau head masih
belum ada atau Linked List masih kosong maka pernyataan pada if akan
dilaksanakan yang mana isi perintahnya adalah jika head NULL maka head
adalah baru yaitu Tnode atau node baru dan untuk data setelah head atau
head->next adalah Head karena penambahan baru dilakukan sekali jadi
datanya masih satu yaitu head. Namun bila penyeleksian if tidak terlaksana
maka fungsi else akan laksanakan yang mana berisi jika data pada Linked
List atau head sudah ada dan bukan NULL makan variabel pointer node
baru untuk next atau data setelahnya adalah next sehingga data baru yang
ditambahkan ada didepan, lalu head akan berpindah ke baru, artinya bukan
datanya yang berpindah namun nama dari inisialisasi head akan berubah ke
depan kembali sehingga head akan selalu berada didepan meskipun
menerima penambahan data didepan.

11

Gambar2.6ilustrasiheaddantailtambahdepan

2.2.3.2 Penambahan data dibelakang

Penambahan data dibelakang akan menambahkan data dibelakang
head, namun saat pertama kali melakukan penambahan data, node
langsung ditunjuk oleh head jadi untuk pertamakali data ditambah
dibelakang head. Untuk penambahan data dibelakang menggunakan head
sedikit lebih sulit karena membutuhkan pointer bantu yang digunakan
untuk mengetahui node paling belakang, kemudian akan melakukan
penyambungan pada node paling belakang ke node baru yang ditunjuk
oleh node paling belakang tadi sehingga node baru akan menjadi node
paling belakang berikutnya yang menunjuk ke Head. Untuk mengetahui
node terbelakang perlu menggunakan perulangan yang akan melalui
setiap node yang ada sampai pengulangan berhentu pada node terbelakang
yang menuju ke Head. Dalam program penambahan data dibelakang
dengan head dapat dilihat pada gambar 2.7.

12

voidinsertBelakang(chardatabaru[30]){
TNode*baru,*bantu;
inti;
baru=newTNode;
for(i=0;i<=30;i++){
baru>data[i]=databaru[i];
}
baru>next=baru;
baru>prev=baru;
if(isEmpty()==1){
head=baru;
tail=baru;
head>next=head;
head>prev=head;
tail>next=tail;
tail>prev=tail;
}
else{
tail>next=baru;
baru>prev=tail;
tail=baru;
tail>next=head;
head>prev=tail;
}
printf("\t\tDatamasuk\n");
printf("\t\tPressEntertoContinue..");

Gambar2.7head dantail tambahbelakang

13

Program pada gambar 2.7 menjelaskan jika data ada maka fungsi if akan
dilaksanakan yaitu head adalah data baru dan head akan mengarah kearah
Baru, dan jika fungsi if tidak terlaksana maka fungsi else yang merupakan
data tidak ada akan terlaksana, yang mana pointer baru diinisialisasikan
sebagai tail akan melakukan pengulangan jika setelah pointer bantu tidak
sama dengan Head sehingga jika didapati node terakhir pada perulangan
itu, maka node yang mengarah ke Tail akan mengarah ke node baru dan
node baru akan mengarah ke Head sehingga setiap data yang diinputkan
akan selalu berada paling belakang.
Ilustrasi dari penambahan data dibelakang dengan head dan tail dapat
dilihat pada gambar 2.8.

Gambar2.8ilustrasiheaddantailtambahbelakang

Pada program Linked List dengan head penambahan data dibelakang, kita
dapat juga melakukan program lain yaitu menampilkan isi dari Linked List,
karena pada saat mencari data terbelakang dengan perulangan, dimana

14

program akan melakukan pembacaan data satu per satu sampai akhir
sehingga semua data dapat diketahui datanya dengan melakukan fungsi
yang akan menampilkan setiap data dari node yang telah dilalui saat
perulangan, yaitu dapat dilihat pada contoh program pada gambar 2.9.
voidtampil(void){
inti=0;
if(isEmpty()==0){
do{
i++;
printf("\t\t%i.%s\n",i,head>data);
printf("\t\t===================\n");
head=head>next;
}while(head!=tail>next);
printf("\n");
}elseprintf("\t\t\t..Masihkosong..\n\n");
}

Gambar2.9headtampil

Dan ilustrasinya dapat dilihat pada gambar 2.10.

Gambar2.10ilustrasiheaddantailtampil

15

Penjelasan dari ilustrasi dan program diatas adalah untuk

menampilkan semua isi list, di mana linked list ditelusuri satu-persatu dari
awal node sampai akhir node, Penelusuran ini dilakukan dengan
menggunakan suatu pointer bantu, karena pada prinsipnya pointer head
yang menjadi tanda awal list tidak boleh berubah/berganti posisi.
Penelusuran dilakukan terus sampai node terakhir ditemukan menunjuk ke
nilai HEAD. Jika tidak menuju HEAD, maka node bantu akan berpindah
ke node selanjutnya dan membaca isi datanya dengan menggunakan field
next dan previous sehingga dapat saling berkait. Dan jika head masih
bernilai NULL berarti data kosong dan tidak ada yang akan tertampil.

2.2.3.3 Menghapus data terdepan dengan head dan tail

Penghapusan data terdepan dengan head dapat dilakukan yaitu
dengan menghapus node pertama yang sedang dinisialkan oleh pointer
head, namun untuk itu head tidak boleh dihapus karena head adalah titik
acuan untuk pengaksesan data yang ada, sehingga kita harus melakukan
pergantian inisialisasi, yaitu pointer head berpindah ke head-> next yaitu
node setelah head dan node pertama diinisialkan oleh pointer lain yang
dibseri nama hapus, kemudian pointer tersebut akan mewakili sebagai
node pertama yang mana akan kita hapus dengan menggunakan keyword
delete, sehingga node terdepan tetaplah pointer head dan node terdepan
sebelumnya dapat dihapus menggunakan inisialisasi dari head dengan

16

nama pointer lain tanpa menggangu head. Contoh programnya dapat

dilihat pada gambar 2.11.
voidhapusDepan(void){
TNode*hapus;
chard[30];
inti;
if(isEmpty()==0){
if(head!=tail){
hapus=head;
for(i=0;i<=30;i++){
d[i]=hapus>data[i];
}
head=head>next;
tail>next=head;
head>prev=tail;
deletehapus;
}else{
for(i=0;i<=30;i++){
d[i]=head>data[i];
}
head=NULL;
tail=NULL;
}
printf("\t\t%sterhapus\n",d);
}elseprintf("\t\tMasihkosong\n");
}

Gambar2.11headhapusdepan

17

Dan ilustrasi dari penghapusan data terdepan dapat dilihat pada gambar
2.12.

Gambar2.12ilustrasiheadhapusdepan

2.2.3.4 Menghapus data terbelakang dan hapus semua dengan head dan tail
Program penghapusan data terbelakang menggunakan head hampir
sama dengan penambahan data terbelakang menggunakan head, yang
mana membutuhkan pointer bantu dan melakukan perulangan, namun pada
penghapusan data terbelakang kita akan melakukan perulangan utnuk
pointer bantu setelahnya dan setelahnya lagi atau bantu->next->next
sampai next terakhir menuju Head. Hal ini dilakukan bila Linked List
sudah berisi data atau fungsi if dijalankan, dan dilakukan pergantian
inisialisasi untuk pointer bantu terakhir perulangan dengan pointer hapus,
lalu pointer bantu yang berada sebelum akhir dari hapus akan menunjuk ke
Head dan pointer hapus akan dihapus dengan keyword delete sehingga
akhirnya node yang dihapus adalah node terakhir dan node bantu akan

18

mengarah ke Head, namun untuk fungsi else jika data belum ada, maka
yang terlaksana adalah head masih NULL. Variabel d pada program di
gambar 2.13 akan memuat data pada pointer hapus yang saat itu akan
dihapus nodenya dan saat data masih kosong maka d akan diisi data pada
node head yaitu NULL. Contoh program menghapus data terbelakang
dengan head dapat dilihat padagambar 2.13.

Gambar2.13headhapusbelakang

19

Dan untuk ilustrasinya dapat dilihat pada gambar 2.14.

Gambar2.14ilustrasihapusbelakang

Untuk menghapus semua elemen pada Linked List dengan head kita dapat
melakukan perulangan yaitu ketika pointer bantu tidak sama dengan NULL maka
perulangan akan terus berlangsung yang mana didalam perulangan terdapat
beberapa perintah yaitu pointer bantu yang ada saat itu akan dinisialisasikan dengan
nama hapus dan kemudian bantu akan berpindah ke node berikutnya dan pointer
hapus akan dihapus dengan keyword delete sehingga satiap perulangan data yang
dilalui akan dihapus sampai dengan perulangan berakhir, yaitu sampai NULL.
Contoh programnya dapat dilihat pada gambar 2.15.

20

Gambar2.15headhapussemua

21

2.3

Pembahasan Program
Program yang dibuat adalah program menggunakan bahasa C yang

menggunakan program yang menggunakan head and tail juga yang menggunakan
head saja sehingga semua fungsi telah digabungkan dalam sebuah program yang
dapat berjalan dengan baik.
#include<conio.h>
#include<stdio.h>
structTNode{
chardata[30];
TNode*next;
TNode*prev;
};
TNode*head,*tail;
voidinit(void);
intisEmpty(void);
voidinsertDepan(chardatabaru[30]);
voidinsertBelakang(chardatabaru[30]);
voidinserttengah(chardatabaru[30],intpilihdepan,intpilihbelakang);
voidtampil(void);
voidhapusDepan(void);
voidhapusBelakang(void);
voiddeletetengah(intpilih);

Gambar2.26program1

22

voidclear(void);
intcari(charelemen[30]);
main()
{
charpilih;
charelm[30];
intdepan,belakang;
init();
do
{
printf("\n");
printf("\t\t===================================\n");
printf("\t\t||NomorAntrian||\n");
printf("\t\t||NasabahBankKrutt||\n");
printf("\t\t===================================\n");
printf("\t\tMENUPILIHAN:\n");
printf("\t\t===================================\n");
printf("\t\t[1]MASUKKANNamaNasabahdisiniuntuksimpanan100jutakeatas\n");
printf("\t\t[2]MASUKKANNamaNasabahdisiniuntuksimpanan20juta
kebawah\n");
printf("\t\t[3]MASUKKANNamaNasabahdisiniuntuksimpanan20jutakeatas\n");
printf("\t\t[4]TAMPILKANUrutanPemanggilanNasabah\n");
printf("\t\t[5]HAPUSURUTANPALINGDEPAN\n");
printf("\t\t[6]HAPUSURUTANPALINGBELAKANG\n");
printf("\t\t[7]HAPUSURUTANDITENGAH\n");
printf("\t\t[8]HAPUSSEMUADATA\n");
printf("\t\t[9]CARINASABAH\n");
printf("\t\t[0]KELUAR\n");
printf("\t\t===================================\n\n");
printf("\t\t===================================\n\n");
printf("\n");
printf("\t\t>>PILIHAN ANDA : ");
Gambar2.27program2

23

switch(pilih)
{
case'1':clrscr();
tampil();
printf("\n");
printf("\t\tMASUKKANNamanasabahdisiniuntuksimpanan100jutakeatas\n");
printf("\t\t\n");
printf("\t\t::MASUKKANNama:");
scanf("%s",&elm);
insertDepan(elm);
getch();
clrscr();
break;
case'2':clrscr();
tampil();
printf("\n");
printf("\t\tMASUKKANNamanasabahdisiniuntuksimpanan20jutakebawah\n");
printf("\t\t\n");
printf("\t\t::MASUKKANnama:");
scanf("%s",&elm);
insertBelakang(elm);
clrscr();
break;
case'3':clrscr();
tampil();
printf("\n");
printf("\t\tMASUKKANNamanasabahdisiniuntuksimpanan20jutakeatas\n");
printf("\t\t\n");
printf("\t\t::MASUKKANnama:");
scanf("%s",&elm);
Gambar2.28program3

24

printf("\t\t::DATABELAKANG:");
scanf("%i",&belakang);
inserttengah(elm,depan,belakang);
getch();
clrscr();
break;
case'4':clrscr();
tampil();
printf("\t\t\n\n");
printf("\t\tPressEntertoContinue..");
getch();
clrscr();
break;
case'5':clrscr();
tampil();
hapusDepan();
printf("\n");
printf("\t\t\n");
printf("\t\tPressEntertoContinue..");
getch();
clrscr();
break;
case'6':clrscr();
tampil();
hapusBelakang();
printf("\n");
printf("\t\t\n");
printf("\t\tPressEntertoContinue..");
getch();
clrscr();
break;
Gambar2.29program4

25

case'8':clrscr();
clear();
printf("\t\tDATATELAHDIHAPUSSEMUA\n");
printf("\t\t\n");
printf("\t\tPressEntertoContinue..");
getch();
clrscr();
break;

case'9':clrscr();
printf("\n");
printf("\t\tMASUKKANDATAYANGDICARI\n");
printf("\t\t\n");
printf("\t\t::MASUKKANDATA:");
scanf("%s",&elm);
if(cari(elm)==1){
printf("\n\t\tdatasuccessditemukan");
}else{
printf("\n\t\tMaafdatatidakditemukan");
}
getch();
clrscr();
break;

case'0':break;
getch();
clrscr();
default:printf("\t\tSalahpilih...\n");
break;
}
Gambar2.30program5

26

}while(pilih!='0');
}
voidinit(void){
head=NULL;
tail=NULL;
}
intisEmpty(void){
if(tail==NULL)return1;
elsereturn0;
}
voidinsertDepan(chardatabaru[30]){
TNode*baru;
inti;
baru=newTNode;
for(i=0;i<=30;i++){
baru>data[i]=databaru[i];
}
baru>next=baru;
baru>prev=baru;
if(isEmpty()==1){
head=baru;
tail=baru;
head>next=head;
head>prev=head;
tail>next=tail;
tail>prev=tail;}
else{
baru>next=head;
head>prev=baru;
head=baru;
Gambar2.31program6

27

head>prev=tail;
tail>next=head;
}
printf("\n\t\t\Datamasuk\n");
printf("\t\tPressEntertoContinue..");
}
voidinsertBelakang(chardatabaru[30]){
TNode*baru,*bantu;
inti;
baru=newTNode;
for(i=0;i<=30;i++){
baru>data[i]=databaru[i];}
baru>next=baru;
baru>prev=baru;
if(isEmpty()==1){
head=baru;
tail=baru;
head>next=head;
head>prev=head;
tail>next=tail;
tail>prev=tail;}
else{
tail>next=baru;
baru>prev=tail;
tail=baru;
tail>next=head;
head>prev=tail;}
printf("\t\tDatamasuk\n");
printf("\t\tPressEntertoContinue..");}

Gambar2.32program7

28

voidtampil(void){
inti=0;
if(isEmpty()==0){
do{
i++;
printf("\t\t%i.%s\n",i,head>data);
printf("\t\t===================\n");
head=head>next;
}while(head!=tail>next);
printf("\n");
}elseprintf("\t\t\t..Masihkosong..\n\n");}
voidhapusDepan(void){
TNode*hapus;
chard[30];
inti;
if(isEmpty()==0){
if(head!=tail){
hapus=head;
for(i=0;i<=30;i++){
d[i]=hapus>data[i];}
head=head>next;
tail>next=head;
head>prev=tail;
deletehapus;}else{
for(i=0;i<=30;i++){
d[i]=head>data[i];}
head=NULL;
tail=NULL;}
printf("\t\t%sterhapus\n",d);
}elseprintf("\t\tMasihkosong\n");}

Gambar2.33program8

29

voidhapusBelakang(void){
TNode*hapus;
chard[30];
inti;
if(isEmpty()==0){
if(head!=tail){
hapus=tail;
for(i=0;i<=30;i++){
d[i]=hapus>data[i];}
tail=tail>prev;
tail>next=head;
head>prev=tail;
deletehapus;}else{
for(i=0;i<=30;i++){
d[i]=head>data[i];}
head=NULL;
tail=NULL;}
printf("\t\t%sterhapus\n",d);
}elseprintf("\t\tMasihkosong\n");}
voidclear(void){
TNode*bantu,*hapus;
if(isEmpty()==0){
bantu=head;
while(bantu>next!=head){
hapus=bantu;
bantu=bantu>next;
deletehapus;}
head=NULL;}
}

Gambar2.34program9

30

intcari(charelemen[30]){
inti=0;
intstatus=0;
if(isEmpty()==0){
do{
i++;
if(head>data[i]==elemen[i]){
status=1;
}elsehead=head>next;
}while(head!=tail>next&&i<=30);
return(status);
}elseprintf("\t\tMasihkosong\n");}
voidinserttengah(chardatabaru[30],intpilihdepan,intpilihbelakang){
TNode*baru,*bantu,*depan,*belakang;
charelemen[30];
intI,j;
baru=newTNode;
for(i=0;i<=30;i++){
baru>data[i]=databaru[i];}
baru>next=baru;
baru>prev=baru;
if(isEmpty()==1){
head=baru;
tail=baru;
head>next=head;
head>prev=head;
tail>next=tail;
tail>prev=tail;}else{
depan=head;
belakang=head;
for(i=1;i<pilihdepan;i++){
Gambar2.35program 10

31


depan=depan>next;
}
for(i=1;i<pilihbelakang;i++){
belakang=belakang>next;
}
depan>next=baru;
baru>prev=depan;
baru>next=belakang;
belakang>prev=baru;
}
printf("\t\tDatamasuk\n");
printf("\t\tPressEntertoContinue..");
}

Gambar2.36program11

32

intcari(charelemen[30]){
inti=0;
intstatus=0;
if(isEmpty()==0){
do{
i++;
if(head>data[i]==elemen[i]){
status=1;
}elsehead=head>next;
}while(head!=tail>next&&i<=30);
return(status);
}elseprintf("\t\tMasihkosong\n");}
voidinserttengah(chardatabaru[30],intpilihdepan,intpilihbelakang){
TNode*baru,*bantu,*depan,*belakang;
charelemen[30];
intI,j;
baru=newTNode;
for(i=0;i<=30;i++){
baru>data[i]=databaru[i];
}
baru>next=baru;
baru>prev=baru;
if(isEmpty()==1){
head=baru;
tail=baru;
head>next=head;
head>prev=head;
tail>next=tail;
tail>prev=tail;

Gambar2.37program12

33

}else{
depan=head;
belakang=head;
for(i=1;i<pilihdepan;i++){
depan=depan>next;
}
for(i=1;i<pilihbelakang;i++){
belakang=belakang>next;
}
depan>next=baru;
baru>prev=depan;
baru>next=belakang;
belakang>prev=baru;
}
printf("\t\tDatamasuk\n");
printf("\t\tPressEntertoContinue..");
}

Gambar2.38program13

34

voiddeletetengah(intpilih){
TNode*hapusdepan,*hapusbelakang,*hapustengah;
chard[30];
inti,j;
if(isEmpty()==0){
if(head!=tail){
hapusdepan=head;
hapusbelakang=head;
hapustengah=head;
for(i=1;i<pilih;i++){
hapusdepan=hapusdepan>next;}
for(i=1;i<(pilih+2);i++){
hapusbelakang=hapusbelakang>next;}
for(i=1;i<=pilih;i++){
hapustengah=hapustengah>next;}
for(j=1;j<pilih;j++){
for(i=0;i<=30;i++){
d[i]=hapustengah>data[i];}
hapustengah=hapustengah>next;}
deletehapustengah;
hapusdepan>next=hapusbelakang;
hapusbelakang>prev=hapusdepan;}else{
for(i=0;i<=30;i++){
d[i]=hapustengah>data[i];}
head=NULL;
tail=NULL;}
printf("\t\t%sSuccessterhapus\n",d);
}elseprintf("\t\tMasihkosong\n");}

Gambar2.39program14

35

Untuk output dari program dapat dilihat pada gambar dibawah ini.

Gambar2.41output1

Jika kita memilih pilihan 1 maka outputnya seperti gambar 2.42

Gambar2.42output2

36

Dan jika kita memilih pilihan 2 yaitu penambahan data dibelakang, maka outputnya
dapat dilihat pada gambar 2.43

Gambar2.43output3

Dan jika kita memilih pilihan 3 yaitu penambahan data dibelakang, maka outputnya
dapat dilihat pada gambar 2.43

Gambar2.44output4

Untuk melakukan penghapusan data didepan, kita dapat masukan pilihan 5. Output
dari pilihan 4 adalah seperti gambar 2.45

Gambar2.45output5

37

Untuk melakukan penghapusan data dibelakang, maka dapat memilih pilihan 6,

untuk outputnya dapat dilihat pada gambar 2.46

Gambar2.46output6

Untuk melakukan penghapusan data ditengah, maka dapat memilih pilihan 6, untuk
outputnya dapat dilihat pada gambar 2.47

Gambar2.47output7

38

Menampilkan data pada program dapat dilakukan dengan pilihan ke 4, yang

outputnya dapat dilihat pada gambar 2.48

Gambar2.48output8

Untuk melakukan penghapusan semua data sekaligus, maka pilihan yang dapat
dipilih adalah nomor 8, yang outputnya dapat dilihat pada gambar 2.47

Gambar2.49output9

39

Jika ingin mengecek kembali apakah sudah mengambil antrian atau belum, maka
perintah yang dapat digunakan yaitu pada pilihan nomor 9 yang outputmya setelah
menggunakan pilihan ini adalah seperti pada gambar 2.4.10

Gambar2.50output10

Kemudian untuk mengakhiri program atau keluar dari program, maka fungsi pilihan
yang dapat digunakan adalah 0.

Gambar2.51output11

40

BAB III
KESIMPULAN DAN SARAN

3.1

Kesimpulan
1. Linked List adalah struktur data yang lebih efisien dalam jumlah
memory yang digunakan karena bersifat Dinamis.
2. Double Linked List Circular adalah jenis dari Linked List yang memiliki
dua arah yang pada akhirnya menuju HEAD atau re loop dari Linked
Listnya.
3. Pengalokasian memory pada Linked List dapat menggunakan fungsi
malloc maupun keyword new yang mana bila menggunakan keyword
new lebih mudah karena tidak perlu memesan ukuran jenis tipe memory
seperti fungsi malloc.
4. DLLC dapat menggunakan head maupun head and tail sebagai titik
acuan dalam pengaksesan data yang lain.
5. Meskipun Linked List sangat efisien dalam penggunaan memory
daripada Array, namun Linked List datanya tidak dapat diakses secara
langsung tanpa melalui fungsi yang dapat membaca datanya secara
sequential.

41

3.2

Saran
1. Pahamilah dahulu algoritmanya agar dapat memahami cara kerja DLLC.
2. Jika materi yang telah dibahas kurang dapat dipahami, carilah referensi
lain untuk dapat menguasai DLLC.
3. Cobalah program dan pahamilah agar dapat melakukan pembaruan
terhadap program sesuai dengan kebutuhan.

42

DAFTAR PUSTAKA
Ahonk.

pengertian-link-list.

25

April

2015.

http://ahonk-

ftk10.blogspot.com/2011/04/pengertian-link-list.html
Ting, Virdi Arres. Double Linked List Circular (SLLNC). 25 April 2015.
file:///C:/Users/xx/Downloads/laporan%20single%20linked%20list%20non%20ci
rcular.htm
Wikipedia.

Struktur

Data.

http://id.wikipedia.org/wiki/Struktur_data

43

25

April

2015.