Array dan Matriks
IF2121 / Algoritma dan Struktur Data
Sem. 1 2017/2018
Definisi
• Array adalah koleksi objek yang terdiri dari
sekumpulan elemen yang diorganisasi
secara kontigu, artinya memori yang
dialokasi antara satu elemen dengan
elemen yang lainnya mempunyai address
yang berurutan
• Array dengan satu jenis indeks disebut
array berdimensi satu, vektor, larik,
Array
IdxMin IdxMin+1 IdxMin+2 IdxMin+3 IdxMax-2 IdxMax-1 IdxMax
Array: container seluruh elemen
Elemen Array, dengan tipe homogen untuk setiap
elemen;
dapat diacu dari indeksnya
Indeks Array: dgn. tipe ordinal, menunjukkan address dari elemen
Pengertian-pengertian
• Keseluruhan array (sebagai koleksi) adalah
container yang menampung seluruh elemen,
yang secara konseptual dialokasi sekaligus.
• Indeks array: menunjukkan address dari sebuah
elemen.
• Elemen array: dapat diacu melalui indeksnya,
bertype tertentu yang sudah terdefinisi.
• Seluruh elemen array ber-type “sama”.
– Catatan: beberapa bahasa pemrograman
memungkinkan p}efinisian array dengan elemen
generik, tapi pada saat diinstansiasi, harus
Memory Array
• Array dikatakan “kosong” jika memori yang
dialokasi belum ada yang didefinisikan
elemennya
– Dalam bahasa pemrograman tertentu sudah
diisi dengan nilai default
• Array dikatakan “penuh” jika semua
memori yang dialokasi sudah diisi dengan
elemen yang terdefinisi.
Model Representasi Eksplisit (1/2)
• Definisi array mencakup definisi ruang
memori dan definisi kandungan elemen
yang “efektif”
• Definisi nilai efektif misalnya dalam
bentuk:
– banyaknya elemen yang “efektif”
Model Representasi Eksplisit (2/2)
Neff
Neff
Alokasi Array Statik dalam
Bahasa C
• Deklarasi array secara statik (alokasi di
memori lokal):
type_array nama_array [ukuran];
• Contoh: deklarasi variabel array bertype
int bernama TabInt dengan ukuran 100
Definisi Array of Integer
#include "boolean.h"
/* Kamus Umum */
#define NMax 100
/* ukuran maksimum array, indeks array: 0..99 */
#define IdxUndef -999
/* indeks tak terdefinisi */
/* Definisi koleksi objek */
typedef struct {
int TI[NMax+1]; /* memori tempat penyimpan elemen;
indeks yang digunakan [0..Nmax-1] */
int Neff; /* >=0, banyaknya elemen efektif */ } TabInt;
/* Deklarasi : T : TabInt */
/* Definisi : Tabel kosong: T.Neff = 0 */
Contoh: elemen integer; bisa diganti
Operasi-Operasi Array
• Create Empty
• IsEmpty, IsFull
• Traversal (contoh: mengisi array, mencetak isi
array)
• Searching (menghasilkan boolean, index)
• Sorting
• Menambah 1 elemen (add 1 element), menghapus
1 elemen (delete 1 element)
• Pencarian nilai ekstrem: minimum, maksimum
• Lain-lain
CreateEmpty, IsEmpty, IsFull
/* ********** KONSTRUKTOR ********** */ /* Konstruktor : create tabel kosong */
void CreateEmpty (TabInt * T);
/* I.S. T sembarang */
/* F.S. Terbentuk T kosong, yaitu T.Neff = 0 */
/* ********** TEST KOSONG/PENUH ********** */ /* *** Test tabel kosong *** */
boolean IsEmpty (TabInt T);
/* Mengirimkan true jika tabel T kosong, false jika tidak */
/* *** Test tabel penuh *** */
boolean IsFull (TabInt T);
/* Mengirimkan true jika tabel T penuh, false jika tidak */
CreateEmpty
/* ********** KONSTRUKTOR ********** */ /* Konstruktor : create tabel kosong */ void CreateEmpty (TabInt * T)
/* I.S. sembarang */
/* F.S. Terbentuk tabel T kosong dengan kapasitas NMax+1 */
{ /* ALGORITMA */ *T.Neff = 0;
IsEmpty, IsFull
boolean IsEmpty (TabInt T);
/* Mengirimkan true jika tabel T kosong, false jika tidak */
{ /* ALGORITMA */
return(T.Neff == 0); }
boolean IsFull (TabInt T);
/* Mengirimkan true jika tabel T kosong, false jika tidak */
{ /* ALGORITMA */
return(T.Neff == 0); }
Mengisi Array (1)
• Prosedur IsiTabel digunakan untuk mengisi sebuah
array of integer T. Mula-mula dibaca sebuah nilai N
(asumsikan
0 ≤ N ≤ NMax). Jika N > 0, maka baca N
buah nilai integer dari keyboard dan simpan dalam array
T secara kontigu dari elemen ke-0.
void IsiTabel (TabInt * T);
/* I.S.: T sembarang */
/* F.S.: T terisi N buah elemen secara kontigu */
/* Proses: Baca N (asumsi 0<=N<=NMax). Jika N > 0, baca N buah integer dari keyboard dan simpan di T secara kontigu */
Mengisi Array (2)
void IsiTabel (TabInt * T)
/* I.S.: T sembarang */
/* F.S.: T terisi N buah elemen secara kontigu */
/* Proses: Baca N (asumsi 0<=N<=NMax). Jika N > 0, baca N buah integer dari keyboard dan simpan di T secara kontigu */
{ /* KAMUS LOKAL */ int i; /* indeks */
int N; /* Ukuran elemen */
/* ALGORITMA */
scanf("%d",&N); /* Asumsi 0<=N<=NMax*/ *T.Neff = N;
/* Pengisian array dari pembacaan dari keyboard */
for (i = 0; i < *T.Neff; i++) { scanf("%d",&(*T.TI[i])); }
Mencetak Isi Array (1)
• Prosedur TulisTabel dipakai untuk mencetak isi
sebuah array of integer T. Jika T.Neff = 0,
tuliskan
“Array kosong”. Jika T.Neff>0, tuliskan
isi elemen array ke layar.
void TulisTabel (TabInt T);
/* I.S.: T terdefinisi, mungkin kosong */
/* F.S.: Jika T.Neff = 0, tercetak “Array kosong” */ /* Jika T.Neff > 0, isi elemen array tercetak ke
Mencetak Isi Array (2)
void TulisTabel (TabInt T)
/* I.S.: T terdefinisi, mungkin kosong */
/* F.S.: Jika T.Neff = 0, tercetak “Array kosong” */ /* Jika T.Neff > 0, isi elemen array tercetak ke
layar */ { /* KAMUS LOKAL */ int i; /* indeks */ /* ALGORITMA */ if (T.Neff == 0) { printf("Array kosong\n"); } else { /* T tidak kosong */
for (i = 0; i < T.Neff; i++) { printf("%d\n",T.TI[i]); }
Mencari Nilai X (1)
• Fungsi Search menerima input sebuah array of
integer T dan sebuah integer X dan
menghasilkan indeks di mana X ditemukan
pertama kali di T. Menghasilkan IdxUndef jika X
tidak ada di T.
int Search (TabInt T, int X);
/* Menghasilkan indeks di mana X ditemukan pertama kali di T. Jika X tidak ada di T maka dihasilkan IdxUndef */
Mencari Nilai X (2)
int Search (TabInt T, int X);
/* Menghasilkan indeks di mana X ditemukan pertama kali di T. Jika X tidak ada di T maka dihasilkan IdxUndef */
{ /* KAMUS LOKAL */ int i; /* indeks */ boolean found;
/* ALGORITMA */
i = 0; found = false;
while (i < T.Neff && !found) { if (T.TI[i] == X) { found = true; } else { i++; } } if (found) return i; else return IdxUndef;
Menghitung Nilai Maksimum (1)
• Fungsi Max menerima input sebuah array
of integer T dan menghasilkan nilai
elemen T yang paling besar (maksimum).
• Asumsi: T tidak kosong (T.Neff>0)
int Max (TabInt T);
/* Menghasilkan nilai terbesar dari elemen T.
Asumsi: T tidak kosong (T.Neff>0) */
Menghitung Nilai Maksimum (2)
int Max (TabInt T)
/* Menghasilkan nilai terbesar dari elemen T. Asumsi: T tidak kosong (T.Neff>0) */
{ /* KAMUS LOKAL */ int i; /* indeks */ int nmax; /* ALGORITMA */ nmax = T.TI[0]; i = 1; while (i < T.Neff) { if (T.TI[i] > nmax) { nmax = T.TI[i]; } i++; } return nmax;
Sorting – Bubble Sort (1)
• Prosedur BubbleSort menerima masukan
sebuah array of integer T (asumsi: T tidak
kosong) dan mengurutkan T secara terurut
membesar dengan menggunakan teknik
Bubble Sort
void BubbleSort (TabInt * T);
/* Mengurutkan T secara terurut membesar dengan menggunakan Teknik Bubble Sort */
/* I.S.: T terdefinisi, tidak kosong */ /* F.S.: T terurut membesar */
Sorting – Bubble Sort (2)
void BubbleSort (TabInt * T);
/* Mengurutkan T secara terurut membesar dengan menggunakan Teknik Bubble Sort */
/* I.S.: T terdefinisi, tidak kosong */ /* F.S.: T terurut membesar */
{ /* KAMUS LOKAL */
int pass, k; /* indeks */ int Temp;
/* ALGORITMA */
if (*T.Neff > 1) { /* Hanya sort jika T.Neff>1 */ for (pass = 0; pass < *T.Neff-1; pass++) {
for (k = *T.Neff; k > pass+1; k--) { if (*T.TI[k] < *T.TI[k-1]) { Temp = *T.TI[k]; *T.TI[k] = *T.TI[k-1]; *T.TI[k-1] = Temp; } } }
Tambah 1 Elemen (1)
• Prosedur Add1Elmt menerima masukan
sebuah array of integer T dan sebuah
integer X dan menambahkan X sebagai
elemen terakhir T (T diasumsikan bisa
kosong, tapi tidak penuh)
void Add1Elmt (TabInt * T, int X);
/* Menambahkan X sebagai elemen terakhir dari T */ /* I.S.: T terdefinisi, mungkin kosong, tapi tidak penuh. X terdefinisi. */
Tambah 1 Elemen (2)
void Add1Elmt (TabInt * T, int X);
/* Menambahkan X sebagai elemen terakhir dari T */ /* I.S.: T terdefinisi, mungkin kosong, tapi tidak penuh. X terdefinisi. */
/* F.S.: X ditambahkan sebagai elemen terakhir T */
{ /* KAMUS LOKAL */
/* ALGORITMA */
*T.TI[*T.Neff] = X; *T.Neff++;
Hapus Elemen Terakhir (1)
• Prosedur DelLastElmt menerima masukan
sebuah array of integer T (diasumsikan tidak
kosong) dan menghapus elemen terakhir T dan
menyimpannya di X. T mungkin menjadi kosong
void DelLastElmt (TabInt * T, int * X);
/* Menghapus elemen terakhir T dan menyimpannya di X */ /* I.S.: T terdefinisi, tidak kosong. X sembarang. */ /* F.S.: X berisi elemen terakhir T. Elemen T berkurang
Hapus Elemen Terakhir (2)
void DelLastElmt (TabInt * T, int * X);
/* Menghapus elemen terakhir T dan menyimpannya di X */ /* I.S.: T terdefinisi, tidak kosong. X sembarang. */ /* F.S.: X berisi elemen terakhir T. Elemen T berkurang
satu elemen, mungkin menjadi kosong. */
{ /* KAMUS LOKAL */
/* ALGORITMA */
*X = *T.TI[*T.Neff-1]; *T.Neff--;
Latihan 1
• Buatlah prosedur TulisPositif yang menerima
masukan sebuah array of integer T dan
menuliskan ke layar semua elemen T yang
bernilai positif (>0). Jika T kosong atau jika tidak
ada elemen T yang posifit, tidak menuliskan apa
pun.
void TulisPositif (TabInt T);
/* Menuliskan elemen T yang positif ke layar */ /* I.S.: T terdefinisi, mungkin kosong. */
/* F.S.: Elemen T yang positif tercetak di layar. Jika T kosong atau tidak ada elemen positif, tidak ada yang
Latihan 2
• Tuliskan fungsi CountX yang menerima
masukan sebuah array of integer T dan sebuah
nilai integer X dan menghasilkan berapa banyak
elemen T yang bernilai X. Jika T kosong atau
jika tidak ada elemen T yang bernilai X, maka
mengembalikan 0.
int CountX (TabInt T, int X);
/* Menghasilkan banyaknya elemen T yang bernilai X.
Jika T kosong atau tidak ada elemen T yang bernilai X, maka menghasilkan 0. */
Latihan 3
• Tuliskan ulang prosedur sorting terurut
membesar dengan menggunakan teknik
insertion sort.
void InsertionSort (TabInt * T);
/* Mengurutkan T secara terurut membesar dengan menggunakan Teknik Insertion Sort */
/* I.S.: T terdefinisi, tidak kosong */ /* F.S.: T terurut membesar */
Matriks (1)
• Sekumpulan informasi yang setiap individu
elemennya terdefinisi berdasarkan dua buah
indeks (yang biasanya dikonotasikan dengan
baris dan kolom)
• Setiap elemen matriks dapat diakses secara
langsung jika kedua indeks diketahui
• Indeksnya harus bertype yang mempunyai
keterurutan (suksesor/predesesor), misalnya
integer.
Matriks (2)
• Matriks adalah struktur data statik (ukurannya
ditentukan dari awal) dan kontigu
• Untuk keperluan ini, sering kali memori dipesan
“berlebihan” untuk kemudian dipakai sebagian
saja
Implementasi Matriks di C:
Array 2 Dimensi
/* Deklarasi Array of Array */
type-array nm_array [nmax1][nmax2];
/* Cara mengacu elemen */
nm_array[idx1][idx2]
/* Contoh: */
int Tab2D[3][4];
Tab2D[i][j] = 9; X = Tab2D[2][3];
Definisi Type Matriks
/* Definisi TYPE MATRIKS dengan indeks integer */ /* Ukuran maksimum baris dan kolom */#define BrsMax 10 #define KolMax 10
typedef struct {
int Mem[BrsMax][KolMax]; /* memori matriks */
int NBrsEff; /* banyaknya/ukuran baris yg terdefinisi */ int NKolEff; /* banyaknya/ukuran kolom yg terdefinisi */ } Matriks;
/* Indeks matriks yang digunakan: [0..BrsMax-1][0..KolMax-1] */
/* Memori matriks yang dipakai selalu di "ujung kiri atas" */ Contoh: elemen
integer; bisa diganti type lain
Operasi-Operasi Matriks
• Baca Matriks
• Tulis Matriks
• Tambah/Kurang 2 Matriks
• Perkalian 2 Matriks
• Transpose
• Dll.
Baca Matriks (1)
• Prosedur BacaMatriks membentuk sebuah
matriks M dengan ukuran nxm (dibaca dari
masukan pengguna, asumsi 0<n<=BrsMax;
0<m<=KolMax) dan mengisi matriks M dengan
elemen dari pengguna
void BacaMatriks (Matriks * M);
/* Membentuk matriks M ukuran nxm yang dibaca dari masukan pengguna */
/* I.S.: M sembarang */
/* F.S.: M terdefinisi dengan ukuran nxm berdasarkan masukan pengguna */
Baca Matriks (2)
void BacaMatriks (Matriks * M);
/* Membentuk matriks M ukuran nxm yang dibaca dari masukan pengguna */
/* I.S.: M sembarang */
/* F.S.: M terdefinisi berukuran nxm berdasarkan masukan pengguna */
{ /* KAMUS LOKAL */
int i, j; /* indeks matriks */
int n, m; /* ukuran baris dan kolom */
/* ALGORITMA */
scanf("%d",&n); /* ukuran baris, asumsi: 0<n<=BrsMax */ scanf("%d",&m); /* ukuran kolom, asumsi: 0<m<=KolMax */ *M.NBrsEff = n;
*M.NKolEff = m;
/* mengisi matriks */
for (i = 0; i < *M.NBrsEff; i++) {
for (j = 0; j < *M.NKolEff; j++) { scanf("%d",&(*M.mem[i][j]));
Tulis Matriks (1)
• Prosedur TulisMatriks menerima masukan
sebuah Matriks M dan menuliskan ke layar isi
matriks tersebut
void TulisMatriks (Matriks M);
/* Menuliskan isi matriks M ke layar */ /* I.S.: M terdefinisi */
Tulis Matriks (2)
void TulisMatriks (Matriks M);
/* Menuliskan isi matriks M ke layar */ /* I.S.: M terdefinisi */
/* F.S.: Isi M tercetak ke layar */
{ /* KAMUS LOKAL */
int i, j; /* indeks matriks */
/* ALGORITMA */
for (i = 0; i < M.NBrsEff; i++) {
for (j = 0; j < M.NKolEff; j++) { printf("%d ", M.mem[i][j]); } printf("\n"); } }
Jumlah 2 Matriks (1)
• Fungsi JumlahMatriks menerima masukan
sebuah 2 Matriks M1 dan M2 dan menghasilkan
matriks yang merupakan penjumlahan dari M1
dan M2. Asumsi: ukuran baris dan kolom M1
dan M2 sama
Matriks JumlahMatriks (Matriks M1, Matriks M2);
/* Menghasilkan penjumlahan matriks M1 dan M2 */
Jumlah 2 Matriks (2)
Matriks JumlahMatriks (Matriks M1, Matriks M2);
/* Asumsi: ukuran baris dan kolom M1 dan M2 sama */
{ /* KAMUS LOKAL */
int i, j; /* indeks matriks */ Matriks M3;
/* ALGORITMA */
M3.NBrsEff = M1.NBrsEff; M3.NKolEff = M1.NKolEff;
for (i = 0; i < M1.NBrsEff; i++) {
for (j = 0; j < M1.NKolEff; j++) {
M3.mem[i][j] = M1.mem[i][j] + M2.mem[i][j]; }
}
return M3; }
Latihan 1: Hitung 0
• Fungsi Count0 menghasilkan banyaknya
elemen matriks M yang bernilai 0
int Count0 (Matriks M);
Latihan 2: Transpose
• Prosedur Transpose menerima masukan
sebuah Matriks M dan menghasilkan
matriks M1 yang merupakan transpose
dari M
void Transpose (Matriks M, Matriks *M1);
/* I.S.: M terdefinisi, M1 sembarang */ /* F.S.: M1 berisi transpose dari M */
