Modul 6

Double Linked-List

A. Double Linked-List
Double Linked List merupakan Linked List dimana setiap simpul dibagi menjadi tiga bagian yaitu
bagian isi, bagian pointer kiri, dan bagian pointer kanan. Bagian isi merupakan bagian yang berisi data
yang disimpan oleh simpul, sedangkan bagian pointer kiri merupakan bagian yang berisi alamat dari
simpul sebelumnya dan bagian pointer kanan merupakan bagian yang berisi alamat dari simpul
berikutnya.

Dari gambar di atas dapat kita lihat bahwa pointer kanan suatu simpul menunjuk ke simpul
berikutnya dan pointer kiri menunjuk simpul sebelumnya. Tetapi untuk pointer kiri simpul pertama
tidak menunjuk ke simpul yang lain (NULL) dan pointer kanan dari simpul terakhir juga tidak
menunjuk simpul yang lain (NULL).

B. Operasi Pada Linked-List

1. Insert
Insert Node Di awal Linked List
void Sisip_Depan (simpul &DL, char elemen)
{
simpul baru;
baru = (simpul) malloc(sizeof(simpul));
baru->isi = elemen;
baru->kanan = NULL;
baru->kiri = NULL;
if (DL == NULL)

Modul Praktikum Algoritma & Struktur Data – Institut Teknologi Garut 2021 1
 DL = baru;
else
{
baru ->kanan = DL;
DL->kiri = baru;
DL = baru;
}
}

Insert node di tengah Linked List (dengan pointer bantu)

void Sisip_Tengah (simpul &DL, char elemen1, char elemen2)
{
simpul bantu, baru;
baru = (simpul) malloc(sizeof(simpul));
baru->isi = elemen1;
baru->kanan = NULL;
baru->kiri = NULL;
if (DL == NULL)
cout<<”List Kosong ……………”<<endl;
else
{
bantu = DL;
While(bantu->kanan->isi != elemen2)
Bantu = bantu->kanan;
baru->kanan = bantu->kanan;
baru->kiri = bantu;
bantu->kanan->kiri = baru;
bantu->kanan = baru;
}
}

Insert node di tengah Linked List (tanpa pointer bantu)

void Sisip_Tengah2 (simpul &DL, char elemen1, char elemen 2)

Modul Praktikum Algoritma & Struktur Data – Institut Teknologi Garut 2021 2
 {
simpul baru;
baru = (simpul) malloc(sizeof(simpul));
baru->isi = elemen1;
baru->kanan = NULL;
baru->kiri = NULL;
if (DL == NULL)
cout<<”List Kosong ……………”<<endl;
else
{
while(DL->kanan->isi != elemen2) DL = DL->kanan;
baru->kanan = DL->kanan;
baru->kiri = DL;
DL->kanan->kiri = baru;
DL->kanan = baru;
}
while(DL->kiri != NULL) DL = DL->kiri;
}

Insert node di belakang Linked List (dengan pointer bantu)

void Sisip_Belakang(simpul &DL, char elemen)
{
simpul baru, Bantu;
baru = (simpul) malloc(sizeof(simpul));
baru->isi = elemen;
baru->kanan = NULL;
baru->kiri = NULL;
if (DL == NULL)
DL = baru;
else
{
Bantu = DL;
While (Bantu->kanan != NULL) Bantu = Bantu->kanan

Modul Praktikum Algoritma & Struktur Data – Institut Teknologi Garut 2021 3
 Bantu->kanan = baru;
baru->kiri = baru;
}
}

Insert node di belakang Linked List (tanpa pointer bantu)

void Sisip_Belakang (simpul &DL, char elemen)
{
simpul baru;
baru = (simpul) malloc(sizeof(simpul));
baru->isi = elemen;
baru->kanan = NULL;
baru->kiri = NULL;
if (DL == NULL)
DL = baru;
else
{
While (DL->kanan != NULL) DL = DL->kanan;
DL->kanan = baru;
baru->kiri = DL;
while (DL->kiri != NULL) DL = DL->kiri;
}
}

2. Delete
Delete node di awal Linked List
void Hapus_Depan(simpul &DL)
{
Simpul Hapus;
If (DL == NULL)
cout<<”Linked List Kosong ………….”;
else
{

Modul Praktikum Algoritma & Struktur Data – Institut Teknologi Garut 2021 4
 Hapus = DL;
DL = DL->kanan;
DL->kiri = NULL;
Hapus->kanan = NULL;
Free(Hapus);
}
}

Delete node di tengah Linked List (dengan pointer bantu)

void Hapus_Tengah(simpul &DL, char elemen)
{
Simpul bantu, hapus;
If (DL == NULL)
cout<<”Linked List Kosong ………….”;
else
{
bantu = DL;
while(bantu->kanan->isi != elemen)
bantu = bantu->kanan;
hapus = bantu->kanan;
bantu->kanan->kanan->kiri = bantu;
hapus->kanan = NULL;
hapus->kiri = NULL;
free(Hapus);
}
}

Delete node di tengah Linked List (tanpa pointer bantu)

void Hapus_Tengah(simpu &DL, char elemen)
{
simpul Hapus;
if (DL == NULL)
cout<<”Linked List Kosong …...........”;

Modul Praktikum Algoritma & Struktur Data – Institut Teknologi Garut 2021 5
 else
{
Hapus = DL;
while(Hapus->Isi != elemen) Hapus = Hapus->Isi;
Hapus->kanan->kiri = Hapus->kiri;
Hapus->kiri->kanan = Hapus->kanan;
Hapus->kanan = NULL;
Hapus->kiri = NULL;
free(Hapus);
}
}

Delete node di belakang Linked List (dengan pointer bantu)

void Hapus_Belakang (simpul &DL)
{
Simpul bantu, hapus;
if(DL == NULL)
cout<<”Linked List Kosong ………….”;
else
{
bantu = DL;
while(bantu->kanan->kanan != NULL)
bantu = bantu->kanan;
hapus = bantu-> kanan;
bantu->kanan = NULL;
hapus->kiri = NULL;
free(Hapus);
}
}

Delete node di belakang Linked List (tanpa pointer bantu)

void Hapus_Belakang(simpul &DL)
{

Modul Praktikum Algoritma & Struktur Data – Institut Teknologi Garut 2021 6
 simpul Hapus;
if(DL==NULL)
cout<<”Linked List Kosong …...........”;
else
{
Hapus = DL;
while(Hapus->Kanan != NULL) Hapus=Hapus->Isi;
Hapus->kiri->kanan = NULL;
Hapus->kiri = NULL;
free(Hapus);
}
}

Program penghapusan simpul tengah dan simpul belakang tanpa menggunakan pointer
bantu dan tanpa menggerakkan pointer DL
/* =====================================================
============ PROGRAM DOUBLE LINKED LIST =============
===== Sisip Depan, Hapus Tengah, Hapus Belakang =====
================ Tanpa Pointer Bantu ================
================ BY : LAMHOT SITORUS ================
===================================================== */

#include<iostream.h>
#include<conio.h>
#include<stdlib.>
#define true 1
#define false 0
typedef struct node *simpul;

struct node
{
char Isi;

Modul Praktikum Algoritma & Struktur Data – Institut Teknologi Garut 2021 7
 simpul kanan;
simpul kiri;
};

//======================
//==Prototype Function==
//======================
void Sisip_Depan(simpul &DL, char elemen);
void Hapus_Belakang(simpul &DL);
void Hapus_Tengah(simpul &DL, char elemen);
void Cetak(simpul DL);

//=================
//==Function Main==
//=================
main()
{
char huruf;
simpul DL = NULL; //Pastikan bahwa DL kosong
int i;
cout<<"\t\t==OPERASI PADA DOUBLE LINKED LIST==\n\n";
//===============
//==Sisip Depan==
//===============
cout<<"Penyisipan Simpul Di Depan\n\n";
for(i=1; i<=6; i++)
{
cout<<"Masukkan Huruf :";
cin>>huruf;
Sisip_Depan(DL,huruf);
}
Cetak(DL);
//=========================
//==Hapus Simpul Belakang==

Modul Praktikum Algoritma & Struktur Data – Institut Teknologi Garut 2021 8
 //=========================
cout<<"\nSetelah Hapus Simpul Belakang \n";
Hapus_Belakang(DL);
Cetak(DL);
cout<<"\nSetelah Hapus Simpul Belakang \n";
Hapus_Belakang(DL);
Cetak(DL);
//=======================
//==Hapus Simpul TENGAH==
//=======================
cout<<"\nMasukkan Huruf Tengah Yang Akan Dihapus :";
cin>>huruf;
Hapus_Tengah(DL,huruf);
Cetak(DL);
cout<<"\nMasukkan Huruf Tengah Yang Akan Dihapus :";
cin>>huruf;
Hapus_Tengah(DL,huruf);
Cetak(DL);
getch();
}

//**********************************
//**FUNCTION SISIP SIMPUL DI DEPAN**
//**********************************
void Sisip_Depan(simpul &DL, char elemen)
{
simpul baru; //simpul baru = new simpul; maka baris berikut
dihapus
baru = (simpul) malloc(sizeof(simpul));
baru->Isi = elemen;
baru->kanan = NULL;
baru->kiri = NULL;
if(DL == NULL)
DL=baru;

Modul Praktikum Algoritma & Struktur Data – Institut Teknologi Garut 2021 9
 else
{
baru->kanan = DL;
DL->kiri = baru;
DL=baru;
}
}

//************************************
//**FUNTION MENCETAK ISI LINKED LIST**
//************************************
void Cetak(simpul DL)
{
if(DL==NULL)
cout<<"Linked List Kosong ........."<<endl;
else
{
cout<<"Isi Linked List : ";
while (DL->kanan != NULL)
{
cout<<DL->Isi<<"<==>";
DL=DL->kanan;
}
cout<<DL->Isi;
}
}

//**********************************
//**FUNCTION HAPUS SIMPUL BELAKANG**
//**********************************
void Hapus_Belakang(simpul &DL)
{
simpul Hapus;
if(DL==NULL)

Modul Praktikum Algoritma & Struktur Data – Institut Teknologi Garut 2021 10
 cout<<"Linked List Kosong ............";
else
{
Hapus = DL;
while(Hapus->kanan != NULL) Hapus=Hapus->kanan;
Hapus->kiri->kanan = NULL;
Hapus->kiri = NULL;
free(Hapus);
}
}

//***********************************
//**FUNCTION HAPUS SIMPUL DI TENGAH**
//***********************************
void Hapus_Tengah(simpul &DL, char elemen)
{
simpul Hapus;
if(DL==NULL)
cout<<"Linked List Kosong ............";
else
{
Hapus = DL;
while(Hapus->Isi != elemen) Hapus=Hapus->kanan;
Hapus->kanan->kiri = Hapus->kiri;
Hapus->kiri->kanan = Hapus->kanan;
Hapus->kanan = NULL;
Hapus->kiri = NULL;
free(Hapus);
}
}

Modul Praktikum Algoritma & Struktur Data – Institut Teknologi Garut 2021 11
 Output Program :

Modul Praktikum Algoritma & Struktur Data – Institut Teknologi Garut 2021 12