LAPORAN PRAKTIKUM ALGORITMA DAN STRUKTUR (10)

(1)

LAPORAN PRAKTIKUM

ALGORITMA DAN STRUKTUR DATA I

SENARAI BERANTAI/ LINKED LIST

Modul V

Disusun Oleh :

Syukur Jaya Mendrofa 201501072

Dosen Pengampu :

Oskar Ika Adi Nugroho S.T., MT

JURUSAN SISTEM INFORMASI

SEKOLAH TINGGI ILMU KOMPUTER (STIKOM)

“YOS SUDARSO”

PURWOKERTO

2016

BAB I

(2)

SEJARAH SINGKAT LINK LIST

Dikembangkan tahun 1955-1956 oleh Allen Newell, Cliff Shaw dan Herbert Simon di RAND Corporation sebagai struktur data utama untuk bahasa Information Processing Language (IPL). IPL dibuat untuk mengembangkan program artificial intelligence, seperti pembuatan Chess Solver.

Victor Yngve di Massachusetts Institute of Technology (MIT) juga menggunakan linked list pada natural language processing dan machine transitions pada bahasa pemrograman COMMIT.

PENGERTIAN LINK LIST

Linked list (list bertaut) adalah salah satu struktur data dasar yang sangat fundamental dalam bidang ilmu komputer. Dengan menggunakan linked list maka programmer dapat menimpan datanya kapanpun dibutuhkan. Linked list mirip dangan array, kecuali pada linked list data yang ingin disimpan dapat dialokasikan secara dinamis pada saat pengoperasian program (run-time).

Pada array, apabila programmer ingin menyimpan data, programmer diharuskan untuk mendefinisikan besar array terlebih dahulu, seringkali programmer mengalokasikan array yang sangat besar(misal 100). Hal ini tidak efektif karena seringkali yang dipakai tidak sebesar itu. Dan apabila programmer ingin menyimpan data lebih dari seratus data, maka hal itu tidak dapat dimungkinkan karena sifat array yang besarnya statik. Linked list adalah salah satu struktur data yang mampu menutupi kelemahan tersebut.

Secara umum linked list tersusun atas sejumlah bagian-bagian data yang lebih kecil yang terhubung (biasanya melalui pointer). Linked list dapat divisualisasikan seperti kereta, bagian kepala linked list adalah mesin kereta, data yang disimpan adalah gerbong, dan pengait antar gerbong adalah pointer.

Programmer membaca data menyerupai kondektur yang ingin memeriksa karcis penumpang. Programmer menyusuri linked list melalui kepalanya, dan kemudian berlanjut ke gerbong (data) berikutnya, dan seterusnya sampai gerbong terakhir (biasanya ditandai dengan pointer menunjukkan alamat kosong (NULL)). Penyusuran data dilakukan secara satu persatu sehingga penyusuran data bekerja dengan keefektifan On. Dibandingkan array, ini merupakan kelemahan terbesar linked list. Pada array, apabilan programmer ingin mengakses data ke-n (index n), maka programmer dapat langsung mengaksesnya. Sedangkan dengan linked list programmer harus menyusuri data sebanyak n terlebih dahulu.

JENIS-JENIS LINKED LIST

(3)

 Double linked list

 Circular Linked List

Linked list (one way list) adalah suatu kumpulan elemen data (yang disebut sebagai node) dimana urutannya ditentukan oleh suatu pointer.

Setiap elemen (node) dari suatu linked list terdiri atas dua bagian, yaitu :

o INFO, berisi informasi tentang elemen data yang bersangkutan.

o NEXT (link field/next pointer field), berisi alamat dari elemen (node) selanjutnya yang dituju.

Berikut ini sebuah contoh linked list yang terdiri atas 4 node :

info next info next info next info next start

node ke-1 node ke-2 node ke-3 node ke-4 null

Pada node ke-4 field NEXT-nya berisi NULL, artinya node ke-4 tsb. adalah node terakhir.

Node-node dalam linked list tidak harus selalu digambarkan paralel seperti pada gambar diatas. Linked list pada contoh diatas dapat pula digambarkan seperti berikut ini :

null info

info

info next next

Ada dua hal yang menjadi kerugian dengan representasi suatu data dengan linked list ini, yaitu

a. Diperlukan ruang tambahan untuk menyatakan/tempat field pointer.

b. Diperlukan waktu yang lebih banyak untuk mencari suatu node dalam linked list.

Sedangkan keuntungannya adalah :

a. Jenis data yang berbeda dapat di-link.

b. Operasi REMOVE atau INSERT hanya dilakukan dengan mengubah pointer-nya Saja.

(4)

Ada beberapa aturan yang didefinisikan pada operasi didalam linked list, yaitu :

Jika P adalah suatu variabel pointer, maka nilainya adalah alamat atau lokasi dari variabel lain yang dituju.

Operasi yang didefinisikan pada suatu variabel pointer adalah : 1. Test apakah sama dengan NULL.

2. Test untuk kesamaan dengan variabel pointer lain. 3. Menetapkan sama dengan NULL.

4. Menetapkan menuju ke node lain.

Notasi yang didefinisikan sehubungan dengan operasi diatas adalah : 1. NODE(P), artinya node yang ditunjuk oleh pointer P.

2. INFO(P), artinya nilai INFO dari node yang ditunjuk pointer P.

3. NEXT(P), artinya hubungan (link) selanjutnya dari node yang ditunjuk oleh pointer P.

Sebagai contoh, perhatikan linked list dibawah ini :

A

NODE(P) = node yang ditunjuk oleh P yaitu node pertama. INFO(P) = A

NEXT(P) = node ke-dua INFO(NEXT(NEXT(P))) = C

MENGHAPUS SUATU NODE DARI LINKED LIST (REMOVE).

Untuk menghapus node dalam linked list digunakan procedure FREENODE.

Jika Q adalah suatu variabel pointer, maka FREENODE(Q) akan menyebabkan node yang ditunjuk oleh variabel pointer Q dihapus dari linked list.

Perhatikan linked list berikut :

(5)

Next(P) := Next(Q)

info

info info info

P Q

langkah ke-3 : Freenode(Q)

procedure Freenode(Q)

1. Next(Q) := Avail

info next Q

info info

next next next

P Avail

...

null

2. Info(Q) := Null

3. Avail := Q

next Q

info info

next next next

Avail

...

null

MENYISIPKAN SUATU NODE KE DALAM LINKED LIST

Untuk menyisipkan node dalam linked list digunakan procedure GETNODE.

Jika NEW adalah suatu variabel pointer, maka GETNODE(NEW) akan menyebabkan node yang ditunjuk oleh variabel pointer NEW disisipkan ke dalam linked list.

procedure Getnode(NEW)

(6)

then out-of-free-space

 else begin

Getnode := Avail;

info next info next info next info next null ...

Avail

 Avail := Next(Avail);

Getnode

Avail

 Next(Getnode) : = Null; end;

Getnode Avail null

Algoritma menyisipkan sebuah Node :

1. Getnode(NEW); 2. Info(NEW) := Name;

next next next

... NEW info

Name null

P Q

3. Q := Next(P) 4. Next(P) := NEW

next next next

... NEW info

Name null

(7)

5. Next(NEW) := Q

next next next

NEW info Name

P Q

Logika Linked List pada Array

1. Jika tidak menggunakan logika linked list (pada umumnya dalam meng-input data digunalan cara sequential)

Awal Insert E Delete

C Insert F

1 A 1 A 1 A 1 A

2 C 2 C 2 2

3 3 E 3 E 3 E

4 4 4 4 F

Insert G Delete

E

(overflo w)

1 A 1 A

2 2

3 3

4 F 4 F

2. Jika menggunakan logika Linked List

Keadaan awal Insert E Delete C

Info Nex

t Info Next Info Next

1 A 2 1 A 2 1 A 3

2 C 0 2 C 3 2 4

3 4 3 E 0 3 E 0

4 0 4 0 4 0

Insert F Delete E Insert G

Info Ne

xt Info Next Info Next

1 A 3 1 A 2 1 A 2

2 F 0 2 F 0 2 F 3

3 E 2 3 4 3 G 0

(8)

Circular Linked List

info next info next info next info next ...

first

Head Nodes

info next info next info next info next ...

Head

Circular Linked List dengan Head Node

info next Head

Circular Linked List dengan Head Node kosong

Algoritma penyisipan node yang berisi variabel Name pada head dalam Linked List

 Ambil node baru pada free storage kemudian node tersebut ditunjuk oleh pointer NEW

 Isikan Info dengan Name pada node baru tsb.

 Next dari node baru tsb. menunjuk ke node yang ditunjuk oleh pointer Head

 Pindahkan pointer Head menunjuk ke node yang baru.

Doubly Linked List

Head prior info

Tiap node memiliki pointer yang menunjuk ke node sesudahnya dan pointer yang menunjuk ke node sebelumnya.

Node Sesudahnya : Next(Node) Node sebelumnya : Prior(Node)

(9)

Double Linked List Kosong :

next prior

head

prior head next Prior(Head) = Head

Next(Head) = Head

Procedure menghapus sebuah node pada Double Linked List

1. Set pointer P

next prior info

P

2. Ubah pointer pada node Next predecessor P ke node Successor P

next prior info

P

3. Ubah pointer pada node dari prior Successor P ke node Predeccssor P

next prior info

P

4. bebaskan node yang ditunjuk pointer P

Penyisipan sebuah Node pada Doubly Linked List

 Ambil sebuah node baru dan isikan datanya

(10)

IN P

NEW

AVAIL

 Ubah pointer Next P menunjuk ke node baru

 Ubah pointer Prior dari Successor P menunjuk ke node baru

IN P

NEW

(11)

BAB II

ANALISA PROGRAM

PROGRAM 1

#include<iostream>

#include <conio.h> //file header ini tidak berfungsi (bisa dihapus)

using namespace std; class Simpul

{

public:

int iData; //item data double dData; //item data //pointer ke Simpul berikutnya Simpul* pBrktnya;

//pointer ke Simpul pertama Simpul* pPertama;

public: SenaraiBerantai() :

pPertama(NULL) //konstruktor { } //(masih belum ada Simpul)

bool apaKosong() //true jika senarai berantai kosong { pSenaraiBaru->pBrktnya = pPertama;

pPertama = pSenaraiBaru; }

Simpul* bacaPertama() //menghasilkan Simpul pertama {

return pPertama; }

(12)

Simpul* pTemp = pPertama; //menyimpan simpul pertama pPertama = pPertama->pBrktnya;

delete pTemp; }

void tampilSenarai() {

cout << "Senarai Berantai (pertama-->akhir): "; Simpul* pSkrg = pPertama; //berawal di awal senarai while (pSkrg != NULL) //sampai akhir senarai, {

pSkrg->tampilSimpul(); //menampilkan data

pSkrg = pSkrg->pBrktnya; //bergerak ke simpul berikutnya }

cout << endl; }

}; //akhir kelas SenaraiBerantai int main()

{ //menciptakan senarai berantai baru SenaraiBerantai senaraiBerantai;

senaraiBerantai.sisipPertama(22, 2.99); //menyisipkan empat item senaraiBerantai.sisipPertama(44, 4.99);

senaraiBerantai.sisipPertama(66, 6.99); senaraiBerantai.sisipPertama(88, 8.99);

senaraiBerantai.tampilSenarai(); //menampilkan senarai while (!senaraiBerantai.apaKosong()) //sampai kosong, { //membaca simpul pertama

Simpul* pTemp = senaraiBerantai.bacaPertama(); //menampilkan kuncinya cout << "Menghapus simpul dengan kunci " << pTemp->iData << endl; senaraiBerantai.hapusPertama(); //remove it

}

senaraiBerantai.tampilSenarai(); //menampilkan senarai kosong system("pause");

return 0;

} //akhir main()

(13)

ANALISA PROGRAM 1

Program diatas menggunakan class, dengan nama kelas “simpul” Kelas simpul mempunyai beberapa anggota public;

 int iData; //item data

 double dData; //item data

 Simpul* pBrktnya; pBrktnya adalah sebuah pointer bertipe simpul

 Simpul(int id, double dd) : //konstruktor merupakan suatu fungsi, pada baris ini konstruktor dengan parameter default yaitu (int id, double dd).

 iData(id), dData(dd), pBrktnya (NULL) //konstruktor merupakan suatu fungsi, pada baris ini konstruktor dengan parameter-parameter yaitu iData(id), dData(dd), pBrktnya(NULL)

 void tampilSimpul() //menampilkan Simpul (merupakan sebuah fungsi)

kelas senaraiBerantai private:

 Simpul* pPertama; pPertama sebuah pointer bertipe simpul

kelas senaraiBerantai public:

 SenaraiBerantai() : (merupakan sebuah fungsi)

pPertama(NULL) // konstruktor merupakan suatu fungsi, pada baris ini konstruktor dengan parameter default yaitu (NULL).

{ } //(masih belum ada Simpul)

bool apaKosong() //true jika senarai berantai kosong (merupakan sebuah fungsi) {

return pPertama==NULL; }

//menyisipkan ke awal senarai

void sisipPertama(int id, double dd) (merupakan sebuah fungsi) { //membuat simpul baru

Simpul* pSenaraiBaru = new Simpul(id, dd); pSenaraiBaru sebuah pointer bertipe simpul, didalam * pSenaraiBaru menyimpan nilai kembalian dari fungsi new Simpul(id, dd).

pSenaraiBaru->pBrktnya = pPertama; (untuk memproses pPertama) pPertama = pSenaraiBaru; inisialisasi nilai pPertama = pSenaraiBaru

}

Simpul* bacaPertama() // bacaPertama sebuah pointer bertipe simpul (merupakan sebuah fungsi).

{

return pPertama; }

(14)

Simpul* pTemp = pPertama; //menyimpan simpul pertama. pTemp sebuah pointer bertipe simpul, didalam * pTemp menyimpan nilai pPertama.

pPertama = pPertama->pBrktnya; (untuk memproses pPertama) delete pTemp; (untuk meghapus pTemp)

}

void tampilSenarai() (merupakan sebuah fungsi) {

cout << "Senarai Berantai (pertama-->akhir): ";

Simpul* pSkrg = pPertama; //berawal di awal senarai pSkrg sebuah pointer bertipe simpul, didalam * pSkrg menyimpan nilai pPertama.

while (pSkrg != NULL) //sampai akhir senarai, , fungsi pengulangan untuk menampilkan data yang tersimpan pada setiap simpul.

pSkrg->tampilSimpul(); //menampilkan data. Memanggil fungsivoid tampilSimpul().

pSkrg = pSkrg->pBrktnya; //bergerak ke simpul berikutnya (untuk memproses pSkrg)

Kemudian Fungsi utama pada program ini :

int main()

{ //menciptakan senarai berantai baru

SenaraiBerantai senaraiBerantai; variabel senaraiBerantai bertipe SenaraiBerantai.

senaraiBerantai.sisipPertama(22, 2.99); //menyisipkan empat item senaraiBerantai.sisipPertama(44, 4.99);

senaraiBerantai.sisipPertama(66, 6.99); senaraiBerantai.sisipPertama(88, 8.99);

tanda titik (.) merupakan sebuah operator yang berfungsi untuk mengakses anggota (operator akses anggota public dari luar kelas).

senaraiBerantai.tampilSenarai(); //menampilkan senaraiBerantai dengan mengakses fungsi tampiSenarai ( ).

while (!senaraiBerantai.apaKosong()) //sampai kosong, senaraiBerantai fungsi bool apaKosong() tidak true.

{ //membaca simpul pertama

Simpul* pTemp = senaraiBerantai.bacaPertama();//menampilkan kuncinya. pTemp sebuah pointer bertipe simpul, didalam pTemp menyimpan nilai fungsi senaraiBerantai.bacaPertama();

cout << "Menghapus simpul dengan kunci " << pTemp->iData << endl; untuk menampilkan Menghapus simpul dengan kunci << pTemp = senaraiBerantai.bacaPertama();<< membaca iData yang bertipe integer, sehingga nilai yang keluar (22, 44, 66 dan 88).

senaraiBerantai.hapusPertama(); untuk menghapus isi dari senaraiBerantai dari yang pertama sampai habis dengan mengakses fungsi hapusPertama().

(15)

senaraiBerantai.tampilSenarai(); //menampilkan senarai kosong karena telah dihapus. Mengakses fungsi tampilSenarai().

Beberapa operasi dasar pada program ini adalah sebagai berikut :

1. Pencarian senarai untuk menentukan apakah item tertentu berada di dalam senarai. 2. Oleh karena itu diberikan pointer yang menunjuk ke simpul pertama pada senarai

berantai, untuk melangkah melalui simpul-simpul senarai berantai, dengan menggunakan fungsi pengulangan while while (!senaraiBerantai.apaKosong())

3. Menghapus isi senarai secara satu persatu.

PROGRAM 2

#include <iostream>

{

public:

int iData; //item data double dData; //item data //pointer ke Simpul berikutnya Simpul* pBrktnya;

Simpul(int id, double dd) : //konstruktor iData(id), dData(dd), pBrktnya(NULL) {}

void tampilSimpul() //menampilkan Simpul {

cout << "{" << iData << ", " << dData << "} "; }

Simpul* pLama = pSkrg; //menyimpan simpul skrg pSkrg = pSkrg->pBrktnya; //ke simpul brktnya delete pLama; //menghapus simpul lama

} }

(16)

{ //membuat simpul baru

Simpul* pSenaraiBaru = new Simpul(id, dd); pSenaraiBaru->pBrktnya = pPertama; pPertama = pSenaraiBaru;

}

Simpul* cari(int kunci) //mencari simpul dengan kunci tertentu { //(asumsi senarai berantai tak-kosong)

Simpul* pSkrg = pPertama; //berawal di awal senarai

bool hapus(int kunci) //menghapus simpul dengan kunci tertentu { //(asumsi senarai berantai tak-kosong)

Simpul* pSkrg = pPertama; //mencari simpul Simpul* pSblmnya = pPertama;

while (pSkrg->iData != kunci)

(17)

}; //akhir kelas SenaraiBerantai int main()

{

SenaraiBerantai senaraiBerantai; //menciptakan senarai

senaraiBerantai.sisipPertama(22, 2.99); //menyisipkan 4 item senaraiBerantai.sisipPertama(44, 4.99);

senaraiBerantai.sisipPertama(66, 6.99); senaraiBerantai.sisipPertama(88, 8.99); senaraiBerantai.tampilSenarai(); //display list int cariKunci = 44; //mencari item

Simpul* pCari = senaraiBerantai.cari(cariKunci); if (pCari != NULL)

cout << "Ditemukan dengan kunci " << pCari->iData << endl; else

cout << "Tidak menemukan simpul yang dicari" << endl; int hapusKunci = 66; //menghapus item

bool hapusOK = senaraiBerantai.hapus(hapusKunci); if (hapusOK)

cout << "Dihapus simpul dengan kunci " << hapusKunci << endl; else

cout << "Tidak menemukan simpul yang ingin dihapus" << endl; senaraiBerantai.tampilSenarai(); //menampilkan senarai

system("pause"); return 0; } //akhir main()

(18)

program ini hampir sama dengan program 1 Cuma pada program ini menggunakan destructor,

Menggunakan class, dengan nama kelas “simpul” Kelas simpul mempunyai beberapa anggota public;

 int iData; //item data

 double dData; //item data

 Simpul* pBrktnya; pBrktnya adalah sebuah pointer bertipe simpul

 Simpul(int id, double dd) : //konstruktor merupakan suatu fungsi, pada baris ini konstruktor dengan parameter default yaitu (int id, double dd).

 iData(id), dData(dd), pBrktnya (NULL) //konstruktor merupakan suatu fungsi, pada baris ini konstruktor dengan parameter-parameter yaitu iData(id), dData(dd), pBrktnya(NULL)

 void tampilSimpul() //menampilkan Simpul (merupakan sebuah fungsi)

kelas senaraiBerantai private:

 Simpul* pPertama; pPertama sebuah pointer bertipe simpul

kelas senaraiBerantai public:

 SenaraiBerantai() : (merupakan sebuah fungsi)

pPertama(NULL) // konstruktor merupakan suatu fungsi, pada baris ini konstruktor dengan parameter default yaitu (NULL).

{ } //(masih belum ada Simpul)

~SenaraiBerantai() //destruktor (merupakan sebuah fungsi) tambahan dari program 1, destructor tidak memiliki tipe nilai balik, yaitu ia bukan merupakan fungsi penghasil nilai balik atau fungsi void. Nama sebuah destructor diawali dengan karakter tilde (~), diikuti dengan nama kelas. Contoh pada baris ini : ~SenaraiBerantai().

Destruktor secara otomatis dieksekusi ketika objek kelas keluar skop.

while(pSkrg != NULL) //sampai senarai kosong, fungsi pengulangan untuk menampilkan data yang tersimpan pada setiap simpul.

Simpul* pLama = pSkrg; //menyimpan simpul skrg pLama sebuah pointer bertipe simpul, didalam * pLama menyimpan nilai pSkrg.

pSkrg = pSkrg->pBrktnya; //ke simpul brktnya (untuk memproses pSkrg) delete pLama; //menghapus simpul lama

void sisipPertama(int id, double dd) (merupakan sebuah fungsi)

Simpul* pSenaraiBaru = new Simpul(id, dd); pSenaraiBaru sebuah pointer bertipe simpul, didalam pSenaraiBaru menyimpan nilai fungsi new Simpul(id, dd).

pSenaraiBaru->pBrktnya = pPertama; (untuk memproses = pPertama )

(19)

Simpul* cari(int kunci) //mencari simpul dengan kunci tertentu. Fungsi cari(int kunci) sebuah pointer bertipe simpul.

{ //(asumsi senarai berantai tak-kosong)

while(pSkrg->iData != kunci) //ketika tidak ada kecocokan, fungsi pengulangan untuk menampilkan data yang tersimpan pada setiap simpul tidak sama dengan kembalian dari fungsi cari(int kunci)

{

if(pSkrg->pBrktnya == NULL) //jika akhir senarai,

return NULL; //tidak menemukannya

pSkrg = pSkrg->pBrktnya; //ke simpul berikutnya

return pSkrg; //ditemukan

bool hapus(int kunci) //menghapus simpul dengan kunci tertentu

Simpul* pSkrg = pPertama; //mencari simpul

Simpul* pSblmnya = pPertama;

while (pSkrg->iData != kunci)

if (pSkrg->pBrktnya == NULL)

return false; //tidak ditemukan

pSblmnya = pSkrg; //ke simpul berikutnya

pSkrg = pSkrg->pBrktnya;

if(pSkrg == pPertama) //jika simpul pertama,

pPertama = pPertama->pBrktnya; //mengubah simpul pertama

pSblmnya->pBrktnya = pSkrg->pBrktnya;

delete pSkrg; //menghapus simpul

return true; //penghapusan berhasil

void tampilSenarai()

(20)

Simpul* pSkrg = pPertama; //berawal di awal senarai

Beberapa operasi dasar pada program ini adalah sebagai berikut :

1. Pencarian senarai untuk menentukan apakah item tertentu berada di dalam senarai. 2. Penghapusan sebuah item dari senarai berantai

Kedua operasi ini memerlukan penjelajahan senarai berantai, yaitu jika diberikan sebuah pointer yang menunjuk ke simpul pertama pada senarai berantai, maka harus melangkah melalui simpul-simpul senarai berantai.

PROGRAM 3

#include <iostream>

{

public:

double dData; //item data

//ptr ke simpul berikutnya dalam senarai Simpul* pBrktnya;

Simpul(double d) : dData(d), pBrktnya(NULL) //konstruktor { }

void tampilSimpul() //menampilkan simpul {

cout << dData << " "; }

}; //akhir kelas Simpul class SenaraiBerantaiGanda {

private:

Simpul* pPertama; //ptr ke simpul pertama Simpul* pAkhir; //ptr ke simpul terakhir public:

SenaraiBerantaiGanda() : pPertama(NULL), pAkhir(NULL) //konstruktor { }

~SenaraiBerantaiGanda() //destruktor { // (menghapus semua simpul) Simpul* pSkrg = pPertama; //di awal senarai

while (pSkrg != NULL) //sampai akhir senarai, {

(21)

} }

bool apaKosong() //true jika tidak ada simpul {

return pPertama==NULL; }

void sisipPertama(double dd) //menyisipkan di depan senarai { //menciptakan simpul baru

Simpul* pSimpulBaru = new Simpul(dd); if( apaKosong() ) //jika senarai kosong,

pAkhir = pSimpulBaru;

pSimpulBaru->pBrktnya = pPertama; pPertama = pSimpulBaru;

}

//menyisipkan di akhir senarai void sisipAkhir(double dd)

pAkhir->pBrktnya = pSimpulBaru; pAkhir = pSimpulBaru;

}

void hapusPertama() //menghapus simpul pertama { //(diasumsikan tak-kosong)

Simpul* pTemp = pPertama; //mengingat simpul pertama //jika hanya ada satu simpul

}; //akhir kelas SenaraiBerantaiGanda int main()

{

SenaraiBerantaiGanda senarai; //menciptakan senarai baru senarai.sisipPertama(22); //menyisipkan di depan

(22)

senarai.sisipPertama(66);

senarai.sisipAkhir(11); //menyisipkan di belakang senarai.sisipAkhir(33);

senarai.sisipAkhir(55);

senarai.tampilSenarai(); //menampilkan senarai cout << "Menghapus dua item pertama" << endl;

senarai.hapusPertama(); //menghapus dua item pertama senarai.hapusPertama();

senarai.tampilSenarai(); //menampilkan kembali system("pause");

return 0;

} //akhir main()

OUTPUT PROGRAM 3

Program diatas menggunakan class, dengan nama kelas “simpul” Kelas simpul mempunyai beberapa anggota public;

 double dData; //item data

 Simpul* pBrktnya; pBrktnya adalah sebuah pointer bertipe simpul  Simpul(double d) : dData(d), pBrktnya(NULL) //konstruktor

 void tampilSimpul() //menampilkan simpul

Kelas SenaraiBerantaiGanda private:

 Simpul* pPertama; //ptr ke simpul pertama

 Simpul* pAkhir; //ptr ke simpul terakhir Kelas SenaraiBerantaiGanda public:

 SenaraiBerantaiGanda() : pPertama(NULL), pAkhir(NULL) //konstruktor

 ~SenaraiBerantaiGanda() //destructor (merupakan sebuah fungsi) tambahan dari program 1, destructor tidak memiliki tipe nilai balik, yaitu ia bukan merupakan fungsi penghasil nilai balik atau fungsi void. Nama sebuah destructor diawali dengan karakter tilde (~), diikuti dengan nama kelas. Contoh pada baris ini : ~SenaraiBerantai().

Destruktor secara otomatis dieksekusi ketika objek kelas keluar skop.

{ // (menghapus semua simpul)

(23)

while (pSkrg != NULL) //sampai akhir senarai, fungsi pengulangan untuk menampilkan data yang tersimpan pada setiap simpul.

Simpul* pLama = pSkrg; //menyimpan simpul skrg pLama sebuah pointer bertipe simpul, didalam * pLama menyimpan nilai pSkrg.

pSkrg = pSkrg->pBrktnya; //ke simpul brktnya (untuk memproses pSkrg) delete pLama; //menghapus simpul lama

void sisipPertama(double dd) //menyisipkan di depan senarai (merupakan sebuah fungsi)

{ //menciptakan simpul baru

Simpul* pSimpulBaru = new Simpul(dd); pSimpulBaru sebuah pointer bertipe simpul, didalam pSimpulBaru menyimpan nilai fungsi new Simpul(dd).

if( apaKosong() ) //jika senarai kosong,

pSimpulBaru->pBrktnya = pPertama;

pPertama = pSimpulBaru;

void sisipAkhir(double dd)

Simpul* pSimpulBaru = new Simpul(dd);

if( apaKosong() ) //jika senarai kosong,

pPertama = pSimpulBaru;

pAkhir->pBrktnya = pSimpulBaru;

void hapusPertama() //menghapus simpul pertama

Simpul* pTemp = pPertama; //mengingat simpul pertama

//jika hanya ada satu simpul

if(pPertama->pBrktnya == NULL)

pAkhir = NULL; //NULL <-- akhir

pPertama = pPertama->pBrktnya;

delete pTemp; //menghapus

(24)

cout << "Senarai (pertama-->akhir): ";

Simpul* pSkrg = pPertama; //di awal senarai while(pSkrg != NULL) //sampai akhir senarai,

pSkrg->tampilSimpul(); //menampilkan data

pSkrg = pSkrg->pBrktnya; //ke simpul brktnya

Kemudian fungsi utama dalam program ini :

SenaraiBerantaiGanda senarai; //menciptakan senarai baru (variabel baru bertipe SenaraiBerantaiGanda)

senarai.sisipPertama(22); //menyisipkan di depan

senarai.sisipAkhir(11); //menyisipkan di belakang

senarai.tampilSenarai(); //menampilkan senarai

cout << "Menghapus dua item pertama" << endl;

senarai.hapusPertama(); //menghapus dua item pertama

senarai.hapusPertama();

(25)

BAB III

KESIMPULAN

Pada pertemuan praktikum ke-5 ini, saya dapat menyimpulkan Linked List atau Struktur Berkait atau Senarai Berantai, yaitu cara menyimpan data secara terstruktur sehingga programmer dapat secara otomatis menciptakan suatu tempat baru untuk menyimpan data kapan saja diperlukan. Sebuah pointer menunjuk simpul terkiri dan setiap simpul mempunyai pointer yang menunjuk ke simpul berikutnya. Pointer pada simpul terakhir tidak menunjuk kemana-mana maka berisi NULL. Setiap node pada linked list mempunyai field yang berisi pointer ke node berikutnya, dan juga memiliki field yang berisi data. Node terakhir akan menunjuk ke NULL yang akan digunakan sebagai kondisi berhenti pada saat pembacaan isi linked list.

Simpul pada linked list terdiri dari dua komponen utama yaitu:

1. Data yaitu bisa berupa satu elemen data atau beberapa elemen data. 2. Pointer yang menunjuk ke simpul lain.

Menambah Node di Depan

 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.

 Prinsipnya adalah mengkaitkan node baru dengan head, kemudian head akan menunjuk pada data baru tersebut sehingga head akan tetap selalu menjadi data terdepan.

Menambah Node di Belakang

 Penambahan data dilakukan di belakang, namun pada saat pertama kali, node langsung ditunjuk oleh head.

 Penambahan di belakang membutuhkan pointer bantu untuk mengetahui node terbelakang. Kemudian, dikaitkan dengan node baru.Untuk mengetahui data terbelakang perlu digunakan perulangan.

Menghapus Node di Depan

 Penghapusan node tidak boleh dilakukan jika keadaan node sedang ditunjuk oleh pointer, maka harus dilakukan penggunakan suatu pointer lain (hapus) yang digunakan untuk menunjuk node yang akan dihapus, barulah kemudian menghapus pointer hapus dengan menggunakan perintah delete.

 Sebelum data terdepan dihapus, terlebih dahulu head harus menunjuk ke node berikutnya agar list tidak putus, sehingga node setelah head lama akan menjadi head baru. Jika head masih NULL maka berarti data masih kosong!

Menghapus Node di Belakang

 Membutuhkan pointer bantu dan hapus. Pointer hapus digunakan untuk menunjuk node yang akan dihapus, pointer bantu untuk menunjuk node sebelum node yang dihapus yang akan menjadi node terakhir.