download

Lecture Notes on Algorithms and Data Struture
ALGORITMA MATEMATIKA
Oleh
Thompson Susabda Ngoen
Universitas Bina Nusantara
Fakultas Ilmu Komputer
2002
ALGORITMA MATEMATIKA
Deret Bilangan
Yang disebut dengan deret bilangan adalah sejumlah bilangan yang berurutan (sequence), bisa
terbatas atau tidak terbatas jumlahnya, yang mengikuti suatu kaidah tertentu. Deret tersebut
umumnya disusun secara menaik nilainya (ascending).
Deret bilangan ganjil: 1, 3, 5, 7, 9, …
ganjil n+1 = ganjil n + 2
 Deret bilangan ganjil antara dua bilangan tertentu
void deretbilganjil(long mulai, long sampai) {
if (mulai > sampai) tukar (&mulai, &sampai);
if (mulai%2== 0) mulai++;
// cari ganjil pertama
for (;mulai<= sampai; mulai+=2) printf("%ld ", mulai);
}
Deret bilangan genap: 2, 4, 6, 8, 10, …
genap n+1= genap n + 2
 Deret bilangan genap antara dua bilangan tertentu
void deretbilgenap(long mulai, long sampai) {
if (mulai > sampai) tukar (&mulai, &sampai);
if (mulai%2== 1) mulai++;
// cari genap pertama
for (;mulai<= sampai; mulai+=2) printf("%ld ", mulai);
}
Deret bilangan prima: 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, …
Apakah p adalah prima? Bagi p dengan 2, 3, 5, … sampai dengan √p
 Deret bilangan prima
int isprime(unsigned long n) {
int batas, pembagi, prima;
if (n==2) return 1;
if ((n%2)==0 || n<2) return 0;
batas = ceil(sqrt(n)+0.5);
pembagi = 3;
prima = 1;
while ((pembagi<batas) && prima) {
if ((n%pembagi)==0) return 0; else pembagi+=2;
}
Algo Mat
1
return 1;
}
void deretprima(int n) {
int i; long bil;
if (n> 0) {
printf("2 ");
i= 1;
bil= 3;
while (i< n) {
if (isprime(bil)) {
printf("%ld ", bil);
i++;
}
bil+=2;
}
}
}
Deret bilangan fibonacci: 1,1, 2, 3, 5, 8, 13, 21, 34, ,,,
f1= 1; f2= 1; fn= fn-1 + fn-2
 Deret bilangan fibonacci
void deretfibonacci(int n) {
int i, fn, fn1, fn2;
for (i= 1; i<= n; i++) {
if (i==1) { printf("1 "); fn1= 1; }
else
if(i==2) { printf("1 "); fn2= 1; }
else {
fn= fn1 + fn2;
printf("%d ", fn);
fn1= fn2;
fn2= fn;
}
}
}
Deret Oblong: 2, 6, 12, 20, 30, 42 , …


















Algo Mat
2



 Deret Oblong
void deretoblong(int n) {
for (int i= 1; i<= n; i++)
printf("%d ", i * (i+1));
}
Segitiga Pascal atau Chu Shih-Chieh
1
1
1
1
1
1
2
3
4
5
1
1
3
6
10
1
4
10
1
5
1
Permutasi dan Kombinasi
Permutasi
Apabila terdapat empat orang untuk menduduki posisi empat jabatan dalam sebuah
kepanitiaan: ketua, wakil ketua, sekretaris,bendahara maka akan terdapat 24 kemungkinan
susunan panitia. Hal ini mengikuti perhitungan:
Untuk jabatan ketua terdapat 4 kemungkinan
Untuk jabatan wakil ketua terdapat 3 kemungkinan (setelah dikurangi satu orang yang
menduduki jabatan ketua).
Untuk jabatan sekretaris terdapat 2 kemungkinan (setelah dikurangi satu orang yang
menduduki jabatan ketua dan satu orang lagi yang menduduki jabatan wakil ketua)
Untuk jabatan bendahara terdapat 1 kemungkinan (setelah dikurangi tiga orang pada tiga
jabatan sebelumnya)
4 * 3 * 2 * 1 = 24 kemungkinan
Kemungkinan jumlah komposisi seperti perhitungan di atas disebut permutasi. Terdapat n!
permutasi terhadap n elemen.
Apabila dari n elemen yang tersedia dibentuk komposisi yang terdiri dari r elemen maka
banyaknya susunan yang dapat dibentuk ialah
n * (n - 1) * (n - 2) * … * (n - r + 1)
Misalkan dari 5 elemen (n = 5) akan dibentuk susunan tiga elemen-tiga elemen (r = 3)
Algo Mat
3
Untuk elemen pertama : 5 kemungkinan
Untuk elemen kedua : 4 kemungkinan
Untuk elemen ketiga : 3 kemungkinan
Banyaknya kemungkinan = 5 * 4 * 3 = n * (n - 1 ) * (n - 2) = 60
P (n, r) = n * (n - 1) * (n - 2) * … * (n - r + 1)
atau
n * (n - 1) * (n - 2) * … * (n - r + 1) * (n – r ) * ( n – r – 1 ) * …2 * 1
P (n, r) = ---------------------------------------------------------------------------------------(n – r ) * ( n – r – 1 ) * …2 * 1
sehingga
n!
P (n, r ) = ---------------(n – r ) !
 Permutasi bilangaan
unsigned long faktor(int n) {
unsigned long hasil= 1;
for(int i= 1; i<= n; i++) hasil *=i;
return hasil;
}
unsigned long permutasi(int n, int r) {
return faktor(n) / faktor (n-r);
}
Kombinasi
Misalkan terdapat sejumlah n objek. Kombinasi r objek dari kumpulan objek ini adalah susunansusunan r objek dengan urutan tidak diperhitungkan. Dengan perkataan lain, r kombinasi dari n
objek adalah himpunan r elemen. Sebagi contoh misalnya terdapat empat objek, diwakili huruf A,
B, C, dan D dengan kombinasi yang terdiri dari tiga objek akan memberikan hasil { A,B,C}, {
A,B,D}, {A,C,D}, {B,C,D} atau ABC, ABD, ACD, BCD, sebanyak empat jenis susunan. Kombinasi
adalah permutasi tanpa membedakan urutan elemen. Pada kombinasi yang terdiri dari tiga
elemen dasar misalnya ABC dianggap sama dengan ACB dan BAC dan BCA dan CAB dan CBA.
Kombinasi
Permutasi
ABC
ABC, ACB, BAC, BCA, CAB, CBA
ABD
ABD, ADB, BAD, BDA, DAB, DBA
ACD
ACD, ADC, CAD, CDA, DAC, DCA
BCD
BCD, BDC, CBD, CDB, DBC, DCB
Algo Mat
4
Karena setiap kombinasi yang dibentuk dari 3 objek dapat membentuk 3! atau 6 permutasi maka
K(4,3) * 3! = P (4,3) atau
P (4,3)
K (4,3) = --------- atau
3!
P (n, r)
K (n, r) = --------------r!
sehingga
n!
K (n, r ) = ---------------(n – r ) ! r !
 Daftar kombinasi
unsigned long kombinasi(int n, int r) {
return faktor (n) / (faktor(r) * faktor(n-r));
}
void daftarkombinasi(int n, int r) {
int i, j, s[100];
int komb, m, maxval;
komb = kombinasi (n, r);
for (i=1; i<=r; i++) {
s[i]= i;
printf("%c", s[i]+64);
}
printf("\n");
for(i=2 ; i<=komb; i++) {
m = r;
maxval= n;
while (s[m]==maxval) {
m--; maxval--;
}
s[m]++;
for(j=m+1; j<=r; j++) s[j]= s[j-1]+1;
for(j=1;j<=r;j++) printf("%c",s[j]+64);
printf("\n");
}
}
Algo Mat
5
Polinom
Polinom adalah persamaan matematika berbentuk
c0x0 + c1x1 + c2x2 + … + cn-1xn-1
c0, c1, c2 , … , cn-1 disebut koefisien, berupa bilangan konstan. Sebagai contoh 3 + x - 4x3 adalah
polinom berderajat 3. Terhadap polinom dapat dilakukan beberapa operasi matematika seperti
penjumlahan polinom, perkalian polinom, dan evaluasi polinom dengan memberi nilai tertentu
kepada peubah x. Untuk operasi-operasi tersebut struktur data yang digunakan dapat berupa
array atau linked-list.
Penjumlahan Polinom
Penjumlahan polinom dilakukan dengan menjumlahkan koefisien elemen-elemen berpangkat
sama. Cara termudah adalah dengan menggunakan array untuk menyimpan . koefisien
masing-masing elemen. Misalkan polinom 5 - x + 3x 2 - 8x 3 + 4x 5 disimpan dalam bentuk
[0]
[1]
[2]
[3]
[4]
[5]
…
[100]
5
-1
3
-8
0
4
0
0
 Penjumlahan polinom dengan menggunakan array
struct tpolinom {
int pangkat;
int koef[100]; // disesuaikan dengan kemungkinan pangkat tertinggi
} ;
void initpolinom(struct tpolinom * p) {
p->pangkat= 0;
for (int i= 0; i<100; i++) p->koef[i]= 0;
}
struct tpolinom jumlahpolinom (struct tpolinom p1,
struct tpolinom p2) {
struct tpolinom p3;
if(p1.pangkat > p2.pangkat) p3.pangkat= p1.pangkat;
else p3.pangkat= p2.pangkat;
for (int i= 0; i<= p3.pangkat; i++)
p3.koef[i]= p1.koef[i] + p2.koef[i];
return p3;
}
void main() {
struct tpolinom pnom1, pnom2, pnom3;
. . .
Algo Mat
6
initpolinom(&pnom1);
initpolinom(&pnom2);
. . .
pnom3 = jumlahpolinom(pnom1, pnom2);
. . .
}
Implementasi dengan struktur data array menjadi tidak efisien jika pangkat relatif melebar
(sparse), misalnya untuk polinom 1 + 2x 1000 walaupun sebenarnya hanya ada dua koefisien
yang perlu disimpan namun memerlukan tempat penyimpanan sebanyak 1001 elemen.
Sebagai alternatif dapat gunakan linked-list. Node digunakan untuk menyimpan elemen yang
tidak nol yaitu koefisien dan pangkatnya.
Jika nilai field pangkat pada node polinom pertama lebih kecil daripada nilai field pangkat
pada node polinom kedua maka node polinom pertama ini yang disalin ke polinom hasil dan
pointer pindah ke node berikutnya pada polinom pertama. Jika nilai field pangkat pada node
polinom pertama lebih besar daripada nilai field pangkat pada node polinom kedua maka
node polinom kedua ini yang disalin ke polinom hasil dan pointer pindah ke node berikutnya
pada polinom kedua. Jika nilai field pangkat pada node-node kedua polinom sama besar dan
hasil jumlah koefisiennya bukan nol maka jumlahkan koefisiennya dan disalin ke polinom
hasil, lanjutkan dengan node berikutnya pada masing-masing polinom.
 Penjumlahan polinom dengan linked list
struct tnode {
int p;
// pangkat
int k;
// koefisien
struct tnode *next;
};
struct tnode *isipolinom() {
...
}
struct tnode *newnode(int p, int k) {
struct tnode *node;
node =(struct tnode *) malloc (sizeof(struct tnode));
node->p= p; node->k= k;
return node;
}
void addpolinom(struct tnode **pr,
struct tnode *pp, struct tnode *pq) {
struct tnode *curr, *node;
Algo Mat
7
*pr= NULL;
while (pp!=NULL && pq!= NULL) {
if((pp->p == pq->p)&& ((pp->k + pq->k)!=0)){
node= newnode(pp->p, pp->k+pq->k);
pp=pp->next; pq=pq->next;
} else
if (pp->p < pq->p) {
node= newnode(pp->p, pp->k);
pp= pp->next;
} else {
node = newnode(pq->p, pq->k);
pq= pq->next;
}
if (*pr==NULL) {
*pr= node; curr=node; }
else {
curr->next= node;
curr= node;
}
} // while
//** copy sisa polinom p **//
while(pp!=NULL){
node= newnode(pp->p, pp->k);
curr->next= node; curr= node;
pp= pp->next;
}
//** copy sisa polinom q **//
while(pq!=NULL){
node= newnode(pq->p, pq->k);
curr->next= node; curr= node;
pq= pq->next;
}
curr->next= NULL;
}
void main() {
struct tnode *pnomP, *pnomQ, *pnomR;
pnomP = isipolinom();
pnomQ = isipolinom();
addpolinom(&pnomR, pnomP, pnomQ);
...
}
Algo Mat
8
Perkalian Polinom
Perkalian polinom dilakukan dengan mengalikan setiap koefisien polinom pertama dengan setiap
koefisien polinom kedua.
 Perkalian polinom dengan mengunakan array
struct tpolinom kalipolinom( struct tpolinom p1,
struct tpolinom p2) {
struct tpolinom p3;
int i, j, k;
initpolinom(&p3);
p3.pangkat= p1.pangkat + p2.pangkat;
for (i=0; i<= p1.pangkat; i++)
for (j=0; j<= p2.pangkat; j++)
p3.koef[i+j] += p1.koef[i] * p2.koef[j];
return p3;
}
Impelementasi dengan linked list menggunakan pendekatan yang sama, yaitu mengalikan
setiap koefisien dan pangka setiap node. Hasil perkalian dengan pangkat yang sama harus
disimpan pada node yang sama. Misalnya polinom 2 + 3x + 4x2 dan 3 + 4x + 5x2 akan
dikalikan
Perkalian 2 * 4x dan 3x * 3 memberikan hasil perpangkatan yang sama sehingga harus
disimpan pada satu node yang sama, node untuk pangkat satu. Urutan pembentukan linked list
hasil perkalian menjadi:
Algo Mat
9
Evaluasi Polinom
Yang dimaksud dengan evaluasi polinom di sini ialah menghitung nilai suatu polinom apabila
peubah x diganti dengan sebuah nilai tertentu. Misalnya polinom 5x4-2x3+4x2+ 6x+1 bila dievaluasi
dengan nilai x= 4 akan memberikan hasil 1241.
Pada penghitungan biasa maka perlu dilakukan kalkulasi untuk 44, 43, 42, yaitu dilakukan kalkulasi
berulang-ulang. Untuk mengurangi pengulangan perkalian dapat digunakan Horner’s rule
sehingga polinom berderajat N dapat dihitung dengan N-1 perkalian dan N penjumlahan, seperti
contoh di bawah ini:
p(x)=5x4-2x3+4x2+6x+1
p(x)= x(x(x(5x-2)+4)+6)+ 1
 Evaluasi polinom dengan horner’s rule
long evalpolinom(struct tpolinom p, int x) {
long hasil= 1;
int i;
hasil= p.koef[p.pangkat];
for (i= p.pangkat-1; i>= 0; i--)
hasil = hasil * x + p.koef[i];
return hasil;
}
Matriks
Matriks adalah data yang disajikan dalam bentuk dua dimensi, dalam bentuk tabel yang terdiri dari
baris dan kolom. Terhadap sebuah matriks dapat dilakukan oprasi transpose. Terhadap dua
matriks yang berukuran sama dapat dilakukan operasi penjumlahan dan pengurangan. Terhadap
matriks yang berukuran n * m dapat dikalikan dengan matriks berukuran m* p sehingga
memberikan hasil berupa matriks berukuran n * p.
 Transpose matriks
struct tmatriks {
int baris, kolom;
int isi [10][10];
} ;
struct tmatriks transposematriks(struct tmatriks m1) {
Algo Mat 10
struct tmatriks m2;
int i, j;
m2.baris= m1.kolom;
m2.kolom= m1.baris;
for (i= 0; i< m2. baris; i++)
for (j= 0; j< m2.kolom; j++)
m2.isi[i][j]= m1.isi[j][i];
return m2;
}
 Penjumlahan matriks
int jumlahmatriks(struct tmatriks m1, struct tmatriks m2,
struct tmatriks * m3 ) {
int i, j, k;
if (m1.baris!= m2.baris || m1.kolom!=m2.kolom) return 0;
m3->baris= m1.baris;
m3->kolom= m1.kolom;
for (i= 0; i< m1.baris; i++)
for (j= 0;j < m1.kolom; j++)
m3->isi[i][j] = m1.isi[i][j] + m2.isi[i][j];
return 1;
}
Dua matriks dapat dikalikan apabila ukuran kolom matriks pertama sama dengan ukuran baris
matriks kedua. Matriks hasil perkalian berukuran baris sebesar baris matriks pertama dan kolom
sebesar kolom matriks kedua.
 Perkalian matriks
int kalimatriks(struct tmatriks m1, struct tmatriks m2,
struct tmatriks * m3 ) {
int i, j, k;
if (m1.kolom!= m2.baris) return 0;
m3->baris= m1.baris;
m3->kolom= m2.kolom;
for (i= 0; i< m1.baris; i++)
for (j= 0;j < m2.kolom; j++) {
m3->isi[i][j]= 0;
for (k=0; k< m1.kolom; k++)
m3->isi[i][j] += m1.isi[i][k] * m2.isi[k][j];
Algo Mat 11
}
return 1;
}
Eliminasi Gauss
Eliminasi Gauss digunakan untuk menyelesaikan sistem persamaan linier yang terdiri dari n
persamaan dengan n peubah.
a11x1 + a12x2 + … + a1nxn = b1
a21x1 + a22x2 + … + a2nxn = b2
a31x1 + a32x2 + … + a3nxn = b3
…
an1x1 + an2x2 + … + annxn = bn
Persamaan linier ini dapat ditulis dalam bentuk perkalian matriks
a11
a12
…
A1n
x1
b1
a21
a22
…
A2n
x2
b2
a31
a32
…
A3n
x3
…
…
…
…
…
…
an1
an2
…
ann
xn
bn
=
b3
Misalkan persamaan linier:
x1 – 2 x2 + 3 x3 = 11
3 x1 + x2 + 2 x3 = 19
- x1 + 2 x2 + x3 = 9
ditulis dalam bentuk perkalian matriks menjadi:
[
1
-2
3
3
1
2
-1
2
1
] [ ]
X1
X2
[ ]
11
=
X3
19
9
Solusi persamaan linier ini tidak akan berubah apabila:
- persamaan saling dipertukarkan letaknya
- nama variabel diganti
- mengalikan suatu persamaan dengan suatu konstanta
Algo Mat 12
-
menjumlahkan dua persamaan dan menggantikan salah satu persamaan semula
dengan persamaan hasil penjumlahan
Terhadap persamaan linier di atas pabila persamaan kedua diganti dengan hasil
penjumlahan persamaan kedua dan minus tiga kali persamaan pertama maka diperoleh
[
1
-2
3
0
7
-7
-1
2
1
] [ ]
X1
X2
[ ]
11
=
X3
-14
9
Apabila persamaan ketiga digantikan dengan hasil penjumlahan persamaan pertama dan
ketiga maka diperoleh:
[
1
-2
3
0
7
-7
0
0
4
] [ ]
X1
X2
[ ]
11
=
X3
-14
20
Matriks ini menunjukkan 4 x 3 = 20 , sehingga diperoleh x 3 = 5
Nilai x 3 ini apabila disubstitusikan ke dalam persamaan kedua yang berupa 7 x 2 – 7 x 3 = 14 akan memberikan hasil x 2 = 3. Nilai x 2 dan x 3 ini apabila disubstitusikan ke dalam
persamaan pertama akan memberikan nilai x 1 = 2.
Pencarian nilai peubah dibagi menjadi dua tahap:
1) forward elimination atau triangulation, mengubah persamaan semula berulang-ulang
sampai semua elemen di bawah diagonal utama bernilai nol.
2) backward substitution, nilai peubah yang didapatkan pada tahap pertama disubstitusikan
ke dalam matriks yang dihasilkan pada tahap pertama
void eliminate(int a[][10], int n) {
int i, j, k, max;
float t;
for (i=1; i<=n; i++) {
max= i;
for (j= i+1; j<= n; j++)
if(abs(a[j][i]) > abs(a[max][i])) max= j;
for (k= i; k<= n+1; k++) {
t= a[i][k];
a[i][k]= a[max][k];
a[max][k]= t;
Algo Mat 13
}
for (j=i+1; j<=n; j++)
for (k=n+1; k>=i; k--)
a[j][k]-= a[i][k]*a[j][i]/a[i][i];
}
}
void substitute(int a[][10],int x[],int n){
int j, k;
float t;
for(j=n; j>= 1; j--) {
t= 0.0;
for(k=j+1; k<=n; k++) t += a[j][k] * x[k];
x[j]= (a[j][n+1]-t) / a[j][j];
}
}
Algo Mat 14

Download Report