LINKED LIST

Dalam dunia komputer, linked list banyak secara ekstensif digunakan didalam sistem
manajemen database, manajemen proses, sistem operasi, editor dan lain sebagainya. Apabila
menggunakan array untuk menempatkan beberapa buah struktur sejenis (array of structure) di
memori, maka akan dialokasikan dengan cara statis. Artinya, apabila dideklarasikan dengan 10
buah elemen, maka ukuran memori yang akan dialokasikan di memori adalah 10 dikalikan
dengan ukuran struktur yang didefinisikan sebelumnya. Hal yang perlu ditekankan disini
adalah apabila ternyata hanya melakukan pengisian terhadap array tersebut hanya 5 elemen,
maka memori yang dialokasikan tetap untuk 10 buah elemen. Ini jelas merupakan pemborosan
memori yang harus dihindari dalam pembuatan program. Oleh karena itu, untuk membuat
pekerjaan ini menjadi dinamis maka pra programmer pada umumnya menggunakan linked list
sehingga pengalokasian memori dapat sesuai dengan kebutuhan. Selain itu dengan
menggunakan cara ini juga dapat menambahkan atau menghapus elemen yang terdapat pada
linked list tersebut.
Menurut definisinya, linked list adalah sebuah rangkaian struktur sejenis (bertipe sama) yang
dihubungkan dengan menggunakan salah satu (beberapa) field yang bertipe pointer.
Pendefinisan struktur harus dipahami sebelumnya untuk mengerti tentang linked list.
Struct node {
Int data;
Struct node *p;
};
Pada baris diatas ada sebuah struktur dengan nama node, dimana di dalamnya terdapat 2 buah
field yaitu data (bertipe int) dan p(bertipe pointer ke struktur node). Field data yang akan
digunakan untuk menyimpan nilai, sedangkan pointer p akan digunakan untuk menyimpan
alamat dari struktur node lainnya yang terdapat pada rangkaian.

Gambar. Rangkaian linked list

Pada gambar terdapat 4 buah struktur node, masing-masing menyimpan data 10,20,30,40.
Pointer p yang terdapat pada struktur node ke 1 berisi alamat dari struktur node ke 2, p yang
terdapat pada struktur node ke 2 akan berisi alamat dari struktur node ke 3. Begitupun pointer
p yang terdapat pada struktur node ke 3 akan menunjukkan atau berisikan alamat dari struktur
node ke 4. Sedangakan pointer p yang didalam struktur node ke 4 akan berisi NULL, hal ini
menunjukkan bahwa struktur tersebut merupakan struktur node yang berada pada akhir
rangkaian. Hal semacam ini yang dinamakan dengan struktur terkait atau linked list.
Berdasarkan cara pengisian dan pengambilan elemennya, linked list terbagi atas 2 jenis yaitu
stack (tumpukan) dan queue(antrian).
Stack (Tumpukan)
Stack adalah jenis linked list yang menerapkan konsep LIFO artinya elemen struktur yang
dimasukkan ke dalam rangkaian terakhir kali apabila ditampilkan kembali maka akan muncul
pertama kali. Contoh program :
#include<stdio.h>
#include<stdlib.h>

//definisikan struktur node

struct node {
int data;
struct node *p;
};

//definisikan fungsi untuk meletakan atau mengisikan struktur node ke dalam stack

void push(struct node **s, int nilai){

struct node *temp;
temp=(struct node*) malloc(sizeof(struct node));
temp->data =nilai; //mengisikan field data pd struktur node
temp->p =*s; //mengisi field p pada struktur node
*s =temp;
}

//mendefinisikan fungsi untuk mengambil struktur node dalam stack

void pop(struct node **s){
struct node *temp;
int nilai=1;
int i=1;
 if(*s !=NULL){
temp=*s;
nilai =temp->data;
*s=temp->p;
free(temp);
return nilai;
}else {
return i; //apabila stack kosong maka program stop
}
}

int main(void) {
struct node *paling_atas; //pointer ini akan selalu menunjuk ke elemen paling atas
//melakukan inisialisasi terhadap pointer paling_atas dgn NULL
paling_atas =NULL; //mula-mula stack dalam keadaan kosong

//mengisikan struktur node kedalam stack menggunakan fungsi push

push(&paling_atas, 10);
push(&paling_atas, 20);
push(&paling_atas, 30);
push(&paling_atas, 40);

//tampilkan struktur node yang ada didalam stack dengan fungsi pop
while (paling_atas != NULL) {
paling_atas=paling_atas->p; //menunjukkan ke elemen dibawahnya

printf("%d\n",*paling_atas);
}
return 0;
}
Hasil output yang diberikan adalah :

Jika diperhatikan kembali fungsi push () pda sintaks program :

void push(struct node **s, int nilai){
struct node *temp;
temp=(struct node*) malloc(sizeof(struct node));
temp->data =nilai; //mengisikan field data pd struktur node
temp->p =*s; //mengisi field p pada struktur node
*s =temp;
Disini kita melewatkan 2 buah parameter yaitu pointer *s (pointer ke struktur node) dan nilai.
Namun dalam fungsi ini, kita akan melewatkan pointer *s tersebut berdasarkan alamatnya
(passing by reference) sehingga akan dituliskan kedalam parameter dengan sintaks : struct node
**s.
Dengan kata lain s merupakan pointer ke pointer yang sedang menunjukke tipe struktur node.
Apabila masih bingung dengan kondisi ini, lihat kembali penjelasan tentang pointer ke pointer
dan juga tentang pengiriman parameter berdasarkan alamat.
Dalam kasus ini, pointer *s akan digunakan untuk menyimpan alamat dari struktur node yang
akan dimasukkan ke dalam stack. Sebagai bantuan untuk memudahkan proses dalam fungsi
ini, bisa dideklarasikan pointer temp. Selanjutnya pointer temp tersebut digunakan untuk
mencatat alamat dari struktur yang dialokasikan menggunakan fungsi malloc(). Field data dari
pointer temp akan diisi dengan parameter nilai sedangkan field p diisi dengan parameter *s.
Kemudian pointer *s itu sendiri sekarang akan diisi dengan pointer temp.
Oleh karena pointer *s dilewatkan berdasarkan alamat, maka pada saat pemanggilan pun harus
didefinisikan dengan sebuah alamat dari pointer ke tipe struktur node. Pada program diatas,
terdapat pointer paling_atas yang menunjuk ke tipe struktu node, sehingga dapat melakukan
pemanggilan fungsi push dengan cara : push (&paling_atas,10);
Ini artinya mula-mula akan dilakukan penyimpanan alamat yang ditunjukkan oleh pointer
paling_atas ke dalam field p dari struktur baru yang dialokasikan. Sedangkan field data dari
struktur baru tersebut diisi dengan nilai 10. Setelah itu pointer paling_atas sekarang
diperintahkan untuk menunjuk ke alamat lain, yaitu alamat dari struktur yang baru saja
dialokasikan. Apabila ditambahkan elemen struktur baru lagi kedalam stack, maka pointer
paling_atas juga akan berpindah menunjuk ke alamat dari struktur yang ditambahkan, dan
begitu seterusnya.
Alokasi Simpul
Ketika variabel dideklarasikan, terlebih dahulu harus diinisialisasi. Demikian juga dengan
pengalokasian dinamis sehingga fungsi yang mengalokasikan node baru, fungsi
allocate_node() menggunakan malloc() untuk mendapatkan memori aktual yang akan
menginisialisasi suatu field data. Next selalu diinisialisasi sebagai NULL.
Kemungkinan alokasi memori gagal maka fungsi allocate_node menghasilkan 0 dan kalau
berhasil akan menghasilkan 1. Untuk membebaskan node maka akan menggunakan ungsi
free_node().
Int_allocate_node(int data, list *new)
{
New = (list) malloc (sizeof(node));
If (new==NULL)
Return 0;
New- > datalist =data;
New- > next=null
Return 1;}
Untuk inisialisasi list setelah alokasi untuk node pertama akan ditambahkan statement
head=new;. Ilustrasi fungsi allocate node sebagai berikut :
New = (list) malloc (sizeof(node));
New- > datalist =data;

New- > next=null

Untuk inisialisasi list setelah alokasi node pertama ilustrasi adalah sebagai berikut :
Fungsi free_node() menggunakan memori dinamis dengan fungsi free(). Fungsi free() akan
menghancurkan node yang menunjuk ke pointer yang dilewati sehingga tempat yang ada
dipakai untuk lainnya. Akan tetapi pointer yang akan melewati free() tidak otomatis menjadi
null namun akan menunjuk ke node yang sudah tidak ada. Kaerna itu pointer harus
didefinisikan dengan NULL.
Void free_node(list p_L){
Free(p_L); p_L=NULL; }

Latihan :
Buatlah suatu menu yang berisi Keluar, Insert, Search dan Tampilkan. Semua harus
dimasukkan melalui keyboard. Gunakan single linked list untuk mengerjakannya. Berikut hasil
dari tampilan output :