Algoritma dan
Struktur Data
ADT Array 1 Dimensi
Oleh
NIM : 115090607111036
Asisten : 1. Eka Mahargiyak
: 2. Ahmad Azeri
Program Teknologi
Informatika dan Ilmu Komputer
Universitas
Brawijaya
Malang
2012
BAB I
Pendahuluan
I.1 Dasar Teori
Deskripsi Array
Program mendefinisikan array sebagai barisan
lokasi memori berturutan. Definisi ini kurang tepat karena karena terjadi
keracuan antar tipe data abstrak (ADT) dan respresentasinya. Memang benar
array hampir selalu diimplementasikan menggunakan memori berurutan tapi
tidak selalu demikian. Semua elemen array adalah tilpe sama. Array
cocok untuk organisasi kumpulan data homogen.
Secara
intuitif, ADT array adalah kumpulan pasangan indeks dan nilai
(indekx/value
paris). Untuk array, maka terdapat dua operasi, yaitu :
1. Operasi
untuk mengambil (RETRIEVE) nilai
2. Operasi
untuk mrnyimpan (STORE) nilai
ADT Array
Sintaks
umum deklarasi array sebagai berikut :
Type
var-name [ ] ;
Atau
Type
[ ] var-name ;
Type
mendeklarasikan tipe basis array. Tipe basis menentukan tipe data elemen
pembentukan array. Tipe array menentukan tipe data yang dimuat array.
Berikut
adalah contoh deklarasi array di Java :
Int
numbers [ ] ;
Char
[ ] letters ;
Long
agrid [ ] [ ] ;
Pada
Java, kita tidak perlu menspesifikasi ukuran array saat deklarasi.
Ukuran
array ditentukan dengan dua cara :
1. Mendaftarkan
item-item array saat deklarasi, atau
2. Menyatakan ukuran
secara eksplisit saat menciptakan menggunakan operator new.
Keuntungan lain adalah menempatkan kurang siku
deklarasi array, sehingga dapat menempatkan kurung siklus setelah tipe
atau setelah indentifier. Berikut ini contoh deklari array dengan
memberikan daftar item dan menspesifikasi ukuran menggunakan operator new.
Int
primes = {2, 3, 5, 7, 11, 13} ;
Char
alphabet [ ] = new char [26]
Proses
untuk memperoleh array adalah dua langkah, yaitu :
1. Deklarasi
variabel dengan tipe yang dikehendaki
2. Alokasi
memori mengguankan operator new dan memberikan ke variabel.
Di Java, semua array dialokasikan secara dinamis jika konsep
alokasi dinamis ini tidak akrab bagi anda maka jangan khawatir karena
konsep array dinamis lebih mudah dan ampuh dalam memperlakukan
array. Setelah mengalokasikan array, kita dapat mengakses
elemen spesifik di array dengan menspesifikasikan indeks di kurung siku.
Di Java indeks array dimulai dengan nol.
Pemeriksaan
Batas
Java memeriksa batas array secara ketat sehingga menjamin
tidak ada usaha menyimpan atau mengacu nilai luar array. Sistem
run-time Java melakukan pemeriksaan untuk menjamin indeks berada di range
yang benar. Di java, array multidimensi adalah array dari array.
Pendekatan ini terlihat dan bertindak seperti array multidimensi biasa,
namun terdapat menspesifikasi masing-masing indeks tambahan menggunakan
himpunan kurung kurawal lain.
Kelebihan pengalokasian masing-masing dimensi secara
manual adalah tidak perlu mengalokasikan jumlah elemen yang
sama untuk masing-masing dimensi. Karena array multidimensi array
dari array maka panjang masing-masing array dapat dikendalikan.
Array 1 Dimensi
Array dimensi satu disebut juga dengan vector, adalah sebuah
array yang terdiri dari sejumlah elemen data, dan poisis setiap elemen
ditentukan oleh sebuah subskrib. Setiap array harus dideklarasikan terlebih
dahulu, hal ini digunakan untuk mengalokasikan ruang memori yang akan digunakan
dan juga menentukan tipe data dari elemen
Deklarasi Array satu dimensi
tipe_data nama_var_array[ukuran];
tipe_data : menyatakan jenis tipe data elemen larik (int,
char, float, dll)
nama_var_array
: menyatakan nama variabel yang dipakai.
ukuran
: menunjukkan jumlah maksimal elemen larik.
Array 1 dimensi sesungguhnya senarai variabel bertipe
serupa. Pertama buat lebih dulu varibel array dari tipe yang dikehendaki.
Int monthDays [ ] ; Tanda [] disebut juga “elemen yang ke- „.
Misalnya kondisi[0] berarti elemen yang ke nol. Array yang sudah dipesan,
misalnya 10 tempat tidak harus diisi semuanya, bisa saja hanya diisi 5 elemen saja,
baik secara berurutan maupun tidak. Namun pada kondisi yang tidak sepenuhnya
terisi tersebut, tempat pemesanan di memori tetap sebanyak 10 tempat, jadi
tempat yang tidak terisi tetap akan terpesan dan dibiarkan kosong.
Meski deklarasi telah menetapkan monthDays adalah variabel
array, namun sesungguhnya tidak ada array yang diciptakan. Nilai monthDays
dengan array bilangan bulat actual dan fisik, kita harus melakukan
alokasi menggunakan operator new ( ). Operator new ( ) meruapkan operator khusus
untuk mengalokasikan memori.
Bentuk
umum new untuk array 1 dimensi sebagai berikut :
Array-var
= new type [size]
Type menspesifikasi tipe data yang dialokasikan, size
menspesifikasi jumlah elemen, dan array-var adalah ama variabel. Untuk
menggunakan new, kita harus menspesifikasi tipe dan jumlah elemen.
Perhatiakn
contoh berikut :
Month_days
= new int [12]
Setelah
pernyataan dieksekusi, month_days akan emngacu ke array berisi
12
bilangan int. kedua belas angka tersebut dinisialisasi dengan nol.
Bentuk
umum new ( ) untuk array 1 dimensi sebagai berikut :
Array-var
= new ( ) type {size}
Disini, type menspesifikasi tipe data yang
dialokasikan, size menspesifikasi jumlah elemen array, dan array-var
adalah variabel array. Untuk menggunakan new ( ), pertama harus
menspesifikasi tipe dan jumlah elemen untuk dialokasikan.
Elemen-elemen di array yang dialokasikan dengan new ( ) akan secara
otomatis diinisialisasi ke nol.
Perhatikan
contoh berikut :
montDays
= new ( ) int [12] ;
Setelah pertanyaan diatas dieksekusi, monthDays akan mengacu
ke array berisi 12 bilangan int, kedua belas angka tersebut
diibisialisasi dengan nol.
Untuk memberikan nilai 29 ke elemen kedua dari
month_days, kita menggunakan perintah berikut :
Month_days
[1] = 29 ;
Berikut
ini adalah menampilkan nilai yang disimpan di indeks 3 yaitu elemen ke-4 :
System.
Out. printInt (month_days [3]).
BAB II
Pembahasan
II.1 Source Code
No
|
Larik.java
|
package Array1D;
public class Larik {
//data (struktur
data)
private int size;
private int [] itemDt;
private int n;
private int temp;
private int hasil;
//method
public void buatLarik(int n){
this.size = n ;
this.itemDt = new int[this.size];
}
public Larik(int n){
buatLarik(n);
}
public int getSize(){
return this.size;
}
public Larik(int[]dt){
buatLarik
(dt.length);
for (int i = 0;
i<dt.length;i++)
isiItem(i,dt[i]);
}
public void isiItem(int id, int dt){
this.itemDt[id]=dt;
}
public void cetak (String
komentar){
System.out.println(komentar);
for (int i=0; i<this.size;i++){
System.out.print(this.itemDt[i]+ " ");
}
System.out.println();
}
public int findBesar(){
int besar = this.itemDt[0];
for(int i = 1; i<this.size;i++){
if(besar<this.itemDt[i]){
besar=this.itemDt[i];
}
}
return besar;
}
/**
* program ini mencari posisi
suatu data tertentu di larik
*/
public int getPosisi(int dtCari){
int pos = -99;
boolean ketemu = false;
int i =0;
while(!ketemu
&& i<this.size){
if(dtCari == this.itemDt[i]){
ketemu
= true;
pos=i;
}
i++;
}
return pos;
}
private int getPosMax(int id){
int max = this.itemDt[id];
int posMax = id;
for (int i = id +1;
i<size; i++){
if(max<=this.itemDt[i]){
max=this.itemDt[i];
posMax=i;
}
}
return posMax;
}
private int getPosMin(int id){
int min = this.itemDt[id];
int posMin = id;
for (int i = id +1;
i<size; i++){
if(min>=this.itemDt[i]){
min=this.itemDt[i];
posMin=i;
}
}
return posMin;
}
public int
PencarianBiner(int dtCari, int awal, int akhir){
int pos=-99;
int tengah =
(awal+akhir)/2;
if(dtCari<this.itemDt[tengah])
return
PencarianBiner(dtCari, awal, tengah);
else if(dtCari>this.itemDt[tengah])
return
PencarianBiner(dtCari, tengah+1, akhir);
else if(dtCari==this.itemDt[tengah])
return tengah;
else return pos;
}
/**
* program untuk mengcopi suatu
larik
* mulai dari posisi k sebanyak
n item hasilnya
* dikeluarkan sebagai array baru
*/
public Larik
copyLarik(int k, int n){
Larik lHasil
= null;
if(n<=this.size-k){
lHasil
= new Larik(n);
int j = 0;
for(int i = k;
i<k+n; i++){
lHasil.isiItem(j++,
this.itemDt[i]);
}
}
return lHasil;
}
public void findPosGenap (int x1, int x2){
Larik lsort =
copyLarik(0, size);
int a=
lsort.getPosisi(x1);
int b=
lsort.getPosisi(x2);
int fpg = -1;
for (int i = a; i<
b;i++){
if (lsort.itemDt[i] % 2==0){
fpg
= i;
System.out.print(fpg +" ");
}
}
}
/**
* pilihan 0: diurutkan dari
kecil ke besar
* lain nya: urutkan dari
besar ke kecil
* Algoritma pengurutan
selection sort
*/
public Larik
SelectionSort(int pilihan){
Larik lsort=
copyLarik(0,size);
for (int i = 0;
i<lsort.getSize();i++){
int posData=0;
if(pilihan==0)
posData
= lsort.getPosMin(i);
else
posData
= lsort.getPosMax(i);
int dt1 = lsort.itemDt[i];
int dt2 = lsort.itemDt[posData];
lsort.itemDt[i]=dt2;
lsort.itemDt[posData]=dt1;
}
return lsort;
}
private static void BubleSort(int[] dtArray) {
int i,j,k,temp;
for(i=1; i <
dtArray.length - 1; i++){
System.out.println("Cara
Buble Sort ke - "+ i);
for(j=dtArray.length-1;j >=i;
j--){
if(dtArray[j-1] > dtArray[j]){
temp = dtArray[j];
dtArray[j] = dtArray[j-1];
dtArray[j-1] = temp;
}
for(k=0;k <
dtArray.length; k++){
System.out.print(dtArray[k]+"\t");
}
System.out.println();
}
}
}
public static void main (String[]
args){
int []A =
{2,34,5,7,10};
Larik lA = new Larik(A);
lA.cetak("Sebelum
di sorting : ");
System.out.println();
System.out.println("Sorting
bubble Sort ");
System.out.println();
BubleSort(A);
System.out.println();
System.out.println("Pos
genap [index]:");
lA.findPosGenap(2,
7);
}
|
No
|
Larik2.java
|
package Array1D;
public class Larik2 {
//data (struktur
data)
private int size;
private double []itemDt;
/**
* Contructor untuk membuat
ADT larik dari suatu array
* @param A : array bertype
int
*/
public Larik2(double []A){
this.size = A.length;
this.itemDt = new double[this.size];
for (int i=0; i<this.size; i++){
this.itemDt[i] = A[i];
}
}
/**
* fungsi untuk mendapatkan
ukuran larik
* @return size dari
larik
*/
public int getSize(){
return this.size;
}
/**
* fungsi untuk mendapatkan
item ke i dari suatu larik
* @param i : posisi
item
* @return item larik
*/
public double getItem(int i){
return this.itemDt[i];
}
/**
* Konstruktor Larik2
*/
public Larik2 (int y ) {
larikSize(y);
}
/**
* Membuat size larik
*/
public void larikSize (int y) {
this.size = y;
this.itemDt = new double [this.size];
}
/**
* fungsi static untuk menyambung
dua buah larik 11 dan 12
* @param l1 : Larik
* @param l2 : Larik
* @return Larik
*/
public static Larik2
sambung (Larik2 l1, Larik2 l2){
// Lengkapi
bagian ini
Larik2
Larik = new Larik2(l1.getSize()+l2.getSize());
int j = 0;
for (int i = 0;
i<Larik.getSize();i++){
if (i <
l1.getSize()){
Larik.isiItem(i,
l1.getItem(i));
}else{
while
(j<l2.getSize()){
Larik.isiItem(i,
l2.getItem(j));
i++;j++;
}
}
}
return Larik;
}
/**
* procedure untuk isiItem suatu
larik
* @param id : indeks
larik
* @param id : item
data yang akan disisipkan
*/
public void isiItem (int id, double dt){
this.itemDt[id] = dt;
}
/**
* procedure cetak suatu array
* @param komentar :
String
*/
public void cetak (String
komentar){
System.out.println(komentar);
for (int i=0; i<this.size; i++){
System.out.printf("%.2f
",this.itemDt[i]);
}
System.out.println();
}
/**
* fungsi untuk mendapatkan
nilai terbesar dari suatu larik
* @return : item terbesar
dari larik
*/
public double findBesar(){
double besar = this.itemDt[0];
for (int i=1; i<this.size; i++){
if (besar < this.itemDt[i]){
besar
= this.itemDt[i];
}
}
return besar;
}
/**
* fungsi untuk mencari posisi
suatu data tertentu di array
* @param dtCari:
data yang akan dicari
* @return posisiData
*/
public int getPosisi (double dtCari){
int pos = -99;
boolean ketemu = false;
int i =0;
while (!ketemu
&& i<this.size){
if (dtCari == this.itemDt[i]){
ketemu
= true;
pos
= i;
}
i++;
}
return pos;
}
/**
* fungsi static untuk mencopy
isi suatu larik l
* @param k : posis
awal
* @param n : jumlah
item yang akan dicopy
* @param l : larik
asal
* @return Larik
hasil copy
*/
public static Larik2
copyLarik(int k, int n, Larik2 l){
//lengkapi
bagian ini
Larik2 hasil = null;
if (n <=
l.getSize()-k){
hasil = new Larik2(n);
int j = 0;
for (int i=k;
i<k+n; i++){
hasil.isiItem(j++,
l.getItem(i));
}
}
return hasil;
}
/**
* fungsi untuk mencari posisi
terbesar duatu data
* suatu posisi awal
sampai akhir
* @param awal :
posisi awal
* @param akhir :
posisi akhir
* @return posisi data
tebesar
*/
public int getPosBesar(int awal, int akhir){
int posBesar =
-1;
double itemBesar;
if (awal <=
akhir){
posBesar
= awal;
itemBesar
= this.getItem(awal);
for (int i=awal+1;
i<akhir; i++){
double nilaiItem = this.getItem(i);
if (itemBesar
< nilaiItem){
itemBesar
= nilaiItem;
posBesar=i;
}
}
}
return posBesar;
}
/**'
* fungsi untuk mencari posisi data terkecil
suatu array
* mulai dari posisi awal sampai posisi akhir
* @param awal :
posisi awal
* @param akhir :
posisi akhir
* @return posisi data
terkecil
*/
public int getPosKecil(int awal, int akhir){
//lengkapi
bagian ini
int posKecil =
-1;
double itemKecil;
if (awal <=
akhir){
posKecil
= awal;
itemKecil
= this.getItem(awal);
for (int i=awal+1;
i<akhir; i++){
double nilaiItem = this.getItem(i);
if (itemKecil
> nilaiItem){
itemKecil
= nilaiItem;
posKecil=i;
}
}
}
return posKecil;
}
/**
* fungsi pengurutan suatu larik lAsaldimana
kondisi awal lAsal
* akan tetap setelah proses pengurutan
* @param lAsal :
Array asal yana akan diurutkan
* @param status : 0-> urut dari
kecil ke besar
* 1-> urut dari besar ke kecil
* @return Array baru
hasil pengurutan
*/
public static Larik2
SelectionSort (Larik2 lAsal, int status){
int n =
lAsal.getSize();
Larik2 lhasil =
Larik2.copyLarik(0, n, lAsal);
if (status == 0
) { //urutkan data dari kecil ke besar
for (int i=0; i<n;
i++){
int posKecil =
lhasil.getPosKecil(i, n);
double itemKecil =
lhasil.getItem(posKecil);
double itemI =
lhasil.getItem(i);
lhasil.isiItem(i,
itemKecil);
lhasil.isiItem(posKecil,
itemI);
}
} else {//urutkan
data dari besar ke kecil
for (int i=0; i<n;
i++){
int posBesar =
lhasil.getPosBesar(i, n);
double itemBesar =
lhasil.getItem(posBesar);
double itemI =
lhasil.getItem(i);
lhasil.isiItem(i,
itemBesar);
lhasil.isiItem(posBesar,
itemI);
}
}
return lhasil;
}
public static double LarikKaliLarik (Larik2 A, Larik2 B){
double hasil = 0;
if (A.getSize()
== B.getSize()){
for (int i = 0; i<A.getSize();i++){
hasil
+= A.getItem(i)*B.getItem(i);
}
}
return
hasil;
}
public static void main (String
[] args){
//implementasi
untuk ADT_Larik
double []A=
{3,4,1,10,5,2,10,20,16};
double []B=
{4,3,1,11,7};
Larik2 L1 = new Larik2 (A);
Larik2 L2 = new Larik2 (B);
L1.cetak("Isi
Larik L1");
L2.cetak("\nIsi
Larik L2");
Larik2 L3 =
Larik2.sambung (L1, L2);
L3.cetak("\nL3 =
gabungan dari L1 dan L2");
Larik2 L4 =
Larik2.copyLarik(0, L1.getSize(), L1);
L1.cetak("\nIsi
larik L1");
L4.cetak("\nL4
Copy dari L1");
Larik2 L5 =
Larik2.SelectionSort(L1, 0);
L5.cetak("\nL5
Hasil pengurutan dari kecil -> besar");
Larik2 L6 =
Larik2.SelectionSort(L1, -1);
L6.cetak("\nL6
Hasil pengurutan dari besar -> kecil");
L1.cetak("\nIsi
Larik L1");
double hasil =
Larik2.LarikKaliLarik(L1, L4);
System.out.printf("HASIL
KALI L1*L4 = %.3f\n", hasil);
}
}
|
II.2 Output
Larik.java
BAB III
Penutup
III.1 Kesimpulan
1.
Array dapat
digunakan untuk menyimpan banyak
data yang mempunyai tipe data sejenis.
2.
Data yang jenisnya
berbeda tidak dapat ditempatkan pada satu array yang sama.
3.
Umumnya indeks
array diawalidari indeks ke-0, sehingga jika ingin mengakses data ke-1 pada
array bisa kita aksesmenggunakan indeks data ke-0 pada array dan seterusnya
4.
Sebelum menggunakan
array, perlu membuatnya dan mendeklaraskannya terlebih dahulu.
5.
Array satu Dimensi mempunyai 1 nama tetapi memiliki banyak tempat dan setiap tempat harus
dibedakan, untuk membedakannya dibutuhkan penunjuk, pentunjuk dapat berupa
karakter(char) atau integer.
6.
Array yang sudah
disimpan dalam penunjuk yang sama(berbentuk indeks), maka isinya tidak akan
hilang kecuali indeksnya diisi oleh nilai yang lain.
III.2 Saran
1.
Mengajarkan materi secara bertahap hingga mahasiswa
mengerti.
2.
Menerangkan dan membahas tugas yang sudah di kumpulkan jika
masih ada yang belum dimengerti.
Daftar Pustaka
2.
http://allaboutalgoritma.blogspot.com/2010/02/array-1-dimensi-dalam-java.html
bagus sekali :)
BalasHapusiya, terima kasih :D
BalasHapus