Escolar Documentos
Profissional Documentos
Cultura Documentos
3.1 Tujuan
Tujuan modul III ini, adalah:
• Praktikan bisa membuat program sederhana berdasarkan algoritma dengan
memakai larik
• Praktikan bisa membuat program matriks sederhana berdasarkan algoritma
dengan memakai larik
• Praktikan dapat membiasakan diri untuk membuat program secara terstruktur.
• Praktikan memahami algoritma larik dan matriks
3.2 Teori
3.2.1 Larik
Larik atau array adalah struktur data yang menyimpan sekumpulan elemen
yang bertipe sama. Setiap elemen diakses langsung melalui indeksnya. Contoh:
larik A dengan 8 elemen yang setiap elemennya berisi tinggi badan siswa di
sebuah sekolah.
A
1 158
2 159
3 342
4 324
5 123
6 645
7 452
8 323
III-1
III-2
Deklarasi
Const Maks = 100 {banyak elemen larik}
III-3
Deskripsi
Inisialisasi nilai
K ←1 {mulai dari elemen pertama}
While K ≤ NMaks do
Pemrosesan terhadap A[K]
K←K+1
Endwhile
{K > NMaks}
Terminasi
Deklarasi
K: integer {pencatat indeks larik}
Deskripsi
For K←1 to N do
A[K] ← 0
Endfor
Algoritma Pemroseslarik
{pemrogram utama untuk mengisi elemen larik dengan nilai 0}
III-4
Deklarasi
Const NMaks = 100 {banyaknya elemen larik}
Type Larikint : array[1..NMaks] of integer
A : Larikint
K : integer {indeks larik}
N : integer {jumlah elemen efektif larik}
Deskripsi
Read(N)
Inisdengan0(A, N)
Larik digunakan bila kita memerlukan penyimpanan sementara data yang bertipe
sama di dalam memori, untuk selanjutnya data tersebut dimanipulasi, dihitung
atau diterapkan oleh proses lainnya.
Contoh Algoritma 2:
Algoritma BacaTampilLarik
{program utama untuk membaca dan menampilkan hasil larik}
Deklarasi
A[10], N, K : integer
Deskripsi
Read(N)
K←0
repeat
K ← K+1
read(A[K])
until K=N
K=0
repeat
K ← K+1
write(‘A[‘,K,’] =’,’A[K])
until K=N
III-5
Program Algoritma 2
//tulisbacalarik
#include "stdio.h"
main(){
int A[10], N, K;
printf("Jumlah : ");scanf("%d", &N);
K=0;
do {
K++;
printf("A[%d]",K);scanf("%d", &A[K]);
} while (K<N);
K=0;
do {
K++;
printf("A[%d] = %d", K, A[K]);
} while (K< N);
}
Contoh Algoritma 3:
Procedure HitungRata2(input A : Larikint, input N : integer, output U : real)
{menghitung nilai rata-rata elemen larik A [1..N]}
{k.awal: elemen larik A[1..N] sudah terdefinisi nilainya}
{k.akhir: U berisi nilai rata-rata seluruh elemen}
Deklarasi
K : integer {indeks larik}
Jumlah : real {jumlah total seluruh nilai}
Deskripsi
Jumlah←0
K←0
repeat{
K←K+1
Jumlah ← Jumlah+A[K]
}until (K=N)
U←Jumlah/N
}
Program Hitungratarata
{program utama menghitung rata-rata seluruh elemen larik}
III-6
Deklarasi
Const NMaks = 100 {banyaknya elemen larik}
Type Larikint : array[1..NMaks] of integer
A : Larikint
N, K : integer
U : real
Deskripsi
read(N)
K←0
repeat
K←K+1
read(A[K])
until (K=N)
HitungRata2(A, N, U)
write(U)
Program Algoritma 3:
//tulisbacalarik
#include "stdio.h"
main(){
Larikint A;
int N, K;
float U;
printf("Jumlah : ");scanf("%d",&N);
K=0;
do {
K++;
printf("A[%d]= ",K);scanf("%d",&A[K]);
} while (K<N);
HitungRata2(A, N,&U);
printf("%4.2f",U);}
III-7
Contoh Algoritma 4:
Function Maksimum(input A : Larikint, input N : integer)→integer
{mengembalikan elemen terbesar di dalam larik A[1..N]}
Deklarasi
K : integer {pencatat indeks larik}
Deskripsi
Maks ← -9999 {nilai maksimum sementara}
For K←1 to N do
If A[K] > Maks then
Maks←A[K]
Endif
Endfor
Return maks
Program mencarinilaimaksimum
{program utama mencari nilai maksimum}
Deskripsi
Const NMaks = 100 {banyaknya elemen larik}
Type Larikint : array[1..NMaks] of integer
A : Larikint
N ,K : integer
Maks : integer
Deskripsi
read(N)
III-8
K←0
repeat {
K←K+1
read(A[K])
} until (K=N)
write(Maks(A, N))
Program Algoritma 4:
//cari nilai maksimum
#include "stdio.h"
main(){
Larikint A;
int N, K;
printf("Jumlah : ");scanf("%d",&N);
K=0;
do {
K++;
printf("A[%d]= ",K);scanf("%d",&A[K]);
} while (K<N);
printf("Nilai maksimum dari keseluruhan elemen : %d",Carimaks(A, N));
}
mahasiswa adalah NIM, nama mahasiswa, mata kuliah yang diambil dan nilai
mata kuliah tersebut.
Deklarasi
Const nmaks = 100
Type mahasiswa : record < nim : integer,
Namamhs : string,
Kodemk : string,
Nilai : char
>
Deklarasi
Const NMaks =100
Type Mahasiswa : record < Nim : integer,
Namamhs : string,
Kodemk : string,
Nilai : integer >
III-10
Deskripsi
Read(N)
For K←1 to N do
Read(Tabmhs[K]).Nim
Read(Tabmhs[K]).Namamhs
Read(Tabmhs[K]).Kodemk
Read(Tabmhs[K]).Nilai
Endfor
For K←1 to N do
write(Tabmhs[K]).Nim
write (Tabmhs[K]).Namamhs
write (Tabmhs[K]).Kodemk
write (Tabmhs[K]).Nilai
Endfor
Program Algoritma 5:
// bacalarikmhs
#include "stdio.h"
main(){
Larikint Tabmhs;
int N, K;
printf("Jumlah : ");scanf("%d", &N);
printf("Masukan Data\n\n\n");
for (K=1;K<=N;K++){
printf("record ke-[%d]\n", K);
printf("Nim : ");scanf("%d", &Tabmhs[K].Nim);
printf("Nama mhs : ");scanf("%s", Tabmhs[K].Namamhs);
printf("Kode MK : ");scanf("%s", Tabmhs[K].Kodemk);
printf("Nilai : ");scanf("%d", &Tabmhs[K].Nilai);}
K=0;
III-11
printf("\n\nTampilkan\n");
for (K=1;K<=N;K++){
printf("record ke-[%d]\n", K);
printf("Nim : %d\n", Tabmhs[K].Nim);
printf("Nama mhs : %s\n", Tabmhs[K].Namamhs);
printf("Kode MK : %s\n", Tabmhs[K].Kodemk);
printf("Nilai : %d\n", Tabmhs[K].Nilai);}
}
3.2.2 Matriks
Matriks adalah struktur penyimpanan data di dalam memori utama yang
individu elemennya diacu dengan menggunakan dua buah indeks (yang biasanya
dikonotasikan dengan baris dan kolom).
kolom
1 2 3 4
1 Elemen(2,3)
2
Baris 3
4
5
1 2 3 4 1 2 3 4 1 2 3 4 1 2 3 4 1 2 3 4
• Setiap elemen data dapat diakses secara langsung jika indeksnya (baris dan
kolom) diketahui, yang dalam hal ini indeks menyatakan posisi relatif di
dalam kumpulannya
• Merupakan struktur data yang statik, artinya jumlah elemennya sudah
dideklarasi terlebih dahulu di dalam bagian kamus dan tidak bisa diubah
selama pelaksanaan program.
Deklarasi
I : integer {indeks baris}
J : integer {indeks kolom}
Deskripsi
For I ←1 to NBar do
For J ←1 to NKol do
Proses(N[I, J])
Endfor
Endfor
Deklarasi
I, J : integer
Deskripsi
For I ←1 to NBar do
For J ←1 to NKol do
N[I, J] ← 0
Endfor
Endfor
Program Algoritma 1:
//inisialisasi matriks
#include "stdio.h"
#define NBarismaks 10
#define NKolommaks 10
typedef int Matriksint[NBarismaks+1][NKolommaks+1];
III-14
Matriksint M;
int I, J, NKol, NBar;
main(){
NBar=5;
NKol=5;
Inismatriks(&M, NBar, NKol); }
Deklarasi
I, J : integer
Deskripsi
For I ←1 to NBar do
For J ←1 to NKol do
Write(’M[’, I, ’,’ ,J, ’] = ’)
Read(M[I,J])
Endfor
Endfor
III-15
Deklarasi
I, J : integer
Deskripsi
For I ←1 to NBar do
For J ←1 to NKol do
Write(’M[’, I, ’,’ ,J, ’] = ’)
write(M[I, J])
Endfor
Endfor
Program Algoritma 2:
//bacatulis matriks
#include "stdio.h"
#define NBarismaks 10
#define NKolommaks 10
typedef int Matriksint[NBarismaks+1][NKolommaks+1];
matriksint m;
int I, J, NKol, NBar;
main(){
printf("Masukan jumlah baris");scanf("%d", &NBar);
printf("Masukan jumlah baris");scanf("%d", &NKol);
Bacamatriks(&M, NBar, NKol);
Tulismatriks(&M, NBar, NKol);
}
Contoh Algoritma 3:
Procedure Jumlahduamatriks(input M : Matriksint, input A : Matriksint, output
C: Matriksint, input NBar, NKol : integer)
{menjumlahkan matriks M dan A, yaitu M+A = C}
{k.awal : matriks M dan A sudah terdefinisi elemen-elemennya}
{k.akhir : matriks C berisi hasil penjumlahan M dan A}
Deklarasi
I, J : integer
Deskripsi
For I ←1 to NBar do
For J ←1 to NKol do
C[I, J] = M[I, J] + A[I, J]
Endfor
Endfor
Program Algoritma 3
//jumlah dua matriks
#include "stdio.h"
#define NBarismaks 10
#define NKolommaks 10
typedef int Matriksint[NBarismaks+1][NKolommaks+1];
Matriksint M;
Matriksint A;
Matriksint C;
int I, J, NKol, NBar;
main(){
printf("Masukan jumlah baris");scanf("%d",&NBar);
printf("Masukan jumlah baris");scanf("%d",&NKol);
Bacamatriks(&M, &A, NBar, NKol);
Jumlahduamatriks(&M, &A, &C, NBar, NKol);
Tulismatriks(&C, NBar, NKol);
}
void Bacamatriks(Matriksint *M, Matriksint *A, int NBar, int NKol) {
for (I=1;I<=NBar;I++) {
for (J=1;J<=NKol;J++) {
printf("M[%d,%d]= ", I, J);scanf("%d",&(*M[I][J]));
printf("A[%d,%d]= ", I, J);scanf("%d",&(*A[I][J]));}
}
}
Contoh Algoritma 4:
Matriks nol adalah matriks dengan semua elemen adalah 0.
1 2 3 4
1 0 0 0 0
2 0 0 0 0
3 0 0 0 0
4 0 0 0 0
Deklarasi
I, J : integer
Zero : boolean
Deskripsi
I←1
Zero ← true
While (I ≤ NBar) and (Zero) do
J←1
While (I ≤ NKol) and (Zero) do
If A[I,J] ≠ 0 then
Zero ← false {bukan matriks nol. stop}
Else
J ← J+1 {periksa kolom berikutnya}
Endif
Endwhile
{J > NKol or not Zero}
If zero then
I ← I+1 {periksa baris berikutnya}
Endif
Endwhile
{I > NBar or not Zero}
Return Zero
Program Algoritma 4:
//jumlah dua matriks
#include "stdio.h"
#define NBarismaks 10
#define NKolommaks 10
typedef int Matriksint[NBarismaks+1][NKolommaks+1];
Matriksint M;
int I, J, NKol, NBar;
main(){
printf("Masukan jumlah baris");scanf("%d",&NBar);
printf("Masukan jumlah baris");scanf("%d",&NKol);
Bacamatriks(&M, NBar, NKol);
III-19
Contoh Algoritma 5:
1 2 3 4 5 6 7
1 ’a’ ’m’ ’p’ ’u’ ’h’
2 ’b’ ’a’ ’n’ ’d’ ’u’ ’n’ ’g’
3 ’a’ ’p’ ’i’
4 ’k’ ’u’ ’d’ ’a’
...
M ’l’ ’a’ ’l’ ’a’ ’t’
Deklarasi
I, J : integer
Deskripsi
For I ← 1 to M do
J ←1
{telusuri elemen matriks pada baris I sampai ketemu spasi}
While (J < N) and (Word[I, J] ≠ ’ ’) do
Write(Word[I, J])
J ← J+1
Endwhile
{J=N or Word[I, J] = ‘ ’}
{cetak karakter terakhir jika bukan spasi}
If M[I, J] ≠ ’ ’ then
Write(M[I, J])
Endif
Endfor
Cobalah buat programnya dari algoritma berikut!
3.3 Kasus
3.3.1 Kasus 1
1. Diberikan larik integer A dan integer larik B yang masing-masing berukuran n
elemen. Larik A dan B sudah terdefinisi elemen-elemennya. Tuliskan
algoritma prosedur untuk mempertukarkan elemen larik A dan elemen larik B
pada indeks yang bersesuaian, sedemikian sehingga larik A berisi elemen-
elemen larik B dan larik B berisi elemen-elemen larik A semula. Buatlah
program dari algoritma tersebut.
2. Diberikan larik karakter A yang berukuran N elemen. Larik A sudah
terdefinisi elemen-elemennya. Tuliskan algoritma prosedur yang
membalikkan elemen-elemen larik A sedemikian sehingga elemen terakhir
pada larik semula menjadi elemen pertama pada larik akhir.
Contoh: Sebelum pembalikan:
‘a’ ‘b’ ‘c’ ‘d’ ‘e’
Setelah pembalikan:
‘e’ ‘d’ ‘c’ ‘b’ ‘a’
III-21
3.3.2 Kasus 2
1. Misalkan matriks C yang berukuran M x N sudah berisi data karakter.
Tuliskan algoritma untuk menghitung frekuensi kemunculan huruf ‘A' di
dalam matriks tersebut.
2. M orang mahasiswa mengambil N mata kuliah. Setelah setelah seluruh ujian
akhir selesai, nilai rata-rata (NR) mahasiswa tersebut segera dihitung. NR
dihitung dengan rumus:
N
∑ MK
j =1
j xSKS j
NR = N
∑ SKS
j =1
j
yang dalam hal ini, MKj adalah mata kuliah yang ke j dan SKSj adalah bobot
SKS dari mata kulia MKj nilai mahasiswa (berupa indeks nilai A, B, C, D, E)
disimpan di dalam matriks nilaimhs yang berukuran M x N. baris i pada
matriks menyatakan mahasiswa ke-I dan kolom j menyatakan mata kuliah
(MK) ke-j. setiap elemen matriks adalah berupa record yang terdiri atas field
SKS dan field indeksnilai (jadi matriksnya bertipe terstruktur). Nilaimhs[i,j]
menyatakan data nilai mahasiswa yang mengambil mata kuliah j, nilaimhs[i,j].
indeksnilai menyatakan indeks nilai mata kuliah j yang diambil mahasiswa i.
tulislah algoritma dan program untuk menuliskan NR setiap mahasiswa.
Deklarasi
K : integer {pencatat indeks larik}
Deksripsi
Min ← A[1]
Maks ← A[1]
For K ← 2 to N do
If A[K] < Min then
Min ← A[K]
endif
If A[K] > Maks then
Maks ← A[K]
Endif
Endfor
Buatlah algoritma untuk program utamanya....
Algoritma 2
Procedure CariX(input A : Larikint, input N : integer, input X : integer, output
Ix : integer)
{mencari keberadaan nilai X di dalam larik A[1..N]}
{k.awal : nilai X dan elemen larik A[1..N] sudah terdefinisi}
{k.akhir : ix berisi indeks larik A tempat X berada. Jika X tidak ditemukan, Ix
diisi dengan nilai 0}
Deklarasi
X : integer {indeks larik}
Deskripsi
K←1
While (K<N) and (A[K] ≠ X) do
III-23
K ← K+1
Endwhile
{K=N or A[K] = X}
if A[K] = X then {X ditemukan}
Ix ← K
else
Ix ← 0
Endif
Algoritma pencarian
{program utama mencari nilai tertentu di dalam larik}
Deklarasi
Const NMaks = 100 {banyak elemen larik}
Type Larikint : array[1..NMaks] of integer
A : Larikint
X : integer {elemen yang dicari}
Ix : integer {indeks larik tempat X ditemukan}
Deskripsi
Read(N)
Bacalarik(A, N)
Read(X)
CariX(A, N, X, Ix)
If Ix = 0 then
Write(‘data tidak ditemukan’)
Else
Write(‘ditemukan pada indeks larik ke-’,Ix)
Endif
Algoritma 3
Algoritma Bacalarikmahasiswa
{mengisi elemen larik mahasiswa dengan data yang dibaca dari piranti
masukan}
III-24
Deklarasi
Const NMaks =100
Type Matakuliah : record < KodeMK : string,
NamaMK : string,
Nilai : integer
>
Type Mahasiswa : record < Nim : string,
Namamhs : string,
MK : array[1..5] of matakuliah
>
Larikmhs : array[1..NMaks] of Mahasiswa
I, J : integer
N : integer
JmlMK : integer
Deskripsi
JmlMK = 4
Read(N)
For I←1 to N do
Read(Larikmhs[I].Nim)
Read(Larikmhs[I].Namamhs)
For J←1 to JmlMK do
Read(Larikmhs[I].MK[J].KodeMK)
Read(Larikmhs[I].MK[J].NamaMK)
Read(Larikmhs[I]).MK[J].Nilai)
Endfor
Endfor
Algoritma 4
Tambahkan program di ’algoritma 3’ dengan procedure ’algoritma 4’...
Procedure Hitungindeks(input Nilaiujian : Larikmhs, input N : integer, output
Indeks : Larikmhs)
{menghitung indeks nilai ujian mahasiswa}
{k.awal : N sudah berisi ukuran larik. Elemen larik Nilaiujian[1..N] sudah
terdefinisi nilainya}
{k.akhir : larik Indeks[1..N] berisi nilai indeks ujian}
Deklarasi
K:integer
Deskripsi
For k←1 to N do
Case (Nilaiujian[K])
III-25
Nilaiujian[I] ≥ 80 : Indeks[K]←’A’
70 ≤ Nilaiujian[I] < 80 : Indeks[K]←’B’
55 ≤ Nilaiujian[I] < 70 : Indeks[K]←’C’
45 ≤ Nilaiujian[I] < 55 : Indeks[K]←’D’
Nilaiujian[I] < 45 : Indeks[K]←’E’
Endcase
Endfor
Algoritma 5
Tambahkan ’algoritma 3’ dan ’algoritma 4’ diatas dengan ’algoritma 5’...
Procedure Cetaknilai(input Nim : Larikmhs, input Namamhs : Larikmhs, input :
KodeMK : Larikmhs, input Nilaiujian : Larikmhs, input
Indeks : Larikmhs, input JmlMK : integer)
{mencetak Nim, KodeMK, Nilaiujian dan Indeks ke piranti keluaran}
{k.awal : larik Nim, KodeMK[1..N], Nilaiujian[1..N] dan Indeks[1..N] sudah
terdefinisi}
{k.akhir : Nim, KodeMK, Nilaiujian dan Indeks dicetak ke piranti keluaran}
Deklarasi
I, J : integer
Deskripsi
For I←1 to N do
write(’Nim : ’, Larikmhs[I].Nim)
write(’Nama : ’, Larikmhs[I].Nama)
For J←1 to JmlMK do
{Cetak header tabel}
write(’--------------------------------------’)
write(’KodeMK Nilai Indeks ’)
write(’--------------------------------------’)
write(Larikmhs[I], MK[J].KodeMK, Larikmhs[I]),MK[J].Nilaiujian),
Larikmhs[I]), MK[J].Indeks)
Endfor
Endfor
Deklarasi
I, J : integer
Deskripsi
Maks ← -9999 {diasumsikan -9999 sebagai nilai maksimum sementara}
For I ← 1 to NBar do
For J ← 1 to NKol do
If A[I, J] > Maks then
Maks ← A[I, J]
Endif
Endfor
Endfor
Algoritma 2
Procedure CariX(input A : Matriksint, input NBar, NKol : integer, output
Idxbaris, Idxkolom : integer)
{mencari X di dalam matriks A[1..NBar, 1..NKol]}
{k.awal : matriks a sudah terdefinisi nilai elemen-elemennya }
k.akhir : Idxbaris dan Idxkolom berisi indeks matriks A sedemikian sehingga
A[Idxbaris, Idxkolom] = X. Jika X tidak ditemukan maka Idxbaris dan
Idxkolom diisi nilai -1}
Deklarasi
I, J : integer
Ketemu : boolean {true jika X ditemukan, false jika sebaliknya}
Deskripsi
I←1
Ketemu ← false
While (I ≤ NBar) and (not Ketemu) do
J←1
{telusuri elemen matriks pada baris ke-I, dimulai dari kolom ke-J}
While (J ≤ NKol) and (not Ketemu) do
If A[I, J] = X then
Ketemu ← true
Else
J ← J+1 {periksa pada kolom berikutnya}
Endif
Endwhile
{J > NKol or Ketemu}
If not Ketemu then
III-27
Algoritma 3
Procedure BuatTranspose(input A : Matriksint, input NBar, NKol : integer,
output At: Matriksint, output NBarAt, NKolAt :
integer)
{membentuk transpose dari matriks A[1..NBar, 1..NKol]}
{k.awal : matriks a sudah terdefinisi nilai elemen-elemennya}
{k.akhir : at adalah transpose dari matriks a sedemikian sehingga matriks hasil
transpose (jumlah aris dan jumlah kolom)}
Deklarasi
I, J : integer
Deskripsi
NBarAt ← NKol {jumlah baris matriks transpose}
NKolAt ← NBar {jumlah baris matriks transpose}
for I ← 1 to NBar do
for J ← 1 to NKol do
At[J, I] ← A[I, J]
Endfor
Endfor
Algoritma 4
Procedure Perkalianmatriks(input A : Matriks, input M, N : integer, input B :
Matriks, input P : integer, output C : Matriks, output
NBarc, NKolc : integer)
{mengalikan matriks A dan B menghasilkan matriks C}
{k.awal : matriks A dan B sudah terdefinisi elemen-elemennya}
{k.akhir : matriks C berisi hasil perkalian A dan B, NBarc dan NKolc berisi
ukuran matriks C}
III-28
Deklarasi
I, J : integer
K : integer
Deskripsi
Nbarc ← M {jumlah baris matriks hasil perkalian}
Nkolc ← P {jumlah kolom matriks hasil perkalian}
For I ← 1 to M do
For j ← 1 to P do
C[I, J] ← 0 {inisialisasi C[I, J] dengan 0}
For K ← 1 to N do
C[I, J] ← A [I, K] * B[K, J]
Endfor
Endfor
Endfor