Linked List

Linked List

Linked List

2.1 Definisi Linked List

Pengolahan data yang kita lakukan menggunakan komputer seringkali mirip

dengan ilustrasi di atas, yang antara lain berupa penyimpanan data dan pengolahan lain

dari sekelompok data yang telah terorganisir dalam sebuah urutan tertentu. Salah satu

cara untuk menyimpan sekumpulan data yang kita miliki adalah menggunakan larik.

Telah kita bicarakan dalam Bab 1, keuntungan dan kerugian pemakaian larik untuk

menyimpan sekelompok data yang banyaknya selalu berubah dan tidak diketahui dengan

pasti kapan penambahan atau penghapusan akan berakhir.

2.2 Single Linked List

Single linked list atau biasa disebut linked list terdiri dari elemen-elemen individu,

dimana masing-masing dihubungkan dengan pointer tunggal. Masing-masing elemen

terdiri dari dua bagian, yaitu sebuah data dan sebuah pointer yang disebut dengan pointer

next. Dengan menggunakan struktur two-member seperti ini, linked list dibentuk dengan

8

cara menunjuk pointer next suatu elemen ke elemen yang mengikutinya seperti gambar

2.1. Pointer next pada elemen terakhir merupakan NULL, yang menunjukkan akhir dari

suatu list. Elemen pada awal suatu list disebut head, dan elemen terakhir dari suatu list

disebut tail.

Gambar 2.1 Elemen yang Dihubungkan Bersama Dalam Bentuk Linked List

Untuk mengakses elemen dalam linked list, dimulai dari head dan menggunakan

pointer next dari elemen selanjutnya untuk berpindah dari elemen ke elemen berikutnya

sampai elemen yang diminta dicapai. Dengan single linke list, list dapat dilintasi hanya

satu arah dari head ke tail karena masing-masing elemen tidak terdapat link dengan

elemen sebelumnya. Sehingga, apabila kita mulai dari head dan berpindah ke beberapa

elemen dan berharap dapat mengakses elemen sebelumnya, kita harus mulai dari head.

Secara konseptual, linked list merupakan deretan elemen yang berdampingan.

Akan tetapi, karena elemen-elemen tersebut dialokasikan secara dinamis (menggunakan

malloc), sangat penting untuk diingat bahwa kenyataannya, linked list akan terpencarpencar

di memori seperti Gambar 2.2. Pointer dari elemen ke elemen berarti sebagai

penjamin bahwa semua elemen dapat diakses.

2.2.1 Representasi Simpul (Node)

Struktur node pada linked list merupakan suatu simpul(node) yang berisi pointer

ke suatu data yang merupakan data dirinya sendiri. Model struktur dari linked list tersebut

dalam C adalah sebagai berikut:

typedef struct node *list;

struct node {

int datalist;

struct node *next;

};

dilanjutkan dengan deklarasi dari pointer ke struktur di atas sebagai berikut:

struct node *head;

atau

list head;

2.2.2 Alokasi Simpul

Ketika sebuah variabel dideklarasikan, terlebih dahulu harus diinisialisasi.

Demikian juga dengan pengalokasian secara dinamis. Sehingga, fungsi untuk

mengalokasikan sebuah node baru, fungsi allocate_node() menggunakan malloc()

untuk mendapatkan memori aktual, yang akan menginisialisasi suatu field data. next

selalu diinisialisasi sebagai NULL.

Untuk melihat kemungkinan alokasi memori gagal, maka fungsi allocate_node

menghasilkan 0, bila berhasil maka menghasilkan 1. Untuk membebaskan node

digunakan fungsi free_node. Fungsi dari alokasi node adalah sebagai berikut :

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;

}

Operasi pada Linked List

Pada sub bab ini akan dijelaskan mengenai operasi yang terpenting pada linked

list, yaitu menambahkan node (insert) dan menghapus node (delete).

2.2.3.1 Insert

Fungsi insert pada linked list meliputi :

- 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

Statement kelanjutan dengan deklarasi seperti diatas untuk insert sebagai node

awal (head) dari linked list adalah sebagai berikut:

void insertashead(list insert)

{

insert->next=head;

head = insert;

}

ilustrasi dari fungsi diatas adalah sebagai berikut:

kondisi awal

insert->next=head;

head = insert;

Insert setelah node tertentu

Statement untuk insert setelah node tertentu dari linked list adalah sebagai berikut:

void insertafternode(int x, list insert)

{

list after;

after = head;

do

after = after->next;

while (after->datalist != x);

insert->next = after->next;

after->next = insert;

}

ilustrasi dari fungsi diatas adalah sebagai berikut:

after = head;

do

after = after->next;

while (after->datalist != x);

insert->next = after->next;

after->next = insert;

Langkah-langkah untuk proses di atas adalah sebagai berikut:

1. Pointer next dari elemen baru menunjuk elemen setelah elemen tertentu

2. Pointer next elemen sebelumnya menunjuk ke elemen baru

Insert sebelum node tertentu

Statement untuk insert setelah node tertentu dari linked list adalah sebagai berikut:

void insertbeforenode(int x, list insert)

{

list before, prevbefore;

if (head->datalist = x)

insertashead(insert)

else

{

before = head;

do

prevbefore = before;

before = before->next;

while (before->datalist != x);

insert->next = before;

prevbefore->next = insert;

}

}

ilustrasi dari fungsi diatas adalah sebagai berikut:

before = head;

do

prevbefore = before;

before = before->next;

while (before->datalist != x);

insert->next = before;

Langkah-langkah untuk proses di atas adalah sebagai berikut:

1. Telusuri list sampai elemen tertentu, catat juga elemen sebelumnya

2. Lakukan penyisipan sebelum elemen tertentu tersebut

Insert di akhir (tail) dari linked list

Statement untuk insert di akhir dari list adalah sebagai berikut:

void insertastail(list insert)

{

list tail;

tail = head;

do

tail = tail->next;

while (tail->next != NULL);

tail->next = insert;

tail = tail->next;

}

ilustrasi dari fungsi diatas adalah sebagai berikut:

tail = head;

Langkah-langkah untuk proses di atas adalah sebagai berikut:

1. Telusuri list sampai elemen terakhir (tail->next=NULL)

2. Lakukan pentisipan setelah elemen terakhir

2.2.3.2 Delete

Fungsi delete pada linked list meliputi :

- delete sebagai simpul pertama(head) dari linked list

- delete setelah simpul tertentu

- delete simpul terakhir

Penghapusan Simpul Pertama:

Langkah-langkah untuk proses di atas adalah sebagai berikut:

1. Pointer first diarahkan pada data ke-2

2. Pointer p diarahkan pada data ke-1

3. Bebaskan pointer p (secara otomatis data ke-1 terhapus)

Penghapusan Setelah Simpul Tertentu

Langkah-langkah untuk proses di atas adalah sebagai berikut:

1. Arahkan pointer first s/d data yang ditunjuk

2. Pointer p diarahkan pada first->next

3. Arahkan pointer first->next pada p->next

4. Bebaskan pointer p (secara otomatis data setelah simpul tertentu terhapus)

Penghapusan Simpul Terakhir

Langkah-langkah untuk proses di atas adalah sebagai berikut:

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

2.3 Double Linked List

Elemen-elemen dihubungkan dengan dua pointer dalam satu elemen. Struktur ini

menyebabkan list melintas baik ke depan maupun ke belakang.

Masing-masing elemen pada double linked list terdiri dari tiga bagian, disamping

data dan pointer next, masing-masing elemen dilengkapi dengan pointer prev yang

menunjuk ke elemen sebelumnya. Double linked list dibentuk dengan menyusun

sejumlah elemen sehingga pointer next menunjuk ke elemen yang mengikutinya dan

pointer prev menunjuk ke elemen yang mendahuluinya.

Untuk menunjukkan head dari double linked list, maka pointer prev dari elemen

pertama menunjuk NULL. Untuk menunjukkan tail dari double linked list tersebut, maka

pointer next dari elemen terakhir menunjuk NULL. Susunan elemen yang dihubungkan

dalam bentuk double linked list dapat dilihat pada Gambar 2.3

Double Linked List

Untuk melintas kembali melalui double linked list, kita gunakan pointer prev dari

elemen yang berurutan pada arah tail ke head. Double linked list mempunyai fleksibilitas

yang lebih tinggi daripada single linked list dalam perpindahan pada list. Bentuk ini

sangat berguna ketika akan meletakkan suatu elemen pada list dan dapat memilih

dengan lebih bijaksana bagaimana memindahkannya. Sebagai contoh, salah satu

fleksibilitas dari double linked list adalah dalam hal memindahkan elemen daripada

menggunakan single linked list.

2.4 Circular List

Circular list adalah bentuk lain dari linked list yang memberikan fleksibilitas dalam

melewatkan elemen. Circular list bisa berupa single linked list atau double linked list,

tetapi tidak mempunyai tail. Pada circular list, pointer next dari elemen terakhir menunjuk

ke elemen pertama dan bukan menunjuk NULL. Pada double linked circular list, pointer

prev dari elemen pertama menunjuk ke elemen terakhir.

Circular list yang akan dijelaskan pada bab ini merupakan single linked circular list. Kita

hanya menangani link dari elemen terakhir kembali ke elemen pertama.

2.5 Kesimpulan

1. Linked list adalah sebuah struktur untuk menyimpan data yang bersifat dinamik

2. Beberapa operasi dapat diterapkan pada linked list seperti sisip(insert),

hapus(delete)

3. Operasi-operasi yang ada pada linked list relatif lebih sulit jika dibandingkan

dengan operasi-operasi pada struktur yang statis

Recursion

Recursion

 secara singkat dapat diartikan sebagai sebuah fungsi yang memanggi fungsi itu atau dirinya sendiri.

source code
1 2 3 4 5 6 7 8 9 10 11	void myMethod( int counter) { if(counter == 0)      return; else     {        System.out.println(""+counter);        myMethod(--counter);        return;     } }

Fungsi diatas tentu tidak akan mengalami looping forever karena sudah memiliki kondisi kapan dia selesai yaitu ketika counternya = 0. Contohnya saja kita panggil fungsi diatas dengan nilai counter = 5. Lalu apa hasilnya??
Hasilnya adalah :

§  5

§  4

§  3

§  2

§  1

Kenapa nilai terakhir = 1? Ini karena fungsi diatas memiliki kondisi terakhir dimana jika nilai counter = 0, maka recursion akan berhenti . (Sudah pusing? saya saja sudah pusing karena sudah kebelet maen dota ) Jika sudah agak mengerti dengan contoh di atas selanjutnya kita bahas tentang contoh selanjutnya dari recursion yaitu tentang factorial.
Factorial adalah mengalikan suatu bilangan dengan bilangan sebelumnya sampai bilangan itu dikalikan dengan 1.
For example: 6! = 6 X 5 X 4 X 3 X 2 X 1 = 720 .  Lalu bagaiman kita mencari hasil factorial dengan konsep recursion ini? Coba perhatikan java code dibawah ini deh.

?

source code

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

class Factorial {      int fact(int n) {           int result;           if ( n ==1) return 1;           result = fact (n-1) * n;           return result;      } }    class Recursion {      public static void main (String args[]) {           Factorial f =new Factorial();           System.out.println("Factorial of 3 is "+ f.fact(3));           System.out.println("Factorial of 4 is " + f.fact(4));           System.out.println("Factorial of 5 is " + f.fact(5));

Queque

Queque

Queue (antrian) adalah struktur data dimana data yang pertama kali dimasukkan adalah data yang pertama kali bisa dihapus. Atau bisa juga disebut dengan struktur data yang menggunakan mekanisme FIFO (First In First Out).

Queue dalam kehidupan sehari-hari seperti antrian pada penjualan tiket kereta api, dimana orang yang pertama datang adalah orang yang pertama kali dilayani untuk membeli tiket. Jika ada orang baru yang datang akan membali tiket, maka posisinya berada pada urutan paling belakang dalam antrian tersebut. Orang yang berada pada posisi terakhir dalam antrian adalah yang terakhir kali dapat dilayani dan memperoleh tiket kereta api (kalau kurang beruntung, maka akan kehabisan tiket). Contoh lain adalah nasabah yang antri di teller bank, paket data yang menunggu untuk ditransmisikan lewat internet, antrian printer dimana terdapat antrian print job yang menunggu giliran untuk menggunakan printer, dsb.
Istilah-istilah yang digunakan dalam queue (antrian)Memasukkan data (insert) disebut juga dengan put, add, atau enqueue. Menghapus data (remove) biasa disebut dengan istilah delete, get, atau dequeue. Bagian belakangqueue, dimana data bisa dimasukkan disebut dengan back, tail (ekor), atau end (akhir). Sedangkan bagian depan (front) queue dimana data bisa dihapus juga biasa disebut dengan istilah kepala (head).
Circular Queue
Di dunia nyata apabila seseorang sedang mengantri (misalnya antri tiket kereta api), apabila telah dilayani dan memperoleh tiket, maka ia akan keluar dari antrian dan orang-orang yang berada di belakangnya akan bergerak maju ke dapan. Kita bisa saja menggerakkan setiap item data ke depan apabila kita menghapus data yang terdepan, tetapi hal ini kurang efektif. Sebaliknya kita tetap menjaga setiap item data di posisinya, yang kita lakukan hanyalah merubah posisi front dan rear saja.
Yang menjadi permasalahan adalah apabila posisi rear berada pada bagian akhir dari array (atau pada nomor indeks yang terbesar). Meskipun ada bagian yang kosong di awal-awal array – karena mungkin data telah dihapus, data baru tidak bisa dimasukkan lagi karenarear-nya sudah tidak bisa bergerak lagi. Atau mungkinkah posisi rear nya bisa berpindah? Situasi seperti itu bisa dilihat seperti gambar berikut:

Untuk menghindari permasalahan seperti itu (tidak bisa memasukkan data baru) – meskipun queue-nya belum penuh, maka front dan rear-nya berputar (kembali) ke bagian awal array. Kejadian seperti ini dinamakan dengan circular queue (atau kadang-kadang disebut juga dengan istilah ring buffer). Kejadian seperti ini seperti terlihat pada gambar berikut:

Perhatikan bahwa setelah rear berputar (kembali) ke bagian awal array, posisinya sekarang di bawah front, kebalikan dari posisi aslinya (front berada di bawah rear). Coba hapus beberapa data sehingga pada suatu saat front juga akan berputar (balik) ke bagian awal array, sehingga front dan rear akan ke susunan aslinya (front di bawah rear).
Queue.java
class Queue
{
private int maxSize;
private long[] queArray;
private int front;
private int rear;
private int nItems;
//————————————————————–
public Queue(int s)          // konstruktor
{
maxSize = s;
queArray = new long[maxSize];
front = 0;
rear = -1;
nItems = 0;
}
//————————————————————–
public void insert(long j)   // letakkan item (data) di posisi belakang dari queue
{
if(rear == maxSize-1)         //
rear = -1;
queArray[++rear] = j;         //naikkan rear dan masukkan item (data) pada posisi rear yang baru
nItems++;                     //tambah satu item lagi
}
//————————————————————–
public long remove()         // hapus item (data) yang berada pada posisi front
{
long temp = queArray[front++]; //dapatkan nilainya dan naikkan front
if(front == maxSize)           //
front = 0;
nItems–;                      // item (data) berkurang satu
return temp;
}
//————————————————————–
public long peekFront()      //
{
return queArray[front];
}
//————————————————————–
public boolean isEmpty()    //benar jika queue-nya kosong
{
return (nItems==0);
}
//————————————————————–
public boolean isFull()     // benar jika queue-nya penuh
{
return (nItems==maxSize);
}
//————————————————————–
public int size()           // jumlah ietm (data) dalam queue
{
return nItems;
}
//————————————————————–
}  // end class Queue
QueueApp.java
class QueueApp
{
public static void main(String[] args)
{
Queue theQueue = new Queue(5);  // queue menampung 5 item (data)
theQueue.insert(10);            // masukkan 4 item (data)
theQueue.insert(20);
theQueue.insert(30);
theQueue.insert(40);
theQueue.remove();              // hapus 3 item (data)
theQueue.remove();              //    (10, 20, 30)
theQueue.remove();
theQueue.insert(50);            // masukkan 4 item (data) lagi
theQueue.insert(60);            //    (wraps around)
theQueue.insert(70);
theQueue.insert(80);
while( !theQueue.isEmpty() )    // hapus dan tampilkan
{                            //    all items
long n = theQueue.remove();  // (
System.out.print(n);
System.out.print(“ “);
}
System.out.println(“”);
}  // end main()
}  // end class QueueApp
method insert()
Method insert() mengasumsikan bahwa queue tidak penuh (full). Kita tidak melihatnya dalam main(), tetapi kita bisa memanggil insert() hanya setelah memanggil isFull() dan memperoleh nilai kembalian yang salah. Pengisian data dengan cara menaikkan rear dan mengisikan data baru tersebut pada rear yang baru sekarang. Tetapi, jika rear berada di puncak array, pada maxSize-1, maka harus kembali ke posisi terbawah array sebelum penyisipan dilakukan. Caranya dengan memberi nilai rear=-1, sehingga jika terjadi kenaikan pada pada rear, maka rear akan menjadi 0, dasar dari array. Dan akhirnya,nItem bertambah.
Method remove()
method remove mengasumsikan queue-nya tidak kosong. Untuk meyakinkan bahwa queue-nya tidak kosong, anda harus memanggil method isEmpty(). Penghapusan selalu dimulai dengan memperoleh nilai pada front dan kemudian mengurangi front. Jika front-nya terletak pada akhir array, maka harus kembali ke 0. Kemudian nItems dikurangi.
Method peek()
untuk mendapatkan nilai pada front.

Introduction

Introduction

Struktur data adalah cara penyimpanan, penyusunan, dan pengaturan untuk pengolahan database di dalam media penyimpanan komputer sehingga data tersebut dapat digunakan secara tepat

Pengertian Struktur Data dan Tipe Data

Pengertian Struktur Data dan Tipe Data

Lecture: Leon Abdillah

1. Apa yang dimaksud dengan Struktur Data?

Struktur Data adalah cara penyimpanan, penyusunan dan pengaturan data di dalam media penyimpanan komputer sehingga data tersebut dapat digunakan secara efisien. struktur data berarti tata letak data yang berisi kolom-kolom data, baik itu kolom yang tampak oleh pengguna (user) atau pun kolom yang hanya digunakan untuk keperluan pemrograman yang tidak tampak oleh pengguna. Setiap baris dari kumpulan kolom-kolom tersebut dinamakan catatan (record). Lebar kolom untuk data dapat berubah dan bervariasi. Ada kolom yang lebarnya berubah secara dinamis sesuai masukan dari pengguna, dan juga ada kolom yang lebarnya tetap. Dengan sifatnya ini, sebuah struktur data dapat diterapkan untuk pengolahan database (misalnya untuk keperluan data keuangan) atau untuk pengolah kata (word processor) yang kolomnya berubah secara dinamis.

2. Sebutkan minimal 5 Tipe Data?

a. Integer ( Bilangan Bulat )
Integer merupakan nilai bilangan bulat baik dalam bentuk desimal maupun hexadecimal. Tipe data numerik yang termasuk integer adalah sebagai berikut :
- Byte : Memiliki nilai integer dari -128 sampai +127 dan menempati 1 byte ( 8 bits ) di memori
- Short : Memiliki nilai integer dari -32768 sampai 32767 dan menempati 2 bytes ( 16 bits ) di memori
- Int : Memiliki nilai integer dari -2147483648 sampai 2147483647 dan menempati 4 bytes ( 32 bits ) di memori
-Long : Memiliki nilai dari -9223372036854775808 sampai 9223372036854775807 dan menempati 8 bytes ( 64 bits ) di memori.

b. Char
Char adalah karakter tunggal yang didefinisikan dengan diawali dan diakhiri dengan tanda ‘ ( petik tunggal ).

c. String
Merupakan urutan-urutan dari karakter yang terletak di antara tanda petik tunggal. Nilai data string akan menempati memori sebesar banyaknya karakter string ditambah dengan 1 byte. Bila panjang dari suatu string di dalam deklarasi variabel tidak disebutkan, maka dianggap panjangnya adalah 255 karakter.

d. Real
Nilai konstanta numeric real berkisar dari 1E-38 sampai 1E+38. E menunjukkan nilai 10 pangkat, dan tipe data ini menempati memori sebesar6 byte.

e. Boolean
Tipe data boolean terdiri dari dua nilai saja, yaitu true dan false. Boolean sangat penting dalam mengevaluasi suatu kondisi, dan sering digunakan untuk menentukan alur program.

struktur data

Array pada struktur data
Lecture:Leon Abdillah
Array atau Larik merupakan Struktur Data Sederhana yang dapat didefinisikan sebagai pemesanan alokasi memory sementara pada komputer. Array dapat didefinisikan sebagai suatu himpunan hingga elemen yang terurut dan homogen.

• Terurut : Dapat diartikan bahwa elemen tersebut dapat diidentifikasi sebagai elemen pertama, elemen kedua dan seterusnya sampai elemen ke-n.
• Homogen : Adalah bahwa setiap elemen dari sebuah Array tertentu haruslah mempunyai type data yang sama.

Sebuah Array dapat mempunyai elemen yang seluruhnya berupa integer atau character atau String bahkan dapat pula terjadi suatu Array mempunyai elemen berupa Array. Karakteristik Array :

• Mempunyai batasan dari pemesanan alokasi memory. (Bersifat Statis).
• Mempunyai Type Data Sama (Bersifat Homogen)
• Dapat Diakses Secara Acak.

Terdapat 3 hal yang harus diketahui dalam mendeklarasikan array:

• Type data array
• Nama variabel array
• Subskrip / index array

Jenis Array yang akan dipelajari adalah :

• Array Dimensi Satu (One Dimensional Array)
• Array Dimensi Dua (Two Dimensional Array)
• Array Dimensi Tiga (Thee Dimensional Array)

Array Dimensi Satu 

Array dimensi sastu dapat disebut juga dengan istilah vektor yang menggambarkan data dalam suatu urutan. Array berdimensi satu berisi kumpulan dari nilai-nilai data bertipe sama dalam urutan tertentu yang menggunakan sebuah nama yang sama. Nilai-nilai data pada suatu array disebut dengan elemen array. Letak urutan dari suatu array ditunjukkan oleh suatu index (subscript). 

1	tipe_data nama_var_array [ukuran_index];

Keterangan :

• tipe_data : mendeklarasikan/menyatakan jenis tipe data untuk elemen array (int, char, float, dll)
• nama_var_array : mendeklarasikan/menyatakan nama variabel.
• ukuran_index : menunjukkan jumlah maksimal elemen array.

Contoh :

1	int nilai[6];

Inisialisasi array: 

Menginisialisasi array merupakan memberikan nilai awal kepada array pada saat didefinisikan. 

1	int nilai[6] = {50,85,65,42,75,95};

Pendeklarasian diatas bisa disederhanakan menjadi :

1	int nilai[] = {50,85,65,42,75,95};

Keterangan : 

Pada contoh diatas, kita melakukan pemesanan tempat di memori sebanyak 6 tempat dengan indeks dari 0-5, dan semua elemennya bertipe data integer. Untuk memberikan niai awal 0 terhadap seluruh elemen array pada saat didefinisikan, dengan menggunakan pendeklarasian seperti contoh dibawah: 

1	int temp[100] = {0};

Perintah diatas akan memberikan nilai nol dari subscript bernilai 0 hingga 99. 
 
Berikut contoh penggunaan array dimensi satu: 

01	#include <iostream.h>

02	#include <conio.h>

03	void main()

04

{

05	int nilai[6];

06

07	//memasukan data kearray

08	nilai[0] = 65;

09	nilai[1] = 82;

10	nilai[2] = 95;

11	nilai[3] = 83;

12	nilai[4] = 54;

13	nilai[5] = 75;

14

15	//mengakses elemen array

16

17	cout<<"\nElemen index ke 3 = "<<nilai[3];

18

getch();

19

}

Menggunakan inisialiasai dan pembacaan dengan menggunakan perulangan

01	#include<iostream.h>

02	#include<conio.h>

03

04	void main()

05

{

06	int dataarr[] = {2, 4, 6, 8, 10};

07	int n, r=0;

08	for (n=0; n<5; n++ )

09

{

10	cout<<"\nIndex "<<n<<" Elemen = "<<dataarr[n];

11	r += dataarr[n];

12

}

13	cout<<"\nTotal Elemen = "<<r;

14

getch();

15

}

Read more: http://www.frieyadie.com/12-Array%20pada%20Struktur%20Data.php#ixzz2ScaxnkyG