Docstoc
EXCLUSIVE OFFER FOR DOCSTOC USERS
Try the all-new QuickBooks Online for FREE.  No credit card required.

Praktikum Algoritma dan pemograman

Document Sample
Praktikum Algoritma dan pemograman Powered By Docstoc
					        PRAKTIKUM
ALGORITMA DAN PEMOGRAMAN II




                 PERTEMUAN II
                   REKURSIF


          NAMA        : Muhammad Zaien
          NIM         : J1F111016
          ASISTEN I   : Muhammad Shaufi
          ASISTEN II : Oky Rahmanto




       PROGRAM STUDI S-1 ILMU KOMPUTER
FAKULTAS MATEMATIKA DAN ILMU PENGETAHUAN ALAM
       UNIVERSITAS LAMBUNG MANGKURAT
                   BANJARBARU

                        2012
                              PERTEMUAN II

                                 REKURSIF

1. Tinjauan Pustaka
     Rekursif adalah salah satu teknik pemograman dengan cara memanggi sebuah
 fungsi atau procedure dari dirinya sendiri, baik itu secara langsung atau tidak
 langsung. Pemanggilan fungsi rekursif secara langsung berarti dalam fungsi
 tersebut terdapat statement untuk memanggil dirinya sendiri sedangkan secara
 tidak langsung berati fungsi rekursif memanggil 1 atau lebih fungsi lain sebelum
 memanggil dirinya sendiri (Endra, 2008).
     Singkatnya rekursif adalah sub program yang memanggil dirinya sendiri
 selama kondisi pemanggilan dipenuhi. Sub program rekursif harus memiliki :
          1. Kondisi yang menyebabkan pemanggilan dirinya sendiri berhenti.
          2. Pemanggilan sub program.
     (Mustofa, 2008)
     Rekursif tidak selalu lebih jelek daripada iteratif . Ada kalanya sebuah fungsi
 rekursif justru mempermudah penyelesaian masalah yang ditemui pada kasus
 iteratif (pengulangan) Kelemahan pada proses rekursif antar lain, memerlukan
 tempat penampungan stack yang cukup besar. Karena setiap kali pemanggilan
 fungsi , register – register seperti cs ( untuk memory far ) dan ip harus disimpan ,
 belum lagi untuk penanganan local variable serta parameter fungsi yang tentunya
 membutuhkan ruang untuk stack lebih banyak lagi. Selain itu karena setiap
 pemanggilan fungsi , register dan memory harus di push ke stack maka setelah
 selesai pemanggilan perlu diadakannya pop stack untuk mengembalikan memory
 dan register kembali ke keadaan awal , ini sering disebut sebagai overhead (Endra,
 2008).
     Secara umum bentuk dari sub program rekursif memiliki statemen
 kondisional :
     if kondisi khusus tak dipenuhi
     then panggil diri-sendiri dengan parameter yang sesuai
     else lakukan instruksi yang akan dieksekusi bila kondisi khusus dipenuhi
      Sub program rekursif umumnya dipakai untuk permasalahan yang memiliki
  langkah penyelesaian yang terpola atau langkah-langkah yang teratur. Bila kita
  memiliki suatu permasalahan dan kita mengetahui algoritma penyelesaiannya,
  kadang-kadang sub program rekursif menjadi pilihan kita bila memang
  memungkinkan untuk dipergunakan. Secara algoritmis (dari segi algoritma, yaitu
  bila kita mempertimbangkan penggunaan memori, waktu eksekusi sub program)
  sub program rekursif sering bersifat tidak efisien . (Mustofa, 2008)


2. Deskripsi Program
      Program yang saya buat adalah program konversi bilangan yaitu program
  konversi   bilangan-bilangan    Biner,Oktal,Desimal,dan     Hexadesimal.    Ketika
  pertama dijalankan program akan menampilkan tabel pengisian bilangan dan
  pilihan untuk bilangan asal yang akan dikonversikan. Ketika sudah dipilih
  bilangan asal untuk dikonversi pointer beralih ke tabel bilangan yang dipilih misal
  biner maka pointer akan ke tabel pengisian biner. Kemudian inputkan bilangan
  biner, maka program akan mengonversi ke bilangan desimal kemudian ke oktal,
  dan hexadesimal. Begitu juga ketika di inputkan bilangan oktal atau hexadesimal
  program terlebih dahulu mengonversi ke desimal baru ke bilangan lainnya dan
  menampilkan hasil konversi.


3. Source Code
program konversi_bilangan;
uses crt;
procedure pangkat (a,b:integer;var h:integer);
var i:byte;
begin
     if b=0 then
        h:=1
     else
     begin
          h:=1;
          for i:=1 to b do
               h:=h*a;
     end;
end;
procedure destobin (a:integer);
var
   b,c:string;
   m,d:integer;
begin
    c:='';
    d:=a;
    m:=d mod 2;
a:=d div 2;
    case m of
         0    : b:='0'; 1    : b:='1';
    end;
    if a > 0 then destobin (a);
    c:=c+b;
    write (c);
end;

procedure destook (a:integer);
var
   b,c:string;
   m,d:integer;
begin
    c:='';
    d:=a;
    m:=d mod 8;
    a:=d div 8;
    case m of
         0    : b:='0'; 1    :   b:='1';
         2    : b:='2'; 3    :   b:='3';
         4    : b:='4'; 5    :   b:='5';
         6    : b:='6'; 7    :   b:='7';
    end;
    if a > 0 then destook (a);
    c:=c+b;
    write (c);
end;

procedure destohex (a:integer);
var
   b,c:string;
   m,d:integer;
begin
    c:='';
    d:=a;
    m:=d mod 16;
    a:=d div 16;
    case m of
         0    : b:='0'; 1     : b:='1';
         2    : b:='2'; 3     : b:='3';
         4    : b:='4'; 5     : b:='5';
         6    : b:='6'; 7     : b:='7';
         8    : b:='8'; 9     : b:='9';
         10   : b:='A'; 11    : b:='B';
         12   : b:='C'; 13    : b:='D';
         14   : b:='E'; 15    : b:='F';
    end;
    if a > 0 then destohex (a);
    c:=c+b;
    write (c);
end;
procedure bintodes (a:string;f:byte;var d:integer);
var
   b,c,e:integer;
begin
     b:=length (a);
     case a[b] of
          '0' : c:=0;
          '1' : c:=1;
          else
               begin
                    writeln;
                    writeln (' YANG ANDA INPUT BUKAN BILANGAN BINER !');
                    d:=0;
                    exit;
               end;
     end;
     pangkat (2,f,e);
     f:=f+1;
delete (a,b,1);
     d:=d+(c*e);
     if b >1 then   bintodes (a,f,d);
end;

procedure oktodes (a:string;f:byte;var d:integer);
var
   b,c,e:integer;
begin
     b:=length (a);
     case a[b] of
          '0' : c:=0; '1' : c:=1;
          '2' : c:=2; '3' : c:=3;
          '4' : c:=4; '5' : c:=5;
          '6' : c:=6; '7' : c:=7;
          else
              begin
                    writeln;
                    writeln (' YANG ANDA INPUT BUKAN BILANGAN OKTAL !');
                    d:=0;
                    exit;
              end;
     end;
     pangkat (8,f,e);
     f:=f+1;
     delete (a,b,1);
     d:=d+(c*e);
     if b >1 then    oktodes (a,f,d);
end;

procedure hextodes (a:string;f:byte;var d:integer);
var
   b,c,e:integer;
begin
     b:=length (a);
     case a[b] of
          '0' : c:=0; '1' : c:=1;
          '2' : c:=2; '3' : c:=3;
          '4' : c:=4; '5' : c:=5;
          '6' : c:=6; '7' : c:=7;
          '8' : c:=8; '9' : c:=9;
          'A' : c:=10; 'a' : c:=10;
          'B' : c:=11; 'b' : c:=11;
          'C' : c:=12; 'c' : c:=12;
          'D' : c:=13; 'd' : c:=13;
          'E' : c:=14; 'e' : c:=14;
          'F' : c:=15; 'f' : c:=15
          else
              begin
                    writeln;
                    writeln (' YANG ANDA INPUT BUKAN BILANGAN HEXADESIMAL
!');
                    d:=0;
                    exit;
              end;
     end;
     pangkat (16,f,e);
     f:=f+1;
     delete (a,b,1);
     d:=d+(c*e);
     if b >1 then    hextodes (a,f,d);
end;
var
   a:integer;
   c:string;
   f,p:byte;
begin
     repeat
           clrscr;
           f:=0;a:=0;
           writeln;
           writeln (' --------------------------------------------------
-------------');
           writeln (' |         Biner      |     Oktal     | Desimal  |
Hexadesimal |');
           writeln (' --------------------------------------------------
-------------');
           writeln (' |                    |               |          |
|');
           writeln (' --------------------------------------------------
-------------');
           writeln;
           writeln (' Bilangan Asal ');
           writeln;
           writeln ('     1. Biner ');
           writeln ('     2. Oktal ');
           writeln ('     3. Desimal ');
           writeln ('     4. Hexadesimal ');
           writeln ('     5. Exit');
           writeln;
           write (' Masukkan Pilihan : ');readln (p);
           case p of
                 1    : begin;
                               gotoxy (5,5);readln (c);
                               bintodes (c,f,a);
                               gotoxy (23,5);destook (a);
                               gotoxy (39,5);writeln (a);
                               gotoxy (53,5);destohex (a);
                               readkey;
                        end;
                 2    : begin
                               gotoxy (23,5);readln (c);
                               oktodes (c,f,a);
                               gotoxy (5,5); destobin (a);
                               gotoxy (39,5);writeln (a);
                               gotoxy (53,5);destohex (a);
                               readkey;
                        end;
                 3    : begin
                               gotoxy (39,5);readln (a);
                               gotoxy (5,5);destobin (a);
                               gotoxy (23,5);destook (a);
                               gotoxy (53,5);destohex (a);
                               readkey;
                        end;
                 4    : begin
                               gotoxy (53,5);readln (c);
                               hextodes (c,f,a);
                              gotoxy (5,5);destobin (a);
                               gotoxy (23,5);destook (a);
                               gotoxy (39,5);writeln (a);

                             readkey;
                      end;
             end;
       until p = 5;
end.
4. Alur Program


                                          Begin




                                        Writeln (‘
                                        Tabel dan
                                        pilihan’)
         F


             Y
                                        Readln (p)

     Case P
      Of 5
                     E                   Repeat

             N


                 N                         N                        N
     Case P                 Case P                     Case P              Case P
      Of 4                   Of 3                       Of 2                Of 1



             Y                    Y                             Y                  Y

                            Readln                     Readln             Readln
 Readln (c);
                             (a);                       (c);               (c);




 Hextodes                 Destobin                   Oktodes             Bintodes
  (c,f,a);                  (a);                     (c,f,a);             (c,f,a);




                                                     Procedure
  Destobin
                         Destook (a);                desimal to         Destook (a);
    (a);
                                                       biner




     D                       C                           B                  A
      D                  C                           B            A




                                                    Writeln     Writeln
   Destook (a);       Destohex (a)
                                                     (c);        (c);




    Writeln
     (c);                                       Destohex(a)   Destohex (a)




                  N              Until P
       E                                                                  F
                                  =5


                                            Y
                                     End.
5. Output
6. Kesimpulan
     Kesimpulan dari hasil praktikum ini adalah sebagai berikut :
        1. Rekursif adalah sub program yang memanggil dirinya sendiri.
        2. Rekursif memiliki dua syarat yaitu pertama kondisi dimana jika
            kondisi tidak terpenuhi maka pemanggilan dirinya sendiri dapat
            berhenti, kedua pemanggilan dirinya sendiri.
        3. Rekursif tidak selalu lebih baik dari iteratif atau perulangan karena
            rekursif lebih banyak memakan memory dan tidak efisien di bagian
            algoritmis. Tapi kadang ada permasalah yang hanya dapat
            diselesaikan dengan metode rekursif.
                            DAFTAR PUSTAKA

Endra, Enzie. Rekursif. 16 November 2008.
       http://enzieblack.blogspot.com/2008/11/reekkuurrssiiff.html (diakses April
       23, 2012).
Mustofa, Khabi. Prosedure dan Fungsi Rekursif. 2008.
       http://www.khabib.staff.ugm.ac.id/index.php?option=com_content&task=vie
       w&id=82&Itemid=33 (diakses April 23, 2012).

				
DOCUMENT INFO
Shared By:
Stats:
views:161
posted:5/13/2012
language:
pages:10
Description: berisi laporan praktikum algoritma dan pemograman dengan bahasa pascal