Linked LIst
Ilustrasi Single Linked List
Data 1
Data 1 Data 2
Next node Data 2
Data 3
Next node Data 3
Next node
Data 4
Data 4
NO NEXT
Linked List
Struktur data yang terdiri dari beberapa simpul (node)
dimana setiap simpulnya saling terhubung (linked).
Simpul berupa struct, sedangkan link berupa komponen
simpul yang bertipe pointer ke simpul.
Bersifat dinamis. Memakai perintah malloc() dan free().
Umumnya memiliki pointer head untuk menunjukkan
alamat simpul terdepan dan pointer tail untuk
menunjukkan simpul terakhir.
Operasi penambahan/ penghapusan sebuah simpul akan
meng-update nilai pointer link-nya.
Pointer link simpul terakhir diberi nilai NULL (kecuali
untuk circular linked list).
Apakah Linked List itu ?
• Elemen (disebut dengan CELL, atau SEL dalam bahasa
Indonesia) yang mungkin terletak terpisah-pisah di memory,
disambungkan dengan pointer.
• Tiap sel berisi dua informasi : nilai dan pointer ke sel
berikutnya
CELL
Linked List Sederhana
Deklarasi struktur data :
typedef struct{
char nama[20];
float nilai;
struct simpulku *next_simpul;
} simpulku;
void main()
simpulku *simpul1, *simpul2, *simpul3;
//alokasi memori
simpul1 = (simpulku *)malloc(sizeof(simpulku));
simpul2 = (simpulku *)malloc(sizeof(simpulku));
simpul3 = (simpulku *)malloc(sizeof(simpulku));
//isi data
strcpy(simpul1->nama, “Amin”);
strcpy(simpul2->nama, “Budi”);
strcpy(simpul3->nama, “Citra”);
simpul1->nilai=90;
simpul2->nilai=20;
simpul3->nilai=100;
//sambungkan link-nya
simpul1->next_simpul = simpul2;
simpul2->next_simpul = simpul3;
simpul3->next_simpul = NULL;
Alamat = 1000 Alamat = 1080 Alamat = 2370
Amin Budi Citra
90 20 100
1080 2370 NULL
Pointer Tail
simpul1
1000 Pointer Head
Ilustrasi Inserting a Node
T
update
Alamat = 8460
simpul1
Dewi
1000 New 98
Newnext = Tnext 2370
Tnext = New
Ilustrasi Deleting a Node
P T
update
free()
simpul1
1000 Pnext = Tnext
free(T)
Array vs Linked List
header
1 a[0] 13
2 a[1]
address 13 address 18 address 24
3 a[2]
1 18 2 24 3
value value next value next
Pointer ke sel berikutnya
(next)
( NULL )
struct CELL {
int a[3];
struct CELL *next;
int n;
int value;
} header;
struct tnode {
int data;
struct tnode *next;
};
Atau
int main () {
struct tnode *head, *node;
int bil;
head = NULL;
}
Field Field
Head Data Next
…
Pembentukan simpul di awal (kiri)
Langkah-langkahnya :
1. Mengalokasikan simpul baru malloc()
2. Memasukkan data atau nilai ke dalam simpul,
3. Memberi nilai NULL kepada field pointer next,
4. mengubah pointer head sehingga menunjuk ke simpul tersebut.
scanf("%d", &bil);
node = (struct tnode*) malloc (sizeof(struct tnode)); //1
node->data = bil; //2
if (head == NULL)
{
node->next = NULL; //3
head = node; //4
}
Penambahan Simpul Baru
1. memesan sebuah simpul baru dengan menggunakan instruksi malloc(),
2. memasukkan data atau nilai ke simpul,
3. mengaitkan field pointer next pada simpul baru ke simpul yang ditunjuk
pointer head. Tindakan ini menyebabkan simpul baru ini terkait
(terhubung) ke SLL clan menjadi simpul pertama,
4. mengubah pointer head sehingga menunjuk ke simpul baru ini.
scanf("%d", &bil);
node = (struct tnode*) malloc (sizeof(struct tnode)); //1
node->data = bil; //2
if (head != NULL) {
node->next = head; //3
head = node; //4
}
# include <stdio.h> node = head;
# include <stdlib.h> while (node!=NULL) {
printf("%d”,node->data);
node = node->next;
struct tnode { }
int data; while (head != NULL) {
node=head;
struct tnode *next;
head=head->next;
}; free(node);
int main() { }
return 0;
struct tnode *head, *node;
}
int bil;
head = NULL;
printf("ketik bilangan : “);
do{
if (scanf("%d", &bil)!=1) break;
node = (struct tnode*) malloc (sizeof(struct tnode));
node->data = bil;
node->next = head;
head = node;
while (1);
Penambahan Simpul di akhir (kanan)
Pembentukan simpul pertama :
scanf("%d", &(node->data));
Nodenext = NULL;
if (head == NULL) {
head = node;
tail = node;
}
Penambahan Simpul ke ujung kanan
node = (struct tnode*)malloc
sizeof(struct tnode));
scanf("%d", &(node->data));
node->next = NULL;
if (head !=NULL) {
tail->next = node;
tail = node;
}
# include <stdio.h>
# include <stdlib.h>
struct tnode {
int data;
struct tnode *next;
} ;
int main() {
struct tnode *head, *tail, *node;
int bil;
head = NULL;
printf("ketik bilangan : “);
do{
if (scanf("%d", &bil) 1) break;
node = (struct tnode*) malloc (sizeof(struct tnode));
node->data = bil;
node->next = NULL;
if (head == NULL) head = node;
else tail->next = node;
tail = node;
}while (1);
return 0; }
Penambahan Simpul di Tengah
Jika penambahan simpul dilakukan mulai dari senarai berkait yang
masih kosong maka beberapa kondisi harus diperhatikan.
1. Apabila SLL masih kosong, kondisi head == NULL, maka
jadikan simpul baru sebagai simpul pertama.
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.
Pembuatan Single Linked List non
Circular (1)
Deklarasi Node
typedef struct TNode{
int data;
TNode *next;
};
Penjelasan:
Pembuatan struct bernama TNode yang berisi 2
field, yaitu field data bertipe integer dan field
next yang bertipe pointer dari TNode
Setelah pembuatan struct, buat variabel head
yang bertipe pointer dari TNode yang berguna
sebagai kepala linked list.
Pembuatan Single Linked List non
Circular (2)
Digunakan keyword new yang berarti
mempersiapkan sebuah node baru berserta
alokasi memorinya, kemudian node
tersebut diisi data dan pointer nextnya
ditunjuk ke NULL.
TNode *baru;
baru = new TNode;
baru->data = databaru;
baru->next = NULL;
Cara lain alokasi pointer
Menggunakan alokasi memori secara
manual
Menggunakan header stdlib.h atau
malloc.h
Menggunakan fungsi:
<pointer type> *malloc(int size);
SLLNC MENGGUNAKAN HEAD
Dibutuhkan satu buah variabel pointer: head
Head akan selalu menunjuk pada node pertama
void hapusBelakang(){
TNode *bantu,*hapus;
int d;
if (isEmpty()==0){
bantu = head;
if(head!=tail){
while(bantu->next!=tail){
bantu = bantu->next;
}
hapus = tail;
tail=bantu;
d = hapus->data;
delete hapus;
tail->next = NULL;
}else {
d = tail->data;
head=tail=NULL;
}
cout<<d<<" terhapus\n";
} else cout<<"Masih kosong\n";
}
SLLNC dengan HEAD & TAIL
SLLNC dengan HEAD & TAIL
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 pointer hapus
dengan menggunakan perintah delete.
Jika tail masih NULL maka berarti list masih kosong!
SLLNC dengan HEAD & TAIL
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;
}