Linked list

Linked List adalah struktur data yang berbeda dengan struktur data array. Linked list dapat
dibayangkan seperti rantai yang bersambung satu sama lainnya. Tiap-tiap rantai (node)
terhubung dengan pointer.
Gambar berikut memperlihatkan sebuah Linked List.

Sebelum kita membahas lebih jauh tentang Linked List, alangkah baiknya bila kita mengulang
sedikit tentang struct dan typedef. Struct atau structure dalam bahasa pemograman C/C++
digunakan untuk mendefinisikan tipe data yang memiliki anggota (member) bertipe tertentu.
Berikut contoh dan cara mendeklarasi sebuah struct:
struct tgl {
int hari;
int bulan;
int tahun;
}
struct tgl Tanggal;

Bila divisualisasikan kira-kira sebagai berikut:

Contoh di atas memperlihatkan bagaimana mendeklarasi sebuah struct dengan nama struct tgl
yang memiliki tiga member yaitu hari, bulan dan tahun yang bertipe int (integer). Kemudian,
sebuah variabel Tanggal dideklarasikan bertipe struct tgl. Untuk mempersingkat dan
menyederhanakan pendeklarasian sebuah struct, kata cadang typedef biasa digunakan.

Sesuai namanya, typedef digunakan untuk mendefinisikan sebuah tipe data menjadi suatu alias
tertentu. Perhatikan contoh berikut:

Dengan cara yang sama, pendeklarasian struct tgl di atas dapat disederhanakan menggunakan
kata cadang typedef menjadi:
typedef struct tgl {
int hari;
int bulan;
int tahun;
} Date;
Date Tanggal;

Single Linked List

Linked list dapat dianalogikan sebagai rantai yang terdiri dari beberapa node yang saling terkait.
Dengan memegang node terdepan, maka node-node yang saling terkait lainnya dapat kita
telesuri.
Dengan hanya mencatat atau memegang alamat dari alokasi data bertipe struct root pada sebuah
variabel LL maka keberadaan node-node dalam linked list tersebut dapat diketahui. Bila datadata dalam node berupa bilangan bulat, maka struct yang diperlukan untuk membentuk linked
list adalah sebagai berikut:

typedef struct node * NodePtr;

typedef struct node {
int data;
NodePtr next;
}Node;

typedef struct root {

NodePtr head;
unsigned size;
}Root;
Root LL;

Penambahan Node Linked List

Bila setiap penambahan simpul pada linked list dilakukan pada bagian depan (paling dekat
dengan head) maka kompleksitas yang diperlukan untuk menambah node baru dalam linked list
konstan atau O(1). Penambahan sebuah node dengan nilai 3 pada linked list di atas dapat
divisualisasikan sebagai berikut:

Penelusuran Node Linked List

Kompleksitas penelusuran (pencarian) node dalam linked list adalah linier atau O(n). Hal ini
disebabkan karena node-node dalam linked list disusun secara acak (tidak berurut). Seandainya
pun simpul-simpul dalam linked list disusun secara berurut, metode pencarian biner (binary
search) tetap tidak dapat dipergunakan. Ada 2 alasan mengapa pencarian biner tidak dapat
digunakan:
1. Linked list tidak memiliki indeks seperti array, sehingga akses langsung ke node tertentu
tidak dapat dilakukan. Untuk menuju ke node tertentu, proses pemeriksaan tetap dimulai dari
node head (node terdepan). Oleh karena itu proses pencarian selalu berjalan secara linier.
2. Tidak dapat membagi linked list menjadi 2 bagian yang sama besar seperti saat membagi
array menjadi 2 bagian bila metode pencarian biner diaplikasikan pada array terurut.

Penghapusan Node Linked List

Sebelum proses penghapusan dilakukan, pencarian node yang ingin dihapus harus terlebih
dahulu dilakukan. Bila node yang ingin dihapus ditemukan, suatu hal yang selalu harus
diperhatikan adalah bagaimana mengeluarkan node tersebut dari linked list dan kemudian
menyambung kembali linked list kembali. Kompleksitas menghapus sebuah node dalam linked
list adalah O(n). Perhatikan gambar berikut ini:

Implementasi Linked List

/* linkedlist.h: header file */
typedef struct node * NodePtr;
typedef struct node {
int data;
NodePtr next;
}Node;
typedef struct list {
NodePtr head;
unsigned size;
}List;
void initList(List *);
int addList(List *, int);
void displayList(List *);
void freeList(List *);

/* linkedlist.c: implementasi method dilakukan dalam file ini */

#include "linkedlist.h"
#include <stdlib.h>
#include <stdio.h>
void initList(List * lptr) {
lptr->head = NULL;
lptr->size = 0;
}
int addList(List * lptr, int data) {
NodePtr new;
new = malloc(sizeof(Node));
if(new == NULL) {
printf("Error dalam membuat alokasi memori\n");
return 0;
}
new->data = data;
new->next = lptr->head;
lptr->head = new;
lptr->size++;
return 1;
}
void displayList(List * lptr) {
NodePtr current = lptr->head;
printf("\n");
while(current != NULL) {
printf("%d -> ", current->data);
current = current->next;
}
printf("null\n");
}
void freeList(List * lptr) {
NodePtr next=lptr->head;
NodePtr current=next;
while(current != NULL) {
next = current->next;
free(current);
current = next;
}
}

/* main.c */

#include <stdlib.h>
#include <stdio.h>
#include "linkedlist.h"
int main(void) {
int i, n, data;
List LL;
initList(&LL);

/* Buat initial linked list */

printf("Jumlah simpul = ");

scanf("%d", &n);
/* Input data simpul */
for(i=0; i<n; i++) {
printf("Data = ");
scanf("%d", &data);
addList(&LL, data);
}
displayList(&LL);
freeList(&LL);
return EXIT_SUCCESS;

Keuntungan dan kerugian

Keuntungan utama pemanfaatan daftar berantai dibandingkan larik, ataupun daftar biasa adalah
kemudahan dan efektifitas kerja yang lebih baik dalam hal menambah, mengurangi, serta
mencari suatu elemen/node yang terdapat dalam daftar. Hal tersebut dimungkinkan karena
elemen-elemen yang terdapat pada sebuah daftar berantai tidak ditempatkan pada sebuah blok
memori komputer seperti halnya larik ataupun daftar biasa, melainkan tiap-tiap elemen/node
tersebut tersimpan dalam blok memori terpisah, penambahan, pengurangan, ataupun penggantian
node dapat dilakukan dengan mengubah elemen rujukan atas tiap-tiap node yang terkait.
Kerugiannya, sebuah daftar berantai tidak memungkinkan pengaksesan elemen secara acak,
dalam artian untuk dapat mengakses node ke tiga pada contoh di atas harus dilakukan dengan
cara mengunjungi elemen-elemen sebelumnya, dimulai dari elemen pertama, ke dua, seterusnya
hingga pada lokasi elemen yang dimaksudkan.

Jenis-jenis daftar berantai

Daftar bertaut tunggal

Bila struktur data sebuah node hanya memiliki satu tautan atas node berikutnya dalam sebuah
daftar bertaut, maka daftar bertaut tersebut dinamakan sebagai daftar bertaut tunggal.

Daftar bertaut tunggal dengan tiap-tiap node yang terdiri atas dua elemen, data integer, dan elemen rujukan ke
node berikutnya

Daftar bertaut ganda

Berbeda halnya dengan daftar bertaut tunggal, pada daftar bertaut ganda, struktur data atas tiaptiap node memiliki rujukan pada node sebelum dan berikutnya. Sebagian algoritma
membutuhkan taut ganda, contohnya sorting dan reverse traversing.

Daftar bertaut ganda dengan tiap-tiap node yang terdiri atas tiga elemen, data integer, dan dua elemen rujukan ke
node sebelum serta berikutnya

Daftar bertaut sirkular

Pada dua jenis daftar sebelumnya, node terakhir dalam daftar tersebut merujuk pada null yang
artinya akhir dari sebuah daftar, begitu pula null sebagai rujukan node sebelumnya pada node
pertama bila daftar yang dimaksudkan adalah daftar bertaut ganda. Pada daftar bertaut sirkular,
informasi rujukan pada node terakhir akan merujuk pada node pertama, dan rujukan pada node
pertama akan merujuk pada node terakhir bila yang digunakan sebagai dasar implementasi
adalah daftar bertaut ganda.

Sumber pustaka

 Juan, Angel (2006) (pdf), Ch20 Data Structures; ID06 - PROGRAMMING with JAVA (slide
part of the book Big Java, by CayS. Horstmann), hlm. 3
"Definition of a linked list". National Institute of Standards and Technology. 16 Agustus
2004. Diakses pada 14 Desember 2004.
Antonakos, James L. (1999). Practical Data Structures Using C/C++. Prentice-Hall.
hlm. 165190. ISBN 0-13-280843-9.
Collins, William J. (2005) [2002]. Data Structures and the Java Collections Framework.
New York: McGraw Hill. hlm. 239303. ISBN 0-07-282379-8.
Cormen, Thomas H. (2003). Introduction to Algorithms. MIT Press. hlm. 205213 & 501
505. ISBN 0-262-03293-7.
Cormen, Thomas H. (2001). "10.2: Linked lists". Introduction to Algorithms (edisi ke-2md).
MIT Press. hlm. 204209. ISBN 0-262-03293-7.
Green, Bert F. Jr. (1961). "Computer Languages for Symbol Manipulation". IRE
Transactions on Human Factors in Electronics (2): 38.
McCarthy, John (1960). "Recursive Functions of Symbolic Expressions and Their
Computation by Machine, Part I". Communications of the ACM.
Knuth, Donald (1997). "2.2.3-2.2.5". Fundamental Algorithms (edisi ke-3rd). AddisonWesley. hlm. 254298. ISBN 0-201-89683-4.
Newell, Allen (1957). "Programming the Logic Theory Machine". Proceedings of the
Western Joint Computer Conference: 230240.
Parlante, Nick (2001). "Linked list basics". Stanford University. Diakses pada 21 September
2009.
Sedgewick, Robert (1998). Algorithms in C. Addison Wesley. hlm. 90109. ISBN 0-20131452-5.
Shaffer, Clifford A. (1998). A Practical Introduction to Data Structures and Algorithm
Analysis. New Jersey: Prentice Hall. hlm. 77102. ISBN 0-13-660911-2.
Wilkes, Maurice Vincent (1964). "An Experiment with a Self-compiling Compiler for a
Simple List-Processing Language". Annual Review in Automatic Programming (Pergamon Press)
4 (1).
Wilkes, Maurice Vincent (1964). "Lists and Why They are Useful". Proceeds of the ACM
National Conference, Philadelphia 1964 (ACM) (P-64): F11.
Shanmugasundaram, Kulesh (2005-04-04). "Linux Kernel Linked List Explained". Diakses
pada 21 September 2009.

Nama : setiyono lukito

Npm : 1135010031