Arrays

Metode Penyimpanan
Penyimpanan struktur data dalam memori
computer dilakukan dengan 2 metode:
sequential allocation statis
linked allocation dinamis

Sequential allocation
Dengan sequential
allocation alamat sebuah
elemen akan dapat
ditentukan jika telah
diketahui nomor urut /
indeks yang menunjukkan
posisi elemen dan
kapasitas memori yang
digunakan untuk setiap
elemen

Ali

Adi

.
.
.
.
.
.
n-1

Ari

Avi

Sequential Allocation
Untuk menyimpan n sejumlah data harus
didefinisikan terlebih dahulu besarnya memori
/ jumlah tempat yang digunakan untuk
menyimpan data tersebut.
Sebaliknya, jika tempat yang disediakan
berlebih, maka terjadi pemborosan memori,
sehingga metode ini disebut Metode
Pengalamatan Statis.
Contoh paling sederhana dari sequential
allocation ini adalah ARRAY.

Array

Array 1-dimensi disebut Vektor

Array 2-dimensi disebut Matriks

Vektor (array 1-dimensi)

Biasanya digunakan untuk menyatakan suatu
daftar yang mempunyai urutan tertentu (tidak
boleh bolak-balik)
Diawali sebuah ordered-list, misal: Jan, Feb,
, Des.
Jika dilakukan alokasi memori (misal: 100
byte), maka alokasi memori yang dipesan
akan terletak secara berurutan & tidak
terpencar-pencar, mulai elemen pertama
hingga terakhir.

Vektor (2)
Untuk sebuah vektor n elemen,
yang tiap elemennya membutuhkan
c byte, maka total memori yang
dialokasikan sebesar c * n byte
dengan struktur alokasi vektor sbb:
Lo = alamat awal elemen pertama array A
c = ukuran satu elemen
L = Lo + c(i -1)
A[i] = lokasi elemen ke-I array A

A(1)

Lo

.
.
.
A(i)
.
.
.
A(n)
.

Contoh segmen program Pascal

1: CONST
2:
n = 100
3: VAR
4:
A : array [1..n] of integer

Misalkan elemen pertama (Lo) berada pada offset 1000,

c = 2 byte maka, pada offset ke berapakah elemen
ke-5 = A[5] ?
Jawab:
Lo = 1000
c = 2 byte
i=5
L = A[5] = 1000 + 2*(5-1)
= 1000 + 8 = 1008

Contoh segmen program Pascal (2)

Contoh 2 :
1: Var
2:
B : array [5..30] of integer

Lo = 1000
B[15] = ?
Jawab :
B[15] = 1000 + 2.(15-5) = 1000 + 20 = 1020

Matriks (Array 2-D)

Ada 2 cara penyimpanan di memori:

Row Major Order (RMO)

Column Major Order (CMO)

Row Major Order (RMO)

Row Major Order (RMO)
Data disimpan baris per baris sebagai sebuah vector
Contoh:
1: CONST
2:
n = 4 {jumlah baris}
3:
m = 3 {jumlah kolom}
4: VAR
5:
A: array [1..n,1..m] of integer
A(1,1)

A(1,2)
baris 1

A(1,3)

A(2,1)

A(2,2)

A(2,3)

baris 2

A(4,1)

A(4,2)

baris 4

A(4,3)

RMO
Rumus pencarian lokasi elemen A[i,j] secara
RMO
L = Lo + { (i-1) * m + (j-1) } * c
di mana 1 i n
1jn
i = indeks jumlah baris
j = indeks jumlah kolom
m = jumlah kolom
c = ukuran satu elemen
Lo = alamat elemen awal

RMO
Contoh: Lo = 1000, c =2 , n =4, m = 3
A[3,2] = ?
A[3,2] = 1000 + {(3-1)*3 + (2-1)} * 2
= 1000 + 7 * 2
= 1000 + 14
= 1014

RMO (2)
Secara umum: untuk matriks yang mempunyai
lower bound lk dan upperbound uk, maka:
L = Lo + {(i-l1) * (u2 l2 + 1) + (j l2)} * c
Array [1 .. 6 ; 2 .. 5]
l1 = 1; l2 = 2; u1 = 6; u2 = 5
B[3,2] = 1000 + {(3-1) * (5-2+1) + (2 2)} * 2
= 1000 + (2*4 + 0) * 2 = 1016

Column Major Order (CMO)

Column Major Order (CMO)
Prinsip penyimpanan mirip dengan RMO, hanya
saja data disimpan kolom per kolom sebagai
sebuah vector
Misal: matriks A dengan dimensi 4 baris & 3
kolom
A(1,1)

A(2,1)

A(3,1)

kolom 1

A(4,1)

A(1,2)

A(4,2)

kolom 2

A(1,3)

A(4,3)

kolom 3

CMO
Rumus CMO
L = Lo + {(i-1) + (j-1) * n} * c
1 i n, 1 j m
L = Lo + {(i-l1) + (j-l2) * (u1 l1 + 1)} * c
A[3,2] = 1000 + {(3-1) + (2-1) * 4} * 2
= 1000 + (2+4) * 2 = 1012
B[3,2] = 1000 + { (3-1) + (2-2) * (6-1+1)} * 2
= 1000 + (2 + 0 * 6) * 2
= 1004

ARRAY 3 DIMENSI
A [i,j,k]
1 i 2, 1 j 5, 1 k 4
Rumus
Secara umum 1 i n1, 1 j n2, 1 k n3
A[i,j,k] = Lo + {(i-1) * n2 * n3 + (j-1) * n3 + (k-1)} * c
Rumus untuk
Array [l1 .. u1, l2 .. u2, l3 .. u3] of type data

A[i,j,k] = Lo + {(i l1) * (u2 l2 + 1) * (u3 l3 + 1) +

(j l2) * (u3 l3 + 1) + (k l3)} * c

Record
RECORD, adalah type data kompleks yang
menyimpan berbagai macam data yang
tergabung menjadi satu kesatuan data.
Cara penyimpanan type data record pada
memori adalah dengan menyimpan masingmasing fieldnya secara berurutan di dalam
memori.
Jumlah memori yang diperlukan oleh type
data record sebesar total memori yang
dibutuhkan untuk masing-masing fieldnya.

Record (2)
Contoh:
1: var
2:
R: record
3:
Field1 : integer;
4:
Field2 : real;
5:
Field3 : string[10];
6:
end;

Jumlah memori yang dibutuhkan untuk mengalokasikan

variabel tersebut adalah :
2 byte (ukuran field1 = integer) +
6 byte (ukuran field2 = real) +
11 byte (ukuran field3 = string[10])
= 19 byte

ARRAY of RECORD
type data array of record, cara penyimpanan pada
memori sama seperti penyimpanan type data array,
hanya saja ukuran 1 elemen = ukuran 1 record
Contoh:
1:
2:
3:
4:
5:
6:
7:
8:

TYPE
Mhs = Record
Nama : String[20];
Alamat : String[40];
Umur : Byte;
END;
VAR
Data: ARRAY [1..10] of Mhs;

Array of Record (2)

Jika alamat awal elemen pertama array adalah 1000, di
mana kah lokasi field Alamat untuk elemen Data[4]
Langkah pengerjaan:
1.
2.
3.
4.
5.
6.

menentukan ukuran 1 record

ukuran 1 record = 21 + 41 + 1 = 63 byte
menentukan lokasi elemen Data[4]
lokasi Data[4] = 1000 + (4-1) * 63 = 1000 + 189 = 1189
menentukan lokasi alamat untuk elemen Data[4]
lokasi alamat untuk elemen Data[4] = 1189 + 21 = 1210

Contoh Soal
TYPE
tPegawai = RECORD
Nama : STRING[20];
Alamat : STRING[30];
Usia : Byte;
Gaji : Real;
Status : Char;
END
VAR
A : ARRAY [10..30,13..25] of tPegawai;

Cari alamat dari

A[15,15]
A[19,13]
A[20,21]

Secara RMO dan CMO dgn Alamat awal = 1000

Secara RMO
L = Lo + {(i-l1) * (u2 l2 + 1) + (j l2)} * c
A[15,15] = 1000 + {(15-10)*(25-13+1) + (15-13)} * 60
= 1000 + {5*13+2}*60
= 1000 + 67 * 60
= 1000 + 4020 = 5020
A[19,13] = 1000 + {(19-10)*(25-13+1) + (13-13)} * 60
= 1000 + (9*13) * 60
= 1000 + 7020 = 8020
A[20,21] = 1000 + {(20-10)*(25-13+1) + (21-13)} * 60
= 1000 + (10*13+8) *60
= 1000 + 138 * 60
= 1000 + 8280
= 9280

Secara CMO
L = Lo + {(i-l1) + (j-l2) * (u1 l1 + 1)} * c
A[15,15] = 1000 + {(15-10)+(15-13) * (30-10+1)} * 60
= 1000 + {5 + 2 * 21} * 60
= 1000 + (5+42) * 60 = 1000 + 2820 = 3820
A[19,13] = 1000 + {(19-10)+(13-13) * (30-10+1)} * 60
= 1000 + (9 + 0 * 21) * 60
= 1000 + 9 * 60 = 1540
A[20,21] = 1000 + {(20-10)+(21-13) * (30-10+1)} * 60
= 1000 + {10 + 8 * 21} *60
= 1000 + 10 + 168 *60
= 1000 + 10680
= 11680