LABORATORIUM PEMBELAJARAN ILMU KOMPUTER

FAKULTAS ILMU KOMPUTER

UNIVERSITAS BRAWIJAYA
BAB
NAMA
NIM
TANGGAL
ASISTEN

: ADT ARRAY 1 DIMENSI

: LUTHFI FAWWAZ PUTRANTO
: 155150207111141
: 01/10/2016
: FIKRI ARROISI

A. DEFINISI MASALAH
1. Kembangkan program di atas dengan menambahkan method berikut :
a. Mencari posisi bilangan genap yang terletak diantara bilangan x1 dan
bilangan x2 dengan header sebagai berikut :
int findPosGenap(int x1, int x2)
b. Gunakan algoritma pengurutan yang lain BubleSort dan MergeSort
2. Pada Latihan kedua ini anda diminta untuk melengkapi bagian dari program
ADT_Larik sehingga jika diberikan program utama pada gambar 1 akan
menghasilkan keluaran sebagaimana gambar 2.
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
32
33

Program Latihan Praktikum 2.2

package ADT_Larik;
/**
*
* @author achmad ridok
*
*/
public class Larik{
//data (strukur data)
private int size;
private double []itemDt;
/**
* Contructor untuk membuat ADT larik dari suatu array
* @param A : array bertipe int
*/
public Larik(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 untu mendapatkan ukuran larik
* @return size dari larik
*/
public int getSize(){
return this.size;
}
/**

34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

* 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];
}
/**
* fungsi static untuk menyambung dua buah larik l1 dan
l2
* @param l1 : Larik
* @param l2 : Larik
* @return Larik
*/
public static Larik sambung(Larik l1, Larik l2){
// Lengkapi bagian ini
}
/**
* procedure untuk isiItem suatu larik
* @param id : indeks larik
* @param dt : 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 tebesar 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;
}
/**

88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

* 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 : posisi awal
* @param n : jumlah item yang akan dicopy
* @param l : larik asal
* @return Larik hasil copy
*/
public static Larik copyLarik(int k, int n, Larik l){
// lenkapi bagian ini
}
/**
* fungsi untuk mencari posisi terbesar suatu data
* suatu posisi awal sampai akhir
* @param awal : posisi awal
* @param akhir : posisi akhir
* @return posisi data terbesar
*/
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;
}

142
/**
143
* fungsi untuk mencari posisi data terkecil suatu array
144
* mulai dari posisi awal sampai posisi akhir
145
* @param awal : posisi awal
146
* @param akhir : posisi akhir
147
* @return posisi data terkecil
148
*/
149
public int getPosKecil(int awal, int akhir){
150
// lenkapi bagian ini
151
}
151
152
/**
153
* fungsi pengurutan suatu larik lAsal dimana kondisi
154 lAsal
155
* akan tetap setelah proses pengurutan
156
* @param lAsal : Array asal yang akan diurutkan
157
* @param status : 0-> urut dari kecil ke besar
158
*
1-> urut dari besar ke kecil
159
* @return Array baru hasil pengurutan
160
*/
161
public static Larik SelectionSort(Larik lAsal, int
162 status){
163
int n = lAsal.getSize();
164
Larik lhasil = Larik.copyLarik(0, n, lAsal);
165
if (status == 0){// urutkan data dari kecil ke
166 besar
167
for (int i=0; i<n; i++){
168
int posKecil = lhasil.getPosKecil(i,
169 n);
170
double itemKecil =
171 lhasil.getItem(posKecil);
172
double itemI = lhasil.getItem(i);
173
lhasil.isiItem(i, itemKecil);
174
lhasil.isiItem(posKecil, itemI);
public
class AppPr1 {
175
}
args)dari
{ besar ke kecil
176 public static} void
else main(String[]
{ // urutkan data
// implementasi
untuk
ADT_Larik
177
for (int i=0; i<n; i++){
double []A = {3,4,1,10,5,2,10,20,16};
178
int posBesar = lhasil.getPosBesar(i,
double []B = {4,3,1,11,7};
179 n);
Larik L1 = new Larik(A);
180
double itemBesar =
Larik L2 = new Larik(B);
181 lhasil.getItem(posBesar);
182
double itemI = lhasil.getItem(i);
L1.cetak("L1");
183
lhasil.isiItem(i, itemBesar);
L2.cetak("L2");
184
lhasil.isiItem(posBesar, itemI);
Larik L3 = Larik.sambung(L1,
L2);
185
}
L3.cetak("L3");
186
}
Larik L4
= Larik.copyLarik(0,
L1.getSize(), L1);
187
return
lhasil;
L1.cetak("L1");
188
}
L4.cetak("L4");
189 }
190
Larik
L5 = utama
Larik.SelectionSort(L1,0);
Gambar 1. Potongan
program
L5.cetak("L5");
Larik L6 =Larik.SelectionSort(L1, 1);
L6.cetak("L6");
L1.cetak("L1");
int []posisi = L1.FindPosPos(10);
double hasil = Larik.LarikKaliLarik(L1, L4);
System.out.printf("HASIL KALI %.3f\n",hasil);
}
}

Gambar 2. Hasil Keluaran

Isi Larik L1
3.00 4.00 1.00 10.00 5.00 2.00 10.00 20.00 16.00
Isi Larik L2
4.00 3.00 1.00 11.00 7.00
L3 = gabungan dari L1 dan L2
3.00 4.00 1.00 10.00 5.00 2.00 10.00 20.00 16.00 4.00 3.00
1.00 11.00 7.00
Isi Larik L1
3.00 4.00 1.00 10.00 5.00 2.00 10.00 20.00 16.00
L4 Copy dari L1
3.00 4.00 1.00 10.00 5.00 2.00 10.00 20.00 16.00
L5 Hasil pengurutan dari L1 kecil->besar
1.00 2.00 3.00 4.00 5.00 10.00 10.00 16.00 20.00
L6 Hasil pengurutan dari L1 besar->kecil
20.00 16.00 10.00 10.00 5.00 4.00 3.00 2.00 1.00
Isi Larik L1
3.00 4.00 1.00 10.00 5.00 2.00 10.00 20.00 16.00
HASIL KALI Larik L1*L4 = 911.000

B. SOURCE CODE
1

Larik.java(nomor 1)
public class Larik{

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

private int size;

private int []itemDt;
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;}
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){
53
54
55
56
57
58
59

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;

60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
10

else return pos;}

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 Larik SelectionSort(int pilihan){
Larik lsort = copyLarik(0,size);
for (int i=0; i<lsort.getSize();i++){
int posData;
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;}
public static void main (String[] args) {
int []A = {2,34,5,7,10};
Larik lA = new Larik(A);
Larik d= new Larik(A);
lA.cetak("Sebelum");
d.BubbleSort(0).cetak("Bubble Sort");
System.out.println(lA.findPosGenap(0, 1));
lA.SelectionSort(0).cetak("Sesudah di sort");
System.out.println();
int k = lA.PencarianBiner(7,0,5);
System.out.println(k);
int z[]= {1,3,10,5,2,4,6};
mergeSort(z);
for(int u:z){
System.out.println(u);}
Larik lB = lA.SelectionSort(0);
int p = lB.PencarianBiner(10,0,5);
System.out.println(p);}
int findPosGenap(int x1, int x2){
int b=0,a=0;
if(x1>=x2){

0
10
1
10
2
10
3
10
4
10
5
10
6
10
7
10
8
10
9
11
0
11
1
11
2
11
3
11
4
11
5
11
6
11
7
11
8
11
9
12
0
12
1
12
2
12
3
12
4
12

for(a=x2+1;a<x1;a++){
b=itemDt[a];
if(b%2==0)break;}}
else{
for(a=x1+1;a<x2;a++){
b=itemDt[a];
if(b%2==0)break;}
}return a;}
public Larik BubbleSort( int pilihan )
{
Larik BSort= copyLarik(0,size);
int j;
boolean flag = true;
int temp;
while ( flag )
{
flag= false;
if(pilihan==1){
for( j=0; j < size-1; j++ )
{
if ( BSort.itemDt[j] <BSort.itemDt[j+1] )
{ temp = BSort.itemDt[ j ];
BSort.itemDt[ j ] =
BSort.itemDt[ j+1 ];
BSort.itemDt[ j+1 ] = temp;
flag = true; } } }
else{
for( j=0; j < size-1; j++ ){
if ( BSort.itemDt[j] >BSort.itemDt[j+1] ){
temp = BSort.itemDt[ j ];
BSort.itemDt[ j ] =
BSort.itemDt[ j+1 ];
BSort.itemDt[ j+1 ] = temp;
flag = true;
} }}
}return BSort; }
public static void mergeSort(int[] inputArray) {
int size = inputArray.length;
if (size < 2)
return;
int mid = size / 2;
int leftSize = mid;
int rightSize = size - mid;
int[] left = new int[leftSize];
int[] right = new int[rightSize];
for (int i = 0; i < mid; i++) {
left[i] = inputArray[i];}
for (int i = mid; i < size; i++) {
right[i - mid] = inputArray[i];}
mergeSort(left);
mergeSort(right);
merge(left, right, inputArray);}
public static void merge(int[] left, int[] right, int[]
arr) {
int leftSize = left.length;

5
12
6
12
7
12
8
12
9
13
0
13
1
13
2
13
3
13
4
13
5
13
6
13
7
13
8
13
9
14
0
14
1
14
2
14
3
14
4
14
5
14
6
14
7
14
8
14
9

int rightSize = right.length;

int i = 0, j = 0, k = 0;
while (i < leftSize && j < rightSize) {
if (left[i] <= right[j]) {
arr[k] = left[i];
i++;
k++;
} else {
arr[k] = right[j];
k++;
j++; }}
while (i < leftSize) {
arr[k] = left[i];
k++;
i++;}
while (j < leftSize) {
arr[k] = right[j];
k++;
j++;} }}

15
0
15
1
15
2
15
3
15
4
15
5
15
6
15
7
15
8
15
9
16
0
16
1
16
2
16
3
16
4
16
5
16
6
16
7

1
2
3
4
5
6
7
8
9
10
11
12

Larik.java
public class Larik{
private int size;
private double []itemDt;
public Larik(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]; }}
public int getSize(){
return this.size;}
public double getItem(int i){
return this.itemDt[i];}

13
14
15
16
17
18
19
20
21
22
23
24
25
26

public static Larik sambung(Larik l1, Larik l2){

double[]a= new double[l1.size+l2.size];
int d=0;
for(int b=0;b<l1.size;b++){
a[d]=l1.itemDt[b];d++;}
for(int c=0; c<l2.size;c++){
a[d]=l2.itemDt[c];d++;}
Larik z = new Larik(a);
return z;}
public void isiItem(int id, double dt){
this.itemDt[id] = dt;}
public void cetak(String komentar){
if(komentar.equalsIgnoreCase("Larik L3"))
System.out.println("L3 = gabungan dari l1 dan
l2");

27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

else if(komentar.equalsIgnoreCase("L4"))
System.out.println("L4 Copy dari L1");
else if(komentar.equalsIgnoreCase("L5"))
System.out.println("L5 Hasil pengurutan dari L1
kecil -> besar");
else if(komentar.equalsIgnoreCase("L6"))
System.out.println("L6 Hasil pengurutan dari L1
besar -> kecil");
System.out.println("Isi Larik "+komentar);
for(int i=0; i<this.size; i++){
System.out.printf("%.2f ",this.itemDt[i]);}
System.out.println();}
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;}
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;}
public static Larik copyLarik(int k, int n, Larik l){
Larik a= null;
a=new Larik(l.itemDt);
while(k<=n-1){
a.isiItem(k, l.itemDt[k]);k++;}
return a;}
public int getPosBesar(int awal, int akhir){
int posBesar = -1;

61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
10
0
10
1
10
2
10
3

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;}
public int getPosKecil(int awal, int akhir){
int posKecil = -5;
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;}
public static Larik SelectionSort(Larik lAsal, int
status){
int n = lAsal.getSize();
Larik lhasil = Larik.copyLarik(0, n, lAsal);
if (status == 0){
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 {
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(Larik l1,Larik l2){
double a,b,c,total=0;
for(int d=0;d<l1.getSize();d++){
a=l1.itemDt[d];
b=l2.itemDt[d];
c=a*b;

10
4
10
5
10
6
10
7
10
8
10
9
11
0
11
1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

total+=c;
}return total; }}

AppPr1.java
public class AppPr1 {
public static void main(String[] args) {
double []A = {3,4,1,10,5,2,10,20,16};
double []B = {4,3,1,11,7};
Larik L1 = new Larik(A);
Larik L2 = new Larik(B);
L1.cetak("L1");
L2.cetak("L2");
Larik L3 = Larik.sambung(L1, L2);
L3.cetak("L3");
Larik L4 = Larik.copyLarik(0, L1.getSize(), L1);
L1.cetak("L1");
L4.cetak("L4");
Larik L5 = Larik.SelectionSort(L1,0);
L5.cetak("L5");
Larik L6 =Larik.SelectionSort(L1, 1);
L6.cetak("L6");
L1.cetak("L1");
double hasil = Larik.LarikKaliLarik(L1, L4);
System.out.printf("HASIL KALI Larik L1*L4 =
%.3f\n",hasil);}}

C. PEMBAHASAN
1

AppPr1.java
Deklarasi kelas dengan nama AppPr1

2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

Deklarasi main class

Deklarasi dan insialisasi variable array double A
Deklarasi dan inisialisasi variable array double B
Instansiasi L1 dengan parameter A
Instansiasi L2 dengan parameter B
Menjalankan method cetak melalui L1 dengan argumen L1
Menjalankan method cetak melalui L2 dengan argumen L2
Instansiasi L3 dengan nilai dari method sambung dengan argumen L1 dan L2
Menjalankan method cetak melalui L3 dengan argumen L3
Instansiasi L4 dengan menjalankan copyLarik dengan argumen 0,L1.getSize(),L1
Menjalankan method cetak melalui L1 dengan argumen L1
Menjalankan method cetak melalui L4 dengan argumenL4
Instansiasi L5 dengan menjalankan method SelectionSort dengan argumen L1,0
Menjalankan method cetak melalui L5 dengan argumen L5
Instansiasi L6 dengan menjalankan method SelectionSort dengan argumen L1,1
Menjalankan method cetak melalui L6 dengan argumen L6
Menjalankan method cetak melalui L1 dengan argumen L1
Deklarasi dan inisialasi variable double hasil dengan method LarikKaliLarik
dengan argumen L1 dan L4
Mencetak Hasil kali larik L1*L4 = dan mencetak nilai dari variable hasil

larik.java(nomor 1)
Deklarasi kelas larik
Deklarasi variable integer size
Deklarasi variable array integer itemDt
Deklarasi method void dengan nama buatLarik dengan parameter integer n
Memberikan nilai size dengan n
Memberikan panjang array pada itemDt dengan size
Deklarasi constructor dengan parameter integer n, kemudian menjalankan method
buatLarik dengan parameter n
Deklarasi method integer dengan nama getSize, kemudian mengembalikan nilai
size
Deklarasi method yang akan mengembalikan object larik dengan parameter array
integer dt
Menjalankan method buatLarik dengan argumen dt.length
Melakukan perulangan for i=0 i<dt.length;i++
Deklarasi method void isiItem dengan parameter int id, dan dt
Memberikan nilai pada itemDt[id] dengan dt
Deklarasi method void cetak dengan parameter string komentar
Mencetak komentar
Perulangan for dengan int i=0;i<size

17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

Mencetak itemDt[i]
Melakukan ganti baris
deklarasi method findBesar
deklarasi dan insialisai
deklarasi method variable besar dengan dt cari
kondisi besar<itemDt[i]
besar=itemDt[i]
mengembalikan variable besar
deklarasi getposisi dengan parameter dtCari
deklarasi variable pos =-99
deklarasi variable booolean ketemu=false
deklarasi variable int i=0
perulangan while dengan kondisi ketemu=false dan i lebih kecil dari size
kondisi dtCari= itemDt[i]
mengubah ketemu menjadi true
mengubah pos menjadi i
i diincrementkan
mengembalikan nilai pos
deklarasi method getPosMax dengan parameter int id
deklarasi max = itemDt[id]
deklarasi int posMax=id
looping for i=id+1;i<size;i diincrementkan
kondisi max<=itemDt[i]
max=itemDt[i]
posmax =i
mengembalikan nilai posMax
deklarasi method getPosMin dengan parameter int id
deklarasi min = itemDt[id]
deklarasi int posMin=id
looping for i=id+1;i<size;i diincrementkan
kondisi max>=itemDt[i]
min=itemDt[i]
posMin =i
mengembalikan nilai posMin
deklarasi method integer dengan nama PencarianBiner dengan parameter integer
dtCari,awal,akhir
deklarasi int pos =-99
deklarasi int tengah = (awal+akhir)/2
kondisi dtCari<itemDt[tengah]
mengembalikan dengan rekursif dengan argumen dtCari,awal,akhir
kondisi dtCari>itemDt[tengah]
mengembalikan dengan rekursif dengan argumen dtCari, tengah+1,akhir
kondisi dtCari=itemDt[tengah], mengembalikan tengah
mengembalikan pos
Deklarasi method larik copyLarik dengan parameter int k,n
Deklarasi larik lHasil=null

62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

Kondisi n<= size-k

Memberikan nilai lHasil dengan deklarasi larik dengan variable n
Deklarasi int j=0
Perulangan for int i=k;i<k+n, i diincrementkan
Menjalankan method isiItem melalui lHasil dengan argumen j++,itemDt[i]
Mengembalikan nilai Lhasil
Deklarasi Larik SelectionSort dengan parameter int pilihan
Deklarasi Larik lsort= method copyLarik denga argumen 0,size
Perulangan for int i=0 ; i <lsort.getSize(), i diincrementkan
Deklarasi variable int posData
Kondisi pilihan=0, posData akan menjadi lsort.getPosMin(i)
Kondisi lainnya, posData akan menjadi lsort.getPosMax(i)
Deklarasi int dt1=lsort.itemDt[i]
Deklarasi int dt2=lSort.itemDt[posData]
Mengubah lsort.itemDt[i] menjadi dt2
Mengubah lsort.itemDt[posData] menjadi dt1
Mengembalikan nilai lSort
Deklarasi main method
Deklarasi array int A={2,34,5,7,10}
Instansiasi Larik iA dengan argumen A
Instansiasi Larik d dengan argumen A
Menggunakan method cetak melalui iA dengan argumen sebelum
Menjalankan method BubbleSort(0), kemudian method cetak dengan argumen
BubbleSort melalui d
Mencetak method findPosGenap dengan argumen 0,3 melalui iA
Menjalankan method SelectionSort(0),kemudian cetak dengan argumen sesudah
di sort melalui iA
Melakukan ganti baris
Deklarasi int k= method PencarianBiner dengan argumen 7,0,5 melalui iA
Mecetak nilai k
Deklarasi array int Z={1,3,10,5,4,2,6}
Menjalankan method mergeSort dengan argumen (z)
Perulangan for untuk u sama dengan z
Mencetak u
Instansiasi Larik iB = method SelecetionSort(0) melalui iA
Deklarasi int p = method PencarianBiner(10,0,5) melalui iB
Mencetak nilai p
Deklarasi method int findPosGenap dengan parameter int x1,x2
Deklarasi int b=0,a=0
Kondis x1>=x2
Mengubah b menjadi itemDt[a]
Kondisi b%2=0 break;
Kondisi lainnya
Mengubah b menjadi itemDt[a]
Kondisi b%2=0 break;
Mengembalikan nilai a

106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

Deklarasi method Larik BubbleSort dengan parameter int pilihan

Deklarasi Larik Bsort= method copyLarik(0,size)
Deklarasi int j
Deklarasi boolean flag=true
Deklarasi int temp
Perulangan while flag=true
Mengubah flag menjadi false
Kondisi pilihan=1
Perulangan j=0,j<size-1; j diincrementkan
Kondisi Bsort.itemDt[j] < Bsort.itemDt[j+1]
Mengubah temp menjadi Bsort.itemDt[j]
Mengubah Bsort.itemDt[j]= Bsort.itemDt[j+1]
Mengubag Bsort.itemDt[j+1] menjadi temp
Mengubah flag menjadi true
Kondisi lainnya
Perulangan j=0,j<size-1; j diincrementkan
Kondisi Bsort.itemDt[j] > Bsort.itemDt[j+1]
Mengubah temp menjadi Bsort.itemDt[j]
Mengubah Bsort.itemDt[j]= Bsort.itemDt[j+1]
Mengubag Bsort.itemDt[j+1] menjadi temp
Mengubah flag menjadi true
Mengembalikan nilai Bsort
Mencetak method mergeSort dengan parameter int array=inputArray
Deklarasi int size=inputArray.length
Kondisi size<2
Return
Deklarasi mid= size/2
Deklarasi int leftsize=mid
Deklarasi int rightsize= size-mid
Deklarasi array int left dengan panjang leftsize
Delarasi array int right dengan panjang rightsize
Perulangan for int i=0;i<mid; i diincrementkan
Mengubah left[i] menjadi inputArray[i]
Menjalankan method mergeSort(left)
Menjalankan method mergeSort(right)
Menjalankan method merge(left,right,inputArray)
Deklarasi method merge dengan parameter int[] left,right,arr
Deklarasi leftSize=left.length
Deklarasi rightSize=right.length
Deklarasi int i=0,j=0,k=0
Perulangan i<leftsize&&J<rightSize
Kondisi left[i] <= right[j]
Mengubah arr[k] menjadi left[i]
I diincrementkan
K diincrement kan
Kondisi lainnya

157
158
159
150
161
162
163
164
165
166
167

Mengubah arr[k] menjadi right [j]

j diincrementkan
K diincrement kan
Perulangan i<leftSize
Mengubah arr[k] menjadi left[i]
I diincrementkan
K diincrement kan
Perulangan l<leftSize
Mengubah arr[k] menjadi right [j]
j diincrementkan
K diincrement kan

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
32
33

larik.java
Deklarasi kelas larik
Deklarasi variable integer size
Deklarasi variable array double itemDt
Deklarasi constructor dengan parameter double [] A
Mengubah size menjadi a.length
Mengubah itemDt menjadi panjang[size]
Looping for int i=0;i<size;i diincrementkan
Mengubah itemDt[i] menjadi A[i]
Deklarasi method int getSize
Mengembalikan nilai size
Deklarasi method getItem dengan parameter int i
Mengembalikan nilai itemDt[i]
Deklarasi method Larik sambung dengan parameter Larik l1,l2
Deklarasi double a[] dengan panjang l1.size+l2.size
Deklarasi int d=0
Looping for int b=0;b<l1.size;b++
Mengubah a[d]=l1.itemDt[b], d diincrementkan
Looping for int c=0;c<l2.size;c++
Mengubah a[d]=l2.itemDt[c], c diincrementkan
Instansiasi Larik z dengan parameter a
Mengembalikan nilai z
Deklarasi method isiItem dengan parameter int id, double dt
Mengubah itemDt[id] menjadi dt
Deklarasi method cetak dengan parmeter String komentqar
Kondisi komentar sama dengan L3
Mencetak "L3 = gabungan dari l1 dan l2")
Kondisi komentar sama dengan ("L4")
Mencetak "L4 Copy dari L1"
Kondisi komentar sama dengan "L5"
Menetak "L5 Hasil pengurutan dari L1 kecil -> besar"
Kondisi komentar sama dengan "L6"
Mencetak "L6 Hasil pengurutan dari L1 besar -> kecil"
Mencetak Isi Larik "+komentar

34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

Looping For int i=0; i<this.size; i++

Mencetak itemDt[i]
Ganti baris
Deklarasi method findBesar
Deklarasi double besar=itemDt[0]
Looping for int i;i<size;i++
Kondisi besar <itemDt[i]
Besar menjadi itemDt[i]
Mengembalikan besar
Deklarasi method getPosisi dengan parameter double dtCari
Deklarasi pos=-99
Deklarasi boolean ketemu=false
Deklarasi inti=0
Looping while ketemu=true&&i<size
Kondisi dtCari== itemDt[i]
Ketemu menjadi true
Pos menjadi i
I diincrementkan
Mengembalikan pos
Deklarasi method Larik copyLarik dengan parameter int n,k, Larik l
Deklarasi larik a=null
Instansiasi a dengan parameter l.itemDt
Kondisi k<=n-1
Menjalankan method isiItem dengan argumen k,l.itemDt[k] melalui a, kemudian k
diincrementkan
Mengembalikan a
Deklarasi method int getPosBesar dengan parameter int awal,akhir
Deklarasi int posBesar =-1
Deklarasi double itemBesar
Kondisi awal <= akhir
posBesar menjadi awal
itemBesar menjadi getItem(awal)
looping for int i=awal+1;i<akhir;i++
deklarasi double nilaiItem=getItem(i)
kondisi itemBesar< nilaiItem
itemBesar menjadi nilaiItem
posBesar menajdi i
mengembalikan nilai posBesar
Deklarasi method int getPosKecil dengan parameter int awal,akhir
Deklarasi int posKecil =-1
Deklarasi double itemKecil
Kondisi awal <= akhir
posKecil menjadi awal
itemKecil menjadi getItem(awal)
looping for int i=awal+1;i<akhir;i++
deklarasi double nilaiItem=getItem(i)

79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
104
105
106
107
108
109
110
111

kondisi itemKeicl> nilaiItem

itemKecil menjadi nilaiItem
posKecil menajdi i
mengembalikan nilai posKecil
deklarasi method Larik SelectionSort dengan Larik lAsal dan int status
deklarasi n=lAsal.getSize
deklarasi Larik lHasil= Larik.copyLarik(0,n,lAsal)
kondisi status==0
looping for int i=0;i<n;i++
deklarasi posKecil=lHasil.getPosKecil(i,n)
deklarasi double itemKecil=lHasil.getItem(posKecil)
deklarasi double itemI= lHasil.getItem(i)
Menjalankan method isiItem dengan argumen i,itemkecil melalui lHasil
Menjalankan method isiItem dengan argumen posKecil,itemI melalui lHasil
Kondisi lainnya
looping for int i=0;i<n;i++
deklarasi posBesar=lHasil.getPosBesar(i,n)
deklarasi double itemBesar=lHasil.getItem(posBesar)
deklarasi double itemI= lHasil.getItem(i)
Menjalankan method isiItem dengan argumen i,itemBesar melalui lHasil
Menjalankan method isiItem dengan argumen posBesar,itemI melalui lHasil
Deklarasi method double LarikKaliLarik dengan parameter Larik l1,l2
Deklarasi double a,b,c, total=0
Looping for int d=0;d<l1.getSize;d++
a menjadi l1.itemDt[d]
b menjadi l2.itemDt[d]
c menjadi a*b
nilai total ditambahkan dengan c
mengembalikan nilai total

D. SCREENSHOT PROGRAM
1.

2.

E. KESIMPULAN

ADT adalah merupakan model matematika dari objek data yang

menyempurnakan tipe data dengan cara mengaitkannya dengan fungsi yang
beroperasi pada data yang bersangkutan
Array adalah tipe data yang bisa menampung lebih dari satu nilai dengan jumlah
yang telah ditentukan , array dapat diakses dengan menggunakan
Nama_array[indeks]
Array 1 dimensi dapat diaplikasikan untuk membuat larik, atau jika suat data
memiliki banyak nilai dapat menggunakan array 1 dimensi