Array

 ARRAY adalah adalah Tipe terstruktur yang terdiri dari sejumlah komponen-komponen yang mempunyai tipe yang sama. Sebelum digunakan, variabel array perlu dideklarasikan terlebih dahulu. Cara mendeklarasikan variabel array sama seperti deklarasi variabel yang lainnya, hanya saja diikuti oleh suatu indek yang menunjukan jumlah maksimum data yang disediakan.

Fungsi Array adalah menampung sejumlah data yang mempunyai tipe data yang sama dengan tipe data Array tersebut.

Array pada pemrogramman Java, dapat dibagi menjadi 2 bagian besar, yaitu Array Berdimensi Satu dan Array Multidimensi.

A. Array Berdimensi Satu

Bentuk pendekarasian Array Berdimensi Satu pada pemrograman Java, seperti dibawah ini:

tipe_data[] nama_var_array;
nama_var_array = new tipe_data[ukuran];




Contoh pendeklarasian :
int[] nilai;
nilai = new int[10];




a. Memasukan Nilai ke Array

Untuk memasukan nilai kedalam elemen array, dengan cara menyebutkan index untuk elemen array tersebut. Index dimulai dari index ke 0, bukan dari index ke 1.

nilai[0] = 70;
nilai[1] = 60;
nilai[2] = 80;




b. Mengambil Nilai dari Array

Untuk mengambil nilai dari dalam elemen array, dengan cara yang sama seperti memasukan kedalam elemen array, yaitu dengan menyebutkan index dari elemen array tersebut.

nilai[0];
nilai[1];
System.out.println("Nilai Elemen : " + nilai[0]);




Berikut contoh program array untuk menghitung total nilai dan nilai rata-rata elemen array.

01./* ----------------------------

02.Nama File : Array_D1_01.java

03.Author    : Frieyadie

04.------------------------------- */

05. 

06.import java.util.*;

07.class Array_D1_01

08.{

09.public static void main(String[] args)

10.{

11.int a, n, jml_nil=0;

12.double nil_rata=0;

13.int[] nilai;         // deklarasi variabel array

14.nilai = new int[10]; // membuat objek array

15. 

16.Scanner input = new Scanner(System.in);

17. 

18.System.out.print("Masukkan Banyak Data = ");

19.n = input.nextInt();

20. 

21.System.out.println("");

22. 

23.//Memasukan Data ke Elemen Array

24.for(a=0; a<n; a++)

25.{

26.System.out.print("Masukkan Array ke " + a + " = ");

27.nilai[a] = input.nextInt();

28.}

29. 

30.//Menampilkan Data ke Elemen Array

31. 

32.System.out.println("\n\nData Yang Diinput ke Elemen Array \n");

33. 

34.for(a=0; a<n; a++)

35.{

36.System.out.print("Nilai ke - " + a );

37.System.out.println(" = " + nilai[a]);

38.jml_nil = jml_nil + nilai[a];

39.}

40. 

41.nil_rata = jml_nil / n;

42. 

43.System.out.println("\n---------------------------------------");

44.System.out.println("Jumlah Array Nilai          = " + jml_nil);

45.System.out.println("Nilai Rata-Rata Array Nilai = " + nil_rata);

46.}

47.}

 

Rumus skrip untuk mengetahui jumlah data dari Array

(nama Array).length
(nama Array)= Nama dari suatu Array
.length= digunakan oleh Java untuk mengambil jumlah data dari Array, jumlah tersebut mempunyai tipe data Integer dan int
Silahkan pelajari skrip dibawah ini yang dicetak tebal
——————^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^——————

package pelajaranjava;
import java.io.*;
public class Main {

public static void main(String[] args) {

String[]hari={“Senin”, “Selasa”, “Rabu”, “Kamis”, “Jumat”,”Sabtu”,”Minggu”};

System.out.println(hari.length);
}

}

Heap

Heap Adalah struktur data yang berbentuk pohon yang memenuhi sifat-sifat heap yaitu jika B adalah anak dari A, maka nilai yang tersimpan di simpul A lebih besar atau sama dengan nilai yang tersimpan di simpul B.

 

Jenis-jenis heap:

Min Heap  : Nilai setiap node lebih kecil dari anak-anaknya

Contoh Min Heap:

Max Heap : Nilai setiap node lebih besar dari anak-anaknya

Operasi-operasi yang digunakan untuk heap adalah:

1. Delete-max atau delete-min: menghapus simpul akar dari sebuah max atau min heap.  
2. Increase-key atau decrease-key: mengubah nilai yang tersimpan di suatu simpul. 
3. Insert: menambahkan sebuah nilai ke dalam heap.  
4. Merge: menggabungkan dua heap untuk membentuk sebuah heap baru yang berisi semua elemen pembentuk heap tersebut. 

Implementasi pada array:

1. Unsur-unsur disimpan berurutan dari indeks 1 sampai N dari atas ke bawah dan dari kiri ke kanan node pohon.
2. Root disimpan dalam indeks 1 (kita membiarkan indeks 0 menjadi kosong / tidak terpakai).

Representasi array:

Memasukkan Min-Heap

• Masukkan unsur baru pada akhir heap• Naikkan heap baru/angka yang perlu dinaikkan
Penghapusan pada Min-Heap

• Perhatikan penghapusan elemen terkecil yang terletak pada akar.
• Ganti root dengan elemen terakhir dari heap• Penurunan jumlah elemen dalam tumpukan• Memperbaiki properti heap nya

Min-Max Heap

• Kondisi tumpukan bergantian antara tingkat minimum dan maksimum untuk tingkat• Tujuan min-max tumpukan adalah untuk memungkinkan kita untuk menemukan keduaelemen terkecil dan terbesar dari tumpukan pada waktu yang sama. 

Penghapusan pada Min-Max Heap

• Penghapusan elemen terkecil:
  - Ganti root dengan elemen terakhir dalam tumpukan.
  - Penurunan jumlah elemen dalam tumpukan.
  - Downheapmin dari root.

• Penghapusan elemen terbesar:
  - Ganti anak kiri atau kanan-anak dari akar (tergantung pada mana yang lebih besar) dengan elemen

     terakhir dalam tumpukan.
  - Penurunan jumlah elemen dalam tumpukan.
  - Downheapmax dari node.

Linked List

Link list adalah desain tempat penyimpanan data yang terdiri dari node-node (simpul-simpul) yang saling terhubung.

Link list dapat diilustrasikan seperti kereta api, dimana kereta api terdiri dari gerbong-gerbong yang saling terhubung yang dapat mengangkut penumpang. Gerbong disini setara dengan node dalam link list yang berfungsi untuk menyimpan data.

Jika kita menyimpan data 3, 5 dan 7 dalam array, maka ilustrasi tempat penyimpanannya sbb:

Dengan 1 nama, array bisa menyimpan data yg bertipe sama. Dimana setiap data mempunyai indeks.

Sedangkan jika data tersebut disimpan dalam link list, maka ilustrasi tempat penyimpanannya sbb:

Singly Linked List :

~ Setiap node pada linked list mempunyai field yang berisi pointer ke node berikutnya dan juga memiliki field yang berisi data.

~ Akhir linked list ditandai dengan node terakhir akan menunjuk ke null yang akan digunakan sebagai kondisi berhenti saat pembacaan linked list.

Singly Linked List Non Circular

Doubly Linked List :

~ Linked list dengan menggunakan pointer, dimana setiap node memiliki 3 field, yaitu: 1 field pointer yang menunjuk ke pointer berikutnya, 1 field pointer yang menunjuk ke pointer sebelumnya dan field yang berisi data dari node tersebut.

~ Pointer next dan prev-nya menunjuk ke null.

Doubly Linked List

 

Singly Circular Linked List :

~ Single Linked List yang pointer next-nya menunjuk ke dirinya sendiri, jika terdiri dari beberapa node maka pointer terakhirnya akan menunjuk ke pointer terdepannya.

Singly Circular Linked List

Double Circular Linked List :

~ Double Linked List yang pointer next dan prev-nya menunjuk ke dirinya sendiri secara circular.

Doubly Circular Linked List

Link list tidak mempunyai indeks seperti array. Kita hanya bisa memberi nama node. Akan tetapi, tidak semua node dalam link list mempunyai nama. Sebaiknya kita memberi nama untuk node yang pertama (misal namanya head), dan node yang terakhir (misal namanya tail). Tujuannya untuk memudahkan operasi link list dari depan atau belakang, misal nambah data atau menghapus data. 

Langkah yang pertama, kita harus mendefinisikan apa itu node. Dalam Java, sebaiknya pendefinisian node ini dibuat dalam sebuah class, misal:

 

Kemudian kita buat design link list dalam class yang lain, misal:

* untuk contoh program lengkap ada dalam file. download disini.

Operasi-operasi yang bisa dilakukan dalam link list yaitu:

1. Tambah data (insert)
2. Edit data (edit)
3. Hapus data (delete)
4. Pengurutan data (sorting)
5. Pencarian data (searching)

Tambah Depan

Untuk tambah data dari depan, caranya:

Tambah Belakang

Untuk tambah data dari belakang, caranya:

Hapus Depan

Untuk menghapus data dari depan, caranya:

Hapus Belakang

Untuk menghapus data dari belakang, caranya:

Queue

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).

Fungsi dalam Queue:

• Fungsi init : digunakan untuk membuat queue baru atau kosong, yaitu dengan memberi nilai awal (head) dan nilai akhir (tail) dengan -1.

• Fungsi full: digunakan untuk mengetahui apakah queue sudah penuh atau belum. Dilakukan dengan memeriksa nilai akhir (tail) apakah sudah sama dengan maksimal queue.

• Fungsi empty: digunakan untuk mengetahui apakah queue masih kosong atau tidak. Dilakukan dengan memeriksa nilai akhir (tail) bernilai -1 atau tidak.

• Fungsi enqueue : digunakan untuk menambahkan elemen ke dalam queue.

• Fungsi dequeue : digunakan untuk mengambil elemen dari queue, dengan cara memindahkan semua elemen satu langkah ke posisi depannya sehingga elemen yang paling depan tertimpa.

• Fungsi clear : digunakan untuk menghapus semua elemen dalam queue. Ada dua cara yang bisa digunakan, yaitu menuliskan fungsi seperti inisialisasi atau memanggil fungsi remove sampai queue kosong.

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 belakang queue, 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.

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.

Method isEmpty(), isFull(), and size()
untuk mengecek nItems, apakah kosong atau penuh.

Stack

Stack adalah salah satu struktur data yang memiliki sistem kerja Last In First Out (LIFO), yang terakhir masuk pertama keluar. Dapat di ilustrasikan seperti sebuah tumpukan buku, ketika mengambil sebuah buku di dalam tumpukan itu maka harus diambil satu persatu dari buku yang paling atas dari tumpukan buku tersebut.  Sebuah stack hanya dapat ditambahkan dan dikurangi elemennya hanya dari satu sisi yakni elemen atasnya atau biasa disebut Top Of Stack.

Fungsi dalam Stack:

• Fungsi init: fungsi yang digunakan untuk inisialisasi atau membuat stack baru yang masih kosong.
• Fungsi full: digunakan untuk mengetahui stack penuh atau tidak.
• Fungsi empty: digunakan untuk mengetahui stack kosong atau tidak.
• Fungsi clear: digunakan untuk mengosongkan stack. Stack dianggap kosong apabila puncak stack berada pada posisi -1.
• Fungsi push: digunakan untuk menambahkan data ke dalam stack. Penambahan data tidak bisa dilakukan apabila stack sudah penuh. Urutan perintahnya adalah: menambahkan nilai top dan menambahkan data pada posisi nilai top. Jika dalam Linked List menggunakan method addLast
• Fungsi pop: digunakan untuk mengeluarkan data teratas stack dengan syarat bahwa stack tidak kosong. Urutan perintahnya adalah : menghapus data pada posisi nilai top dan menurunkan nilai top. Jika dalam Linked List menggunakan method removeLast.
  Penggunaan STACK :
  * Perhitungan ekspresi aritmatika (posfix)
  * algoritma backtraking (runut balik)
  * algoritma rekursif
  
  (cites from http://id.wikipedia.org/wiki/Stack_%28struktur_data%29)

Ilustrasi :
Misalnya dalam stack ada data A,B,C,D secara berurutan mulai dari bawah (Ascending). >> Jika ingin mengeluarkan data A, maka proses yang dilakukan : POP D –>POP C –> POP B –> POP A
>> Jika ingin memasukkan data E dibawah B, maka proses yang dilakukan adalah : POP D –> POP C –> POP B –> PUSH E
COMMON ERROR :
1. Jika kondisi stack dalam keadaan sudah penuh kemudian di-PUSH, maka akan terjadi Blue Screen
2. Jika kondisi stack dalam keadaan kosong kemudian di-POP, maka akan terjadi looping tanpa henti.
CODE
Ada 2 class yang digunakan untuk program STACK dengan paradigma OOP ini. Yang pertama Main dan Stack
CODE MAIN.JAVA

import java.util.Scanner;

public class Main {
public static void main(String[] args) {
int pilihan;
int data;
Stack result = new Stack();

//looping until false condition
do{
//Displaying Menu
System.out.println(“1. PUSH Item”);
System.out.println(“2. POP Item”);
System.out.println(“3. Lihat Isi Data”);
System.out.println(“0. Keluar”);

Scanner input = new Scanner(System.in);
System.out.println(“Masukkan Pilihan :”);
pilihan = input.nextInt();

//condition for choice
if(pilihan==1){
System.out.println(“Data yang ditambahkan : “);
data = input.nextInt();
result.push(data);
}
else if(pilihan==2){
result.pop();
}
else if(pilihan==3){
result.Display();
}
else if(pilihan==0){
System.exit(0);
}
else{
System.out.println(“Pilihan Tidak Ada!!”);
}//end of condition

} while(pilihan!=0);//end looping

}
}

CODE STACK.java

class Stack {
private boolean empty,full;
private int pos;//menujukkan tempat kosong
private int max_data = 100;
private int item [] = new int[max_data];

public Stack(){
full = false;
empty = true;
pos = 0;
}//end of constructor

//method isFull
public boolean isFull(){
return(full);
}//end of isFull method

//method isEmpty
public boolean isEmpty(){
return(empty);
}//end of isEmptyl method

//method push
public void push(int data){
if(!isFull()){
item[pos++] = data;
empty = false;
if(pos == max_data) full = true;
System.out.println(“Data sudah ditambahkan”);
}
else{
System.out.println(“Stack sudah penuh”);
}
return;
}//end of push method

//method pop
public int pop(){
int x = 0;
if(!isEmpty()){
x = item[--pos];
full = false;

System.out.println(“Data yang di POP adalah :” + item[pos]);
System.out.println(“”);
item[pos]=0;

if(pos==0)empty = true;
else{
System.out.println(“Stack Kosong!”);
}
}else{
System.out.println(“Stack Masih Kosong!\n”);
}
return(x);
}//end of pop method

//method Display
public void Display(){
System.out.println(“Isi Stack Adalah : “);

//printing list item
for(int i=0; i<pos; i++){
System.out.print(item[i]+" ");
}

System.out.println("\n");
}//end of Display

}

IMPLEMENTASI PADA PROGRAM

Bagian progam. 

Tumpukan.java

public class Tumpukan {               public int ukuran;         public long [] tumpukan;         public int top;           public Tumpukan(int s){     ukuran = s;     tumpukan = new long [ukuran];     top = -1; } public void push(long j){     tumpukan[++top] = j; } public long pop(){     return tumpukan[top--]; } public long peek(){     return tumpukan[top]; } public boolean isEmpty(){     return (top == ukuran-1); } public boolean isFull(){     return(top == ukuran-1);       } public void baca(){     int i=top;     while (i>0){         System.out.print(tumpukan[i]);         System.out.print(" ");         i--;     }     System.out.println(" "); } }

Program Pemanggil: aplistack.java

public class aplistack{     public static void main (String [] args){         Tumpukan tumpukan=new Tumpukan(10);         tumpukan.push(56);         tumpukan.baca();         tumpukan.push(45);         tumpukan.baca();         tumpukan.push(67);         tumpukan.baca();         long nilai1=tumpukan.pop();         System.out.println("nilai1 = "+nilai1);         System.out.println(" ");         tumpukan.push(83);         tumpukan.baca();         tumpukan.push(27);          tumpukan.baca();         long nilai2 = tumpukan.pop();         System.out.print("nilai2 = "+nilai2);         System.out.println(" ");         long nilai3 = tumpukan.pop();         System.out.println("nilai3 = "+nilai3);         System.out.println(" ");         tumpukan.baca();                         } }