Single Linked List

Yuliana Setiowati, S.Kom

Linked List
p1 tom macao 10

p2 mary taipa 14

p3 john macao 22

p4 ann macao 18

Misalnya kita buat banyak record

student sebagai variabel dinamik, kita
perlu mengorganisasi data kita, supaya
efisien
Linked List
p1 tom macao 10

mary taipa 14

john macao 22

ann macao 18

Salah satu cara adalah menghubungkan

semua record student dengan pointer
 Linked List
• Single linked list atau linked list
• Tiap elemen terdiri dari dua bagian, yaitu sebuah data
dan sebuah pointer yang disebut dengan pointer next.
 Linked List
linked list terpencar-pencar di memori
Pointer dari elemen ke elemen berarti
sebagai penjamin bahwa semua elemen dapat
diakses.
 Representasi Simpul
struct node{
int info ;
struct node *next ;
};
typedef struct node *NODEPTR;
NODEPTR head , tail ;
Linked List
*head

head b c

struct Node {
char data;
Node *next;
};

Node *head;
Linked List head->data head->next->data

head b c

head->next->next

struct Node { head->next

char data;
Node *next;
};

Node *head;
Linked p=head->next;
List
p p->next

head b c

p->data

Pointer berikutnya dari node

paling akhir = NULL

Node pertama
ditunjuk oleh pointer
yang disebut head
linked list kosong
head
Linked List yang masih
kosong dinyatakan dengan
pointer head = NULL.
Ingat bahwa head
menunjuk ke node pertama
linked list. Jika list kosong
node pertama tidak ada
head
Contoh
#include <stdlib.h> (A) head
struct Node { ?
char data; p a
Node *next; ?
};

int main ( ) { (B) head a

Node *head;
?
p
Node *p;
p = (Node*) malloc(sizeof(Node));
p->data = 'a'; (A) (C) head a
head = p; (B) ?
p = (Node*) malloc(sizeof(Node)); p b
p->data = 'b'; (C) ?
…
Contoh
(C) head a
… (C) ?
head->next = p; (D) p b
p = (Node*) malloc(sizeof(Node)); ?
p->data = 'c'; (E)
head->next->next = p; (D) head a
p->next = NULL; (F)
p b
… ?
}
(E) head a

(F) head a b c b
?
p c
p ?
 Gambar diagramnya !
Latihan
…
int main ( ) {
Node *head = NULL;
Node *p;
p = (Node*) malloc(sizeof(Node));
p ->data = 'a'; (A)
p->next = (Node*) malloc(sizeof(Node));
p->next->data = 'b';
p->next->next = NULL; (B)
head = (Node*) malloc(sizeof(Node));
head->data = 'c';
head->next = p; (C)
…
}
 Alokasi Simpul
NODEPTR getnode(int d){
NODEPTR p ;
p = (NODEPTR) malloc(sizeof(struct node));
p->info = d ;
p->next = NULL ;
return(p);
}
 Membebaskan memori
void free_node(NODEPTR p)
{ free(p);
p = NULL ;
}
Penelurusan linked list , 1
head a b c

p p p

Pointer p menunjuk ke node

saat ini. Setelah pemrosesan, p
menunjuk ke node berikutnya

p = p->next;
Penelurusan linked list, 2
head a b c

p = head; Dimulai dari node pertama

(ditunjuk oleh head) Lakukan
while (p!=NULL) { looping sampai p menunjuk
printf("%c", p->data); ke NULL
p = p->next;
}
p = head;
Pastikan program
while (p) {
menangani linked list
…
kosong
p = p->next;
}
Operasi pada Linked List

• menambahkan node (insert)

• menghapus node (delete).
Operasi Insert
insert sebagai node awal (head) dari linked
list
insert setelah node tertentu
insert sebelum node tertentu
insert sebagai node akhir (tail) dari linked list
 Insert sebagai node awal (head) dari
linked list
void insertashead(NODEPTR insert) Kondisi Awal
{
1 insert->next=head;

2 head = insert;
}

1 2
Insert sebagai node akhir (tail)
Kondisi Awal
void insertastail(NODEPTR insert)
{ if (head==NULL){
1 head = insert ;
2 tail = head ; 1
}
else
{ tail->next = insert ;
2
tail = tail->next ;
}
}
 Insert sebagai node akhir (tail)
Kondisi Awal

1. tail->next = insert ; 1
2. tail = tail->next ;

2
 Insert setelah node tertentu
void insertafternode(int x, NODEPTR insert)
{ NODEPTR after ;
after = head;
while (after->info != x)
after = after->next;
insert->next = after->next;
after->next = insert;
}
1

2
3

4
 Insert sebelum node tertentu
void insertbeforenode(int x, NODEPTR insert)
Jika data yang dicari
{ NODEPTR before, prevbefore;
berada pada awal Linked
if (head->info == x) List
insertashead(insert);
else
{ before = head; Jika data yang dicari
do tidak berada pada awal
Linked List
{ prevbefore = before;
before = before->next;
}while (before->info != x);
insert->next = before;
prevbefore->next = insert;
}
1

2
3

4
 Operasi Delete
delete sebagai simpul pertama(head) dari
linked list
delete pada simpul tertentu
delete simpul terakhir
Penghapusan Node Pertama

Pointer first diarahkan pada data ke-2

Pointer p diarahkan pada data ke-1
Bebaskan pointer p (secara otomatis data
ke-1 terhapus)
Penghapusan Node Pertama
Penghapusan Simpul
Terakhir
1. Telusuri simpul s/d first->next = NULL
2. Arahkan pointer p ke first
3. Bebaskan pointer p->next (Simpul
Terakhir)
4. Arahkan p->next ke NULL
Penghapusan pada Node
Tertentu – Data di Tengah
first 1 2 3 4

first 1 2 3 4

first 4
1 2 3

first 1 3 4
void del_node(int data)
jika data yang akan dihapus
{ NODEPTR del, beforedel ;
berada pada awal Linked List
del = head ;
beforedel = del ; jika data yang akan dihapus
if (del->info == data )
berada pada awal Linked List
dan hanya ada satu data
{ if (del->next == NULL)
{ head = NULL ;
jika data yang akan dihapus
free_node(del); berada pada awal Linked List dan
} Linked List lebih dari satu data
else
{ head = head -> next ;
free_node(del);
}
}
else jika data yang akan dihapus bukan
{ while(del->info != data) pada awal Linked List

{
untuk mencari data yang akan
beforedel = del ; dihapus
del=del->next;
}
if (del->next == NULL) Jika data yg akan dihapus pada
akhir Linked List
{
beforedel->next=NULL;
free_node(del);
}
Jika data yg akan dihapus bukan
else pada akhir Linked List
{
beforedel->next = del->next;
free_node(del);
}