POINTER & LINKED LIST

pointer
*Pointer (variabel penunjuk) adalah suatu variabel yang berisi alamat memori
dari suatu

variabel lain. Alamat ini merupakan lokasi dari obyek lain (biasanya variabel lain) di
dalam

memori. Contoh, jika sebuah variabel berisi alamat dari variabel lain, variabel pertama

dikatakan menunjuk ke variabel kedua

Operator Pointer ada dua, yaitu :

Operator &

Operator & bersifat unary (hanya memerlukan satu operand saja).

Operator & menghasilkan alamat dari operandnya.

Operator *

Operator * bersifat unary (hanya memerlukan satu operand saja).

Operator * menghasilkan nilai yang berada pada sebuah alamat.

LINKED LIST
Linked list adalah sekumpulan elemen bertipe sama, yang mempunyai keterurutan
tertentu, yang setiap elemennya terdiri dari dua bagian Linked list juga merupakan
suatu cara untuk menyimpan data dengan struktur sehingga dapat secara otomatis
menciptakan suatu tempat baru untuk menyimpan data yangdiperlukan. Struktur ini
lebih dinamis karena banyaknya elemen dengan mudah ditambah atau dikurangi,
berbeda dengan array yang ukurannya tetap. berikut gambaran kecil mengenai
linked list.

Dalam ilmu komputer, sebuah linked list adalah struktur data yang terdiri dari sekelompok
node yang bersama-sama mewakili berurutan. Berdasarkan bentuk yang paling sederhana,
setiap node terdiri data dan referensi (dengan kata lain, link) ke node berikutnya dalam
urutan; lebih varian kompleks menambahkan link tambahan. Struktur ini memungkinkan
untuk penyisipan efisien atau penghapusan elemen dari posisi apapun dalam urutan.

Sebuah linked list yang simpul berisi dua bidang: nilai integer dan link ke node berikutnya. Node terakhir ini
terkait dengan terminator digunakan untuk menandakan akhir dari daftar.

Daftar terkait adalah salah satu struktur data sederhana dan paling umum. Mereka dapat
digunakan untuk mengimplementasikan beberapa umum lainnya jenis abstrak Data, termasuk
daftar (tipe data abstrak), tumpukan, antrian, array asosiatif, dan S-ekspresi, meskipun tidak
jarang untuk mengimplementasikan struktur data lainnya secara langsung tanpa
menggunakan daftar sebagai dasar pelaksanaan.
Manfaat utama dari linked list lebih konvensional Array adalah bahwa unsur-unsur
daftar mudah dapat dimasukkan atau dihapus tanpa realokasi atau reorganisasi seluruh
struktur karena item data tidak perlu disimpan contiguously dalam memori atau pada disk,
sedangkan array harus dinyatakan dalam kode sumber, sebelum kompilasi dan menjalankan
program. Daftar terhubung memungkinkan penyisipan dan penghapusan node pada setiap
titik dalam daftar, dan dapat melakukannya dengan sejumlah konstan operasi jika link
sebelumnya untuk link yang ditambahkan atau dihapus dipertahankan selama daftar traversal.
Di sisi lain, terkait daftar sederhana sendiri tidak mengizinkan akses acak untuk data,
atau bentuk pengindeksan efisien. Dengan demikian, banyak operasi dasar - seperti
memperoleh node terakhir dari daftar (dengan asumsi bahwa node terakhir tidak
dipertahankan sebagai acuan simpul terpisah di struktur list), atau menemukan node yang
berisi datum tertentu, atau mencari tempat di mana simpul baru harus dimasukkan - mungkin
memerlukan pemindaian berurutan dari sebagian besar atau semua elemen daftar.
Keuntungan dan kerugian dari menggunakan daftar terkait diberikan di bawah ini.

Konsep dasar dan tata-nama

Setiap record dari linked list sering disebut 'elemen' atau 'simpul'.
Bidang masing-masing node yang berisi alamat dari node berikutnya biasanya disebut 'tautan
berikutnya' atau 'pointer berikutnya'. Bidang yang tersisa dikenal sebagai 'data', 'informasi',
'nilai', 'kargo', atau bidang 'payload'.
'Kepala' dari daftar adalah simpul pertama. The 'ekor' dari daftar mungkin merujuk baik ke
seluruh daftar setelah kepala, atau ke node terakhir dalam daftar. Dalam Lisp dan beberapa
bahasa berasal, node berikutnya dapat disebut 'cdr' (diucapkan bisa-er) dari daftar, sedangkan
muatan node kepala dapat disebut 'mobil'.

Tunggal linked list

Tunggal daftar terkait mengandung kelenjar yang memiliki bidang data serta lapangan
'berikutnya', yang menunjuk ke node berikutnya dalam garis node. Operasi yang dapat
dilakukan pada daftar tunggal terkait termasuk penyisipan, penghapusan dan traversal.

Sebuah daftar sendiri-sendiri terkait yang node berisi dua bidang: nilai integer dan link ke node berikutnya

Ganda terkait daftar

Artikel utama: Daftar Ganda terkait
Dalam 'daftar ganda terkait', setiap node berisi, selain tautan berikutnya-simpul, lapangan link
kedua menunjuk ke node 'sebelumnya dalam urutan. Dua link dapat disebut 'maju (' s ') dan'
mundur ', atau' berikutnya 'dan' prev '(' sebelumnya ').

Sebuah daftar ganda terkait yang node berisi tiga bidang: nilai integer, forward link ke node berikutnya, dan
link ke belakang ke node sebelumnya

Sebuah teknik yang dikenal sebagai XOR-linking memungkinkan daftar ganda terkait untuk
dilaksanakan menggunakan field link tunggal dalam setiap node. Namun, teknik ini
membutuhkan kemampuan untuk melakukan operasi bit pada alamat, dan karena itu mungkin
tidak tersedia dalam beberapa bahasa tingkat tinggi.
Banyak sistem operasi modern menggunakan daftar ganda terkait untuk mempertahankan

referensi untuk proses yang aktif, benang, dan benda-benda lain yang dinamis. [2] Sebuah
strategi umum untuk rootkit untuk menghindari deteksi adalah untuk memutus diri dari daftar
ini. [3]

Kalikan linked list

Dalam 'daftar multiply terkait', setiap node berisi dua atau lebih bidang Link, masing-masing
bidang yang digunakan untuk menghubungkan set yang sama rekaman data dalam urutan
yang berbeda (misalnya, dengan nama, oleh departemen, dengan tanggal lahir, dll) .
Sementara daftar ganda terkait dapat dilihat sebagai kasus khusus dari daftar multiply terkait,
fakta bahwa dua perintah yang berlawanan satu sama lain untuk mengarah algoritma
sederhana dan lebih efisien, sehingga mereka biasanya diperlakukan sebagai kasus terpisah.

elingkar Linked
Dalam terakhir simpul dari daftar, bidang hubungan sering berisi nol referensi, nilai khusus
yang digunakan untuk menunjukkan kurangnya node lebih lanjut. Sebuah konvensi kurang
umum adalah untuk membuatnya menunjuk ke node pertama dari daftar; dalam hal bahwa
daftar dikatakan 'lingkaran' atau 'sirkuler terkait'; selain itu dikatakan 'terbuka' atau 'linier'.

Sebuah linked list circular

Dalam kasus melingkar linked list ganda, satu-satunya perubahan yang terjadi adalah bahwa
akhir, atau "ekor", dari daftar kata terkait kembali ke depan, atau "kepala", dari daftar dan
sebaliknya.

Melingkar Linked
Dalam terakhir simpul dari daftar, bidang hubungan sering berisi nol referensi, nilai khusus
yang digunakan untuk menunjukkan kurangnya node lebih lanjut. Sebuah konvensi kurang
umum adalah untuk membuatnya menunjuk ke node pertama dari daftar; dalam hal bahwa
daftar dikatakan 'lingkaran' atau 'sirkuler terkait'; selain itu dikatakan 'terbuka' atau 'linier'.

Sebuah linked list circular

Dalam kasus melingkar linked list ganda, satu-satunya perubahan yang terjadi adalah bahwa
akhir, atau "ekor", dari daftar kata terkait kembali ke depan, atau "kepala", dari daftar dan
sebaliknya.

Operasi linked list

Ketika memanipulasi daftar terkait di tempat, perawatan harus diambil untuk tidak
menggunakan nilai-nilai yang telah valid dalam tugas sebelumnya. Hal ini membuat
algoritma untuk memasukkan atau menghapus linked list node agak halus. Bagian ini
memberikan pseudocode untuk menambahkan atau menghapus node dari daftar tunggal,
ganda, dan sirkuler terkait di tempat. Sepanjang kita akan menggunakan nol untuk merujuk
kepada penanda akhir-of-daftar atau sentinel, yang dapat diimplementasikan dalam beberapa
cara.
Daftar linear terkait
Daftar tunggal terkait

Struktur data simpul kami akan memiliki dua bidang. Kami juga menjaga firstNode variabel
yang selalu menunjuk ke node pertama dalam daftar, atau null untuk daftar kosong.
record Node
{
Data; // Data yang disimpan di node
Node berikutnya // A referensi ke node berikutnya, null untuk node
terakhir
}
Daftar catatan
{
Node firstNode // poin ke simpul pertama dari daftar; null untuk
daftar kosong
}

Traversal dari daftar tunggal linked sederhana, dimulai pada node pertama dan mengikuti
setiap tautan berikutnya sampai kita datang ke akhir:
simpul: = list.firstNode
sementara simpul tidak null
(melakukan sesuatu dengan node.data)
simpul: = node.next

Kode berikut menyisipkan simpul setelah simpul yang ada dalam daftar sendiri-sendiri
terkait. Diagram menunjukkan cara kerjanya. Memasukkan sebuah node sebelum yang sudah
ada tidak dapat dilakukan secara langsung; sebaliknya, seseorang harus melacak node
sebelumnya dan memasukkan sebuah node setelah.

Fungsi insertAfter (Node node, Node newNode) // masukkan newNode setelah

simpul
newNode.next: = node.next

node.next: = newNode

Memasukkan pada awal daftar membutuhkan fungsi yang terpisah. Ini membutuhkan
memperbarui firstNode.
Fungsi insertBeginning (Daftar daftar, Node newNode) // memasukkan simpul
sebelum saat pertama simpul
newNode.next: = list.firstNode
list.firstNode: = newNode

Demikian pula, kita memiliki fungsi untuk menghapus node setelah node yang diberikan, dan
untuk menghapus node dari awal daftar. Diagram menunjukkan bekas. Untuk menemukan
dan menghapus node tertentu, satu lagi harus melacak elemen sebelumnya.

Fungsi removeAfter (Node node) // menghapus simpul melewati satu ini

obsoleteNode: = node.next
node.next: = node.next.next
menghancurkan obsoleteNode
Fungsi removeAfter (Node node) // menghapus simpul melewati satu ini
obsoleteNode: = node.next
node.next: = node.next.next
menghancurkan obsoleteNode
Fungsi removeBeginning (Daftar daftar) // menghapus simpul pertama
obsoleteNode: = list.firstNode
list.firstNode: = list.firstNode.next // titik terakhir dihapus
simpul
menghancurkan obsoleteNode
Perhatikan bahwa removeBeginning() menetapkan list.firstNode ke null saat melepas

simpul terakhir dalam daftar.

Karena kita tidak bisa iterate mundur, efisien insertBefore atau removeBefore operasi
tidak mungkin.
Menambahkan satu daftar terkait lain dapat menjadi tidak efisien kecuali referensi ke ekor
disimpan sebagai bagian dari struktur Daftar, karena kami harus melintasi seluruh daftar
pertama untuk menemukan ekor, dan kemudian menambahkan daftar kedua ini. Jadi, jika dua
daftar linear terkait masing-masing dengan panjang , Daftar menambahkan memiliki
asymptotic kompleksitas waktu dari
. Dalam keluarga Lisp bahasa, daftar
menambahkan disediakan oleh append prosedur.
Banyak kasus khusus dari operasi linked list dapat dihilangkan dengan memasukkan elemen
boneka di depan daftar. Hal ini memastikan bahwa tidak ada kasus khusus untuk awal daftar

dan membuat kedua insertBeginning() dan removeBeginning() tidak perlu. Dalam hal
ini, data pertama yang berguna dalam daftar akan ditemukan di list. firstNode .next

operasi didalam LINKED LIST

Operasi-Operasi yang ada pada Linked List

Insert
Istilah Insert berarti menambahkan sebuah simpul baru
ke dalam suatu linked list.
IsEmpty
Fungsi ini menentukan apakah linked list kosong atau
tidak.
Find First
Fungsi ini mencari elemen pertama dari linked list
Find Next
Fungsi ini mencari elemen sesudah elemen yang
ditunjuk now
Retrieve
Fungsi ini mengambil elemen yang ditunjuk oleh now.
Elemen tersebut lalu dikembalikan oleh fungsi.
Update
Fungsi ini mengubah elemen yang ditunjuk oleh now
dengan isi dari sesuatu
Delete Now
Fungsi ini menghapus elemen yang ditunjuk oleh now.
Jika yang dihapus
adalah elemen pertama dari linked list (head), head akan
berpindah ke
elemen berikut.
Delete Head
Fungsi ini menghapus elemen yang ditunjuk head.
Head berpindah ke elemen sesudahnya.

Clear
Fungsi ini menghapus linked list yang sudah ada.
Fungsi ini wajib dilakukan
bila anda ingin mengakhiri program yang

menggunakan linked list. Jika anda

melakukannya, data-data yang dialokasikan ke memori
pada program
sebelumnya akan tetap tertinggal di dalam memori.

Jenis-jenis linked list

1. Linked List Circular
Double Linked List
Pengertian secara umumnya DLLC itu Linked list yang
menggunakan pointer, dimana setiap node memiliki 3 field, yaitu:
1 field pointer yang menunjuk pointer berikutnya "next",
1 field menunjuk pointer sebelumnya " prev ",
1 field yang berisi data untuk node tersebut .
Double Linked List Circular pointer next dan prev nya menunjuk
kedirinya sendiri secara circular. Bentuk Node DLLC

Single Linked List

Single Linked List Circular (SLLC) adalah Single Linked List yang
pointer nextnya menunjuk pada dirinya sendiri. Jika Single Linked List
tersebut terdiri dari beberapa node, maka pointer next pada node
terakhir akan menunjuk ke node terdepannya

2. Linked List Non Circular

Double Linked List Non Circular (DLLNC)
adalah Double Linked List yang memiliki 2 buah pointer yaitu
pointernext dan prev.
Pointer next menunjuk pada node setelahnya dan pointer prev menunjuk
pada node sebelumnya.
Pengertian:
Double : artinya field pointer-nya dua buah dan dua arah, ke
node sebelum dan sesudahnya.
Linked List : artinya node-node tersebut saling terhubung satu sama
lain.
Non Circular : artinya pointer prev dan next-nya akan menunjuk pada
NULL.

Single Linked List Non Circular (SLLNC)

Adalah Linked List yang pointer nya selalu mengarah ke Node
yang menampung *next bernilai NULL, jadi arahnya tidak menunjuk
pointer didepannya sehingga tidak dapat kembali ke pointer - pointer
sebelumnya. SLLNC ini juga memiliki 2 bagian, ada Tambah dan ada
Hapus, masing - masing bagian ini juga masih meliputi 3 fungsi lain yaitu
Belakang, Tengah, dan depan. untuk Contoh Tambah & Hapus

Untuk Menghapus(delete) data, menambah(insert) data , Edit

data pada C++ anda harus buat terlebih dahulu file kosong .txt
menggunakan notepad, untuk penempatan harus dalam satu folder,
ingat Dalam satu folder
#include
#include
typedef struct
{
char kode[12],
artis[20],
jenis_musik[40];
char judul_lagu[30];
}data_musik;
data_musik music, tmpmusic;
void
void
void
void
void

inputData();
bukaData();
editData();
cariData();
hapusData();

int main(int argc, char *argv[])

{ int menuPilihan;
while(menuPilihan !=0){
system("CLS");
do{
printf("\n");
printf("=========================================\n");
printf("|
Data Musik
|\n");
printf("=========================================\n");
printf("|
|\n");
printf("|
1. Masukan Data
|\n");
printf("|
2. Tampil Data
|\n");
printf("|
3. Search
|\n");
printf("|
4. Edit Data
|\n");

printf("|
5. Hapus Data
|\n");
printf("|
0. Exit
|\n");
printf("=========================================\n");
printf("Masukan Pilihan [0..5] : ");scanf("%d",&menuPilihan);
system("CLS");
}while(menuPilihan < 0 || menuPilihan > 5);
switch(menuPilihan){
case 1:inputData();break;
case 2:bukaData();break;
case 3:cariData();break;
case 4:editData();break;
case 5:hapusData();break;
}system("PAUSE");
}
return 0;
}
void inputData()
{
system("CLS");
FILE *pfiledata;
pfiledata=fopen("data.txt","ab");
char kode[12],artis[20],jenis_musik[100];
int i=5,ketemu=0;
printf("==========================================\n");
printf("|
Input Nama Artis
|\n");
printf("==========================================\n");
printf(" kode musik
: ");fflush(stdin);gets(music.kode);
printf(" Nama Artis
: ");fflush(stdin);gets(music.artis);
printf(" Jenis Musik
: ");fflush(stdin);gets(music.jenis_musik);
printf("Judul lagu
: ");fflush(stdin);gets(music.judul_lagu);
printf("==========================================\n");
fwrite(&music,sizeof(music),1,pfiledata);
fclose(pfiledata);
}
void cariData()
{
system("CLS");
FILE *pfiledata;
pfiledata=fopen("data.txt","rb");
char x[20];
int ketemu;
char jawab;
printf("==================================\n");
printf("|
Masukan Berdasarkan Nama
|\n");
printf("|
|\n");
printf("|
Masukan Nama Artis :\n");
printf("==================================\n");
fflush(stdin);gets(x);
system("CLS");
fread(&music,sizeof(music),1,pfiledata);
ketemu=0;
do{

if(strcmpi(music.artis,x)==0)
{
printf("|
Data Data Musik
|\n");
printf("===========================================\n");
printf("
kode
: %s
\n",music.kode);
printf("
Nama Artis
: %s
\n",x);
printf("
Jenis Musik
: %s
\n",music.jenis_musik);
printf("
Judul Lagu
: %s \n \n",music.judul_lagu);
printf("===========================================\n");
ketemu=1; }
fread(&music,sizeof(music),1,pfiledata);
}while(!feof(pfiledata));
if(!ketemu)
{
printf("DATA TIDAK DITEMUKAN\n\n");
}
fclose(pfiledata);
}
void editData()
{
system("CLS");
FILE *pfiledata, *pfiletemp;
pfiledata=fopen("data.txt","rb");
pfiletemp=fopen("datatemp.txt","wb");
char x[10];
int ketemu;
char jawab;
printf("=====================================================\n");
printf("|
|\n");
printf("|
Cari Data Berdasarkan kode Lapangan
|\n");
printf("|
Masukan kode
|\n");
printf("|
|\n");
printf("=====================================================\n");
fflush(stdin);gets(x);
system("CLS");
fread(&music,sizeof(music),1,pfiledata);
ketemu = 0;
jawab = 'Y';
do
{
if(strcmpi(music.kode,x)==0)
{
printf("===========================================\n");
printf("|
EDIT DATA Data Musik |\n");
printf("===========================================\n");
printf("
kode
: %s
\n",x);
printf("
Nama Artis
: %s
\n",music.artis);
printf("
Jenis Musik
: %s
\n",music.jenis_musik);
printf("
Judul Lagu
: %s
\n",music.judul_lagu);
printf("===========================================\n");
printf("|
APAKAH KAMU YAKIN ? [Y/T] :
|\n");
printf("===========================================\n");
scanf("%c",&jawab);

if(toupper(jawab)=='Y')
{
system("CLS");
printf(" kode
: ");fflush(stdin);gets(music.kode);
printf(" Nama Artis
: ");fflush(stdin);gets(music.artis);
printf(" Jenis Musik
: ");fflush(stdin);gets(music.jenis_musik);
printf(" Judul Lagu
: ");fflush(stdin);gets(music.judul_lagu);
fwrite(&music,sizeof(music),1,pfiletemp);
ketemu=1;
}
else
fwrite(&music,sizeof(music),1,pfiletemp);
}
else
{
fwrite(&music,sizeof(music),1,pfiletemp);
}
fread(&music,sizeof(music),1,pfiledata);
}while(!feof(pfiledata));
if(!ketemu)
{
printf("
}

DATA TIDAK 'DI UBAH' \n\n");

fclose(pfiletemp);
fclose(pfiledata);
remove("data.txt");
rename("datatemp.txt","data.txt");
}
void hapusData()
{
system("CLS");
FILE *pfiletemp, *pfiledata;
pfiledata=fopen("data.txt","rb");
pfiletemp=fopen("datatemp.txt","wb");
char x[10];
int ketemu;
char jawab;
printf(" ==============================================\n");
printf("
\n");
printf("
Hapus Data Berdasarkan kode Musik
\n");
printf("
Masukan kode Musik
\n");
printf("
\n");
printf(" ==============================================\n");
fflush(stdin);gets(x);
system("CLS");
fread(&music,sizeof(music),1,pfiledata);
ketemu = 0;
jawab = 'Y';
do
{
if(strcmpi(music.kode,x)==0)
{
printf("===========================================\n");

printf("
DATA Data Musik
\n");
printf("===========================================\n");
printf("
kode
: %-10s
\n",x);
printf("
Nama Artis
: %-10s
\n",music.artis);
printf("
Jenis Musik
: %-10s
\n",music.jenis_musik);
printf("
Judul Lagu
: %-10s
\n",music.judul_lagu);
printf("===========================================\n");
printf("DATA AKAN DI HAPUS, ARE YOU SURE ? [Y/T] :

");

scanf("%c",&jawab);
if(toupper(jawab)=='Y')
{
printf("DATA DIHAPUS\n");
ketemu=1;
}
else
fwrite(&music,sizeof(music),1,pfiletemp);
}
else
{
fwrite(&music,sizeof(music),1,pfiletemp);
}
fread(&music,sizeof(music),1,pfiledata);
}while(!feof(pfiledata));
if(!ketemu)
{
printf("DATA TIDAK 'DI HAPUS'\n\n");
}
fclose(pfiletemp);
fclose(pfiledata);
remove("data.txt");
rename("datatemp.txt","data.txt");
}
void bukaData()
{
system("CLS");
FILE *pfiledata;
pfiledata=fopen("data.txt","rb");
typedef struct
{char kode[12], artis[20], jenis_musik[40], judul_lagu[30];
}data_musik;
data_musik music;
int i=5,j=1;
printf("===========================================\n");
printf ("|
Data Musik
|\n");
printf ("===========================================\n");
rewind(pfiledata);
while(fread(&music,sizeof(music),1,pfiledata)){

printf("%i.",j);
printf(" kode
printf(" Nama Artis
printf(" Jenis Musik
printf(" Judul Lagu
i=i+5;
j++;
}
fclose(pfiledata);
}

: %s\n",music.kode);
: %s\n",music.artis);
: %s\n",music.jenis_musik);
: %s \n \n",music.judul_lagu);