Rekursif dalam Algoritma Pemrograman

Bentuk rekursi merupakan alternatif bentuk iterasi atau perulanga. perulangan rekursif merupakan salah satu metode didalam pemrograman yang mana dalam sebuah fungsi terdapat instruksi yang memanggil fungsi itu sendiri.

notasi :

//judul     : fungsi rekursif
//kamus     : nilai1,nilai2,hasil<--integer
             function tambah(angka1<--integer,angka2<--integer)
                                                     <--integer
//deskripsi :
               nilai1 <-- input 4
               nilai2<--input 2
               hasil<-- tambah(nilai1,nilai2)
               output--> hasil 
 //output akan mengeluarkan 6
           function tambah(angka1<--integer,angka2<--integer)
                                                   <--integer 
           {
                if(angka1==0)
                {
                   return angka2
                }
                else
                {
                  return 1+tambah(angka1-1,angka2)
                }
          }

proses penambahannya adalah sebai berikut:

tambah(4,2)
1+tambah(3,2)
1+1+tambah(2,2)
1+1+1+tambah(1,2)//angka1 berkurang karena ada perintah memanggil fungsi dirinya sendiri dengan kondisi bahwa angka1 di kurang 1.
1+1+1+((tambah(0,2)//karena angka1 sudah menjadi 0 maka tambah mengembalikan nilai 2 dengan demikian menjadi :
1+1+1+1+2=6

contoh dalam bahasa C :

#include <stdlib.h>
#include <stdio.h>
///judul : fungsi rekursif tambah
///kamus :
           int hasil,nilai1,nilai2;
           int tambah(int angka1,int angka2);

///deskripsi :
int main()
{
    nilai1=4;
    nilai2=2;
    hasil=tambah(nilai1,nilai2);
    printf("%d",hasil);
}

///fungsi 
int tambah(int angka1,int angka2)
{
if(angka1==0)
    {
       printf("%d=",angka2);
       return angka2;
    }
else
    {
       printf("1+");
       return 1+tambah(angka1-1,angka2);
    }
}

jika program di jalankan :
tambah_program_blog

contoh berikutnya dalam penggunaan rekursif adalah pada faktorial :
notasi :

///judul     :     fakrorial dalam algoritma rekursif
///kamus     :     angka,hasil<--integer
                   function faktorial(nilai<--integer)<--integer 
///deskripsi :
             angka<--input (4) 
             hasil<--faktorial(angka) 

///function :
                  function faktorial(nilai<--integer)<--integer 
                  {
                     if(nilai==1)
                       {
                          return nilai  
                       }
                    else 
                       {
                          return nilai*faktorial(nilai-1) 
                       }
                  }

prosesnya adalah sebai berikut:

faktorial(4) //fungsi di isi nilai 4
4*faktorial(4-1) ///masuk kedalam pilihan else karena nilai tidak 1 maka mengulan fungsi tapi nilai 4 di kurang 1
4*3*faktorial(3-1)
4*3*2*faktorial(2-1) karena faktorial(2-1) sama artinya faktorial(1) maka akan masuk if bukan else.
4*3*2*1=24

berikut contoh program dalam bahasa C :

#include <stdio.h>
#include <stdlib.h> 

///judul :  faktorial rekrsif
///kamus :
                 int batas;
                 int faktorial(int nilai);
                 int hasil;

///deskripsi :

int main()
{
   batas=4;///batas di input nilai 4
   hasil=faktorial(batas); ///fungsi akan berhenti dan measukan hasilnya
                              kedalam variabel hasil
   printf("%d",hasil);
}

int faktorial(int nilai)
{
  if(nilai==1)
    {
      printf("%d=",nilai);
      return nilai;
    }
else
    {///jika nilai tidak 1 maka akan masuk kedalam else 
     printf("%d*",nilai);
      return nilai*faktorial(nilai-1);
    }


}

jika di jalan kan program agan seperti berikut :
rekursif_program_blog

penggunaan rekursif dalam perkalian :

notasi :

///judul : perkalian 
///kamus : hasil,angka1,angka2<--integer 
           function perkalian(nilai1<--integer,nilai2<--integer)
            <--integer 
///deskripsi : 
          angka1<--input 5
          angka2<--input 7
          hasil<--perkalian(angka1,angka2)
          output hasil

///fungsi 
function perkalian(nilai1<--integer,nilai2<--integer)<--
integer 
{
   if(niali2==1)
   {
    return nilai1 
   }
    else 
   {
      return nilai1+perkalian(nilai1,nilai2-1)
   }

aplikasikan kedalam program , bahasa C:

#include <stdio.h>
#include <stdlib.h>

///judul : perkalian rekursif
///kamus :
           int hasil,angka1,angka2;
           int perkalian(int nilai1,int nilai2);
///deskripsi :
 int main()
 {
    angka1=5;
    angka2=7;
    printf("5*7=\n");
    printf("proses perkalian nya adalah \n");
    hasil=perkalian(angka1,angka2);
    printf("%d",hasil);
    printf("hasil perkalian %d*%d=%d\n",angka1,angka2,hasil);



 }
///fungsi

 int perkalian(int nilai1,int nilai2)
 {
     if(nilai2==1)
     {
      printf("%d=",nilai1);
      return nilai1;
     }
       else
     {
       printf("%d+",nilai1);
       return nilai1+perkalian(nilai1,nilai2-1);
     }
 }

hasil setelah program dijalankan :
rekursif-kali

Searching dalam algoritma pemrograman

searching adalah proses pencarian data tertentu didalam sekumpulan data yang bertipe sama dengan cara memberikan data yang bernilai sama dengan data yang ingin di cari di dalam sekumpulan data tersebut. contoh:

ada variable array yang berisi 1 2 3 4 5 6 misalkan ingin mencari nilai 5 didalam array tersebut maka harus memberikian petunjuk atau nilai yang sama agar di bandingkan dengan nilai yang berisi di dalam array. pada metode searching ada 2 teknik yang digunakan yaitu : pencarian sekuensial (sequential search) dan pencarian biner (binary search).

  1. pencarian sekuensial (sequential search)
    pencarian skuensial (squential search) atau sering disebut pencarian linier menggunaka prinsip sebagai berikut :
    data yang di bandingkan satu persatu secara berurutan dengan yang dicari. pada dasarnya, pencarian ini hanya melakukan pengulangn dari 1 sampai jumlah data. jika nilai yang di cari dan salah satu nilai yang berada di dalam sekumpulan data sama maka di temukan. sebaliknya apabila perulangan sampai pada akhir maka berarti tidak di temukan.

notasi :

//Judul :      sequential search
//kamus :      p1<--integer
               data[1....7]={4,2,3,8,9,1,5} array of integer
               nilai_dicari<--integer
               ketemu<--integer
//deskripsi :
               p1<--1
               nilai_dicari<--input //anggap nilai_dicari di isi nilai 5
               
               while(p1<=7)
               {
                  if(data[p1]==nilai_dicari)
                     {
                         output data[p1]
                         ketemu=ketemu+1:
                         break;
                     }
                 p1=p1+1
               }


               if(ketemu==0) //berfungsi untuk mengkonfirmasi 
                              bahawa nilai yang di cari tidak 
                              terdapat di dalam data 
                              dengan mengkonvirmasi 
                              ketemu yang masih kosong atau 0
               {
               output "data tidak di temukan"
               }
               eles
               {
               ketemu=0
               }

contoh di aplikasikan dalam program bahasa C :

#include <stdio.h>
#include <stdlib.h>
///judul :     squential search
///kamus :
               int p1;
               int data[7]={4,2,3,8,9,1,5};
               int nilai_dicari;
               int ketemu;
///deskripsi :
int main()
{
          ketemu=0;
          p1=0;
          printf("array bertipe int data[7]={4,2,3,8,9,1,5}\n");
          printf("jika di uraikan seperti berikut :\n");
          while(p1<=7-1)
          {
              printf("data[%d]=%d\n",p1,data[p1]);
              p1=p1+1;
          }
             printf("\n");
          p1=0;
          nilai_dicari=5;
          printf("nilai yang dicari %d\n",nilai_dicari);

              while(p1<=7-1)///data sebanyak 7 tapi array di mulai dari 0
              {
                  if(data[p1]==nilai_dicari)///jika dat ake 
                                       index P1 sama dengan
                                       nilai di dalam
                                       variabel nilai_cari maka
                       {
                         printf("data ketemu di index %d yang bernilai
                         %d\n",p1,data[p1]);
                         ketemu=ketemu+1;
                         break;///untuk keluar dari perulangan dan 
                                 menjalan kan prosedur selanjutnya
                       }
                 p1=p1+1;
             }

                if(ketemu=0)
                {
                    printf("data tidak di temukan");
                }
                  else
                {
                  p1=0;
                  ketemu=0;
                }

}

hasil setalah program di jalankan

squential-search

2. pencarian biner (binary search)
salah satu syarat binary search dapat dilakukan adalah data sudah dalam keadaan terurut. dengan kata lain, apabila data belum terurut, pencarian biner tidak dapat dilakukan.

mula-mula diambil dari posisi awal=1 dan posisi akhir =n.kemudian kita cari posisi data tengah dengan rumus posisi tengah = posisi awal+posisi akhir) div 2, kemudian data yang di cari dibandingkan dengan data tengah. jika sama, data ditemukan, proses selesai. jika lebih kecil, proses dilakukan kembali tetapi posisi awal dianggap sama dengan posisi tengah -1. jika lebih besar, proses dilakukan kembali tetapi posisi awal dianggap sama dengan posisi tengah +1.

//notasi :

//judul :     binery search
//kamus :     awal,akhir,tengah,cari<--integer
              data[1...7]={1,2,3,4,5,6,7}  array of integer
              ketemu<--integer
//deskripsi
              cari<-- input
              awal<--1
              akhir<--7-1
                   while(awal<=akhir)
                   {
                      tengah=(awal+akhir)/2 
                            if(data[tengah]==cari)
                            {
                            output data[tengah]
                            ketemu=ketemu+1
                            break;
                            }
                            else if(cari< data[tengah])                          
                            {
                            akhir=tengah-1
                            }
                            else
                            {
                            awal=tengah+1
                            }
                   }
           if(ketemu==0)
            {
            output "data tidak ada" 
            }
            else
            {
            ketemu=0;
            }

contoh di aplikasi kan dalam program bahasa C :

#include <stdio.h>
#include <stdlib.h>
///judul      : binery search
///kamus      :
                int ketemu,awal,akhir,tengah,cari;
                int data[7]={1,2,3,4,5,6,7};
                int p1;
///desktripsi :
int main()
{
   cari=1;
   awal=0;
   akhir=7-1;
   printf("nilai yang di cari adalah %d\n",cari);
   printf("dari array data[7]={1,2,3,4,5,6,7};\n");
   printf("berikut tahapan program dalam mencari nilai :\n\n");
       while(awal<=akhir)
       {
         for(p1=awal;p1<akhir+1;p1++)///hanya untuk output bukan biner 
                                         search inti
             { 
                 printf("%d",data[p1]);
             }
         printf("\n");

         tengah=(awal+akhir)/2;
         if(data[tengah]==cari)
         {
            printf("\nketemu di index %d = %d\n",tengah,data[tengah]);
            ketemu=ketemu+1;
            break;
         }
         else if(cari<data[tengah])
         {
            akhir=tengah-1;
         }
         else
         {
         awal=tengah+1;
         }
       }

     if(ketemu==0)
     {
       printf("data tidak ada");
     }
     else
     {
       ketemu=0;
     }
}

hasil setalah program di jalankan :

binery-search

 

Sorting dalam Algoritma Pemrograman

Sorting dalam algoritma pemrograman merupakan proses pengurutan sekumpulan data dalam suatu urutan tertentu. Sorting dipakai untuk:

  1. Membantu proses pencarian (searching).
  2. Menyelesaikan masalah-masalah kompleks seperti penjadwalan, pengolahan basis data, riset operasi, dsb.

didalam sorting memerlukan algoritma pertukaran nilai yaitu :

//judul     :    menukar nilai variable
//kamus     :    nilai1,nilai2,tampung <-- integer
//deskripsi :
               nilai1<--1
               nilai2<--2
               tampung<--0

//pertukaran
              tampung<--nilai1  ///tampung di isi nilai1==1,jadi 
                                   tampung bernilai 1
              nilai1<--nilai2   ///nilai1 di isi nilai2==2,jadi 
                                   nilai1 bernilai 2
              nilai2<--tampung  ///nilai2 di isi tampung==1, jadi 
                                   nilai 2 bernilai 1

Jenis-Jenis Sorting
1.bubble sort
bubble sort adalah metode pengururan dengan cara membandingkan data dan menukar data dengan tepat disebelahnya secara terus menerus sampai dipastikan data tidak ada lagi perubahan.

notasi :

///Judul :  metode bubble sort
///kamus :
               data[1...7]={4,2,3,1,2,5,7} array of integer // artinya    
                                          bahwa data ke 1=4,
                                                ata ke 2=2,
                                                data ke 3=3,
                                                data ke 4=1,
                                                data ke 5=2,
                                                data ke 6=5, 
                                                dan data ke 7=7
           p1,p2<--integer //merupakan variable untuk perulangan
           p3<--integer //variable yang bernilai p2+1
           tem<--integer //untuk menampung nilai sementara
deskripsi :  
              tem=0
              p1<--1
              while(p1<=7)  //artinya selama p1 kurang atau sama 
                              dengan 7 maka perintah di dalam akan 
                              terus di ulang.
           {
                  p2=1 // setiap p1+1, p2 akan kembali ke nilai 1 
                       karena p2 berada di dalam perulangan p1. 
                       jika terdapat perulangan di dalam perulangan 
                       maka perulangan yang di dalam akan di 
                       kerjakan terlebih dahulu baru kemudian 
                       perulangan yang di luar.
             while(p2<=7-1)
                 {
                 p3=p2+1
                 if(data[p2]>data[p3]) //untuk (A-Z) maka tanda 
                                       <,untuk (Z-A) maka tanda >.
                       {
                       //prosedur pertukatan nilai
                       tem=data[p2]
                       data[p2]=data[p3]
                       data[p3]=tem
                       }
                   p2=p2+1
               }
             p1=p1+1
           }

langka perlangka dalam bubble sort adalah sebagai berikut :

4,2,3,1,2,5,7  data awal

2,3,1,2,4,5,7
adalah urutan  data ketika perulang p1 = 1
data ke p2 terus di bandingkan dengan data ke p3=p2+1, dan terus melakukan pertukaran nilai jika keadaan nilai terpenuhi yaitu if(data[p2]>data[p3]) sempai p2 melewati syarat perulang (p2<=7-1) dan di bandingkan dengan p3. setiap data ke p2>p3 maka akan  di lakukan perukaran nilai.

2,1,2,3,4,5,7
adalah urutan  data ketika perulang p1 = 2 p2 kembali ke keadaan p2=1 dan melakukan perulang kembali.

1,2,2,3,4,5,7
adalah urutan data ketika perulangan p1=3 walau pun data sudah terurut p1 dan p2 tetap melakukan perulangan sampai p1 melewati syarat perulangan yaitu p1<=7

notasi di aplikasikan dalam program bahasa C :

#include <stdio.h>
#include <stdlib.h>
///judul : bubble sort
///kamus : 
           int data[7]={4,3,4,1,2,5};
           int p1,p2,p3;
           int tem;
           int output;

//deskripsi : 

int main()
{
    tem=0;
    p1=0;
    printf("data awal \n");
    for(output=0;output<7;output++)
    {
    printf("%d",data[output]);
    }
         printf("\n");
    while(p1<7)
    {
      p2=0;
         while(p2<7-1)
         {
           p3=p2+1;
           if(data[p2]>data[p3]) 
           {
              tem=data[p2];
              data[p2]=data[p3];
              data[p3]=tem;
           }
         p2++;
        }
          printf("data setelah perulangan p1=%d-->",p1); 
          for(output=0;output<7;output++)
          {
            printf("%d",data[output]);
          }
       printf("\n");
      p1++;
    }

}

hasil program setelah di jalankan:

bubble-sort

2. selection sort
selection sort merupakan perbaikan dari metode bubble sort dengan mengurangi jumalh perbandingan. selection sort merupakan metode pengurutan dengan mencari nilai data terkecil dan nilai data terbesar dimulai dari data di posisi 1 hingga di posisi  n-1.

Notasi :

//Judul :  selection sort 
//Kamus :  p1,p2<--integer
           tem<--integer
           data[1...7]={4,2,3,1,2,5,7} array of integer

//deskripsi :
              tem<--0
              p1<--1
              while(p1<=7-1)
              {
              p2<--p1+1
                      while(p2<=7)
                      {
                          if(data[p1]>data[p2]) // untuk (A-Z) maka tanda 
                                             <,untuk (Z-A) maka tanda >.
                          {
                             //pertukatan nilai
                             tem=data[p1]
                             data[p1]=data[p2]
                             data[p2]=tem
                          }
                         p2=p2+1
                      }
               p1=p1+1
               }

langkah-perlangkah dalam selection sort adalah sebagai berikut :

4,2,3,1,2,5,7  data awal

1,4,3,2,2,5,7 adalah hasil setelah perulang p1=1

data p1 dan p2 di bandingkan sehingga  nilai 4 yang awalnya berada di data[1] dan data[2] bertukar karena memenuhi syarat if, maka data [1] =2. kemudian perulangan berjalan kembali dan membandingkan data [1] sampai perulangan p2 berhenti. pada saat data[p2=4] nilai bertukar kembali karena data[p1=1]=2 lebih besar data[p2=4]=1,shingga urutannya menjadi seperti di diatas.

1,2,4,3,2,5,7 adalah hasil setelah perulang p1=2

di mana perpindahan terjadi di data [p1=2] yang awalnya bernilai 4 ditukar dengan data [p2=3] yang bernilai 3 dan data p1 berisi  nilai 3, kemudian perulang p2 berjalan kembali, karena data [p1] yang berisi nilai 3 lebih besar dengan data[p2=4] yang bernilai 2 maka terjadi kembali pertukaran nilai.

1,2,2,4,3,5,7 adalah hasil setelah perulang p1=3

data[p1=3] yang berisi nilai 4 ternyata lebih besar dari data[p2=4] yang berisi nilai 3 maka di lakukan pertukaran nilai dan melanjutkan perulangan. setelah itu data[p1=3] yang berisi 3 ternya lebih besar nilainya di banding nilai yang berada di dalam data[p2=5] yang bernilai 2 maka nilai di tukar. sehingga seperti di atas.

1,2,2,3,4,5,7 adalah hasi setelah perulang p1=4

data[p1=4] yang benilai 4 ternyata lebih besar dari data[p1=5] yang bernilai 3 maka nilai di tukar.

nilai tidak berubah samapi p1=7-1 atau 6 karena nilai sudah tidak memenuhi persyaratan if,yaitu jika data[p1]>data[p2] maka di tukar.

notasi di aplikasikan dalam program bahasa C :

 #include <stdio.h>
#include <stdlib.h>

///judul : selection sort
///kamus :
           int p1,p2;
           int tem;
           int data[7]={4,2,3,1,2,5,7};
           int output;

///deskripsi :
int main()
{

       tem=0;
       p1=0;
       printf("data awal \n");
       for(output=0;output<7;output++)
       {
         printf(" %d ",data[output]);
       }
      printf("\n\n");
        while(p1<7-1)
         {
           p2=p1+1;
            while(p2<7)
              {
                 if(data[p1]>data[p2])
                   {
                   //pertukatan nilai
               printf("data[%d]=%d ditukar dengan   
               data[%d]=%d\n",p1,data[p1],p2,data[p2]);

              tem=data[p1];
              data[p1]=data[p2];
              data[p2]=tem;
                      for(output=0;output<7;output++)
                      {
                       printf(" %d ",data[output]);
                       }
              printf("\n");
                 }
             p2++;
            }
            for(output=0;output<7;output++)
            {
            printf(" %d ",data[output]);
            }
            printf("\n");
         p1++;
       }
}

hasil setelah program di jalankan :
selection-sort

 

Pointer dalam algoritma pemrograman

Pointer adalah penunjuk dari alamat dari sebuah variabel di dalam memory. alamat ini merupakan lokasi dari obyek lain (biasanya bariabel lain) di dalam memori. jika sebuah variabel berisi alamat dari variabel lain, variabel pertama dikatakan menunjuk ke variabel kedua. sebagai contoh variabel px adalah pointer dan x adalah bariabel yang ditunjuk oleh px. jika x memiliki alamat memori af1234 maka px akan berisi af1234.

suatu variabel pointer dideklarasikan dengan bentuk sebagai berikut :
*nama_variabel<–tipe data
contoh :
*px<–integer
*pch<–string

agar suatu pointer menunjuk ke bariabel lain, mula-mula pointer harus diisi dengan alamat dari variabel yang akan ditunjuk. untuk menyatakan alamat dari suatu bariabel, operator & bisa dipergunakan dengan cara menempatkan operator di depan nama variabel. contoh :

&x

berarti “alamat dari variabel x”. adapun contoh pemberian alamat ke suatu bariabel pointer px (yang dideklarasikan sebagai pointer yang menunjuk ke data bertipe int) yaitu

px=&x

pernyataan di atas berarti bahwa px diberi nilai berupa alamat dari bariabel x. setelah pernyataan tersebut dieksekusi barulah dapat dikatakan bahwa px menunjuk ke variabel x.

kalau suatu variabel sudah ditunjuk oleh pointer, variabel yang ditunjuk oleh pointer dapat diakses melalui variabel itu sendiri(dikatakan sebagai pengaksesan langsung) ataupun melalui pointer(dikatakan sebagai pengaksesan tak langsung). pengaksesan tak langsung dilakukan dengan menggunakan operator indirection (tak-langsung), berupa simbol * . conth penerapan operator * yaitu

*px

yang menyatakan isi atau nilai bariabel/data yang di tunjuk oleh pointer px*. sebagai contoh jika y bertipe int, maka sesudah dua pernyataan berikut

px=&x
y=*px

y akan berisi nilai yang sesuai dengan nilai x.

Notasi :

//judul :  pointer
//kamus :  x,y<--integer
           *px<--integer

//deskripsi :
             x=87 //mislakan alamat x=ffe0 
             px=&x  //isi px=ffe0 karena &x artinya menunjuka alamat
             y=*px 
//nilai yang ditunjuk oleh px=87 karena *px artinya menunjuk nilai didalam //px, sementara px menampung alamat sehingga *px mengakses nilai dari //alamat tersebut.
  
 ouput  y
 nilai y=87

notasi di aplikasikan kedalam program bahasa C :

#include <stdio.h>
#include <stdlib.h>
///judul : pointer
///kamus :
           int x,y;
           int *px;

///deskripsi :
int main(){
 x=87;

 printf("alamat x=%p\n",&x);
 px=&x;
 printf("isi px merupakan alamat x=%p\n",px);
 printf("yang berisi nilai x=%d\n",x);
 printf("nilai yang di tunjuk oleh px adalah =%d\n",*px);
 y=*px;
 printf("jika y=*p maka y berisi nilai yang di tunjuk oleh px yaitu     
        %d\n",*px);

}

jika program di jalankan :

pointer

Type Bentukan dalam Algoritma Pemrograman

Type bentukan adalah suatu TYPE yang diranancang/dibentuk (dan diberi nama) dari beberapa komponen bertype tertentu, jika merupakan sekumpulan elemen bertype dasar atau bertype yang sudah di kenal. sebuah type bentukan dituliskan dengan notasi :

 type namatype :< 
                  elemen1 <--type 
                  elemen2<--type
                > 

contoh  :

 Type jam <
            hh<--integer //variabel untuk jam
            mm<--integer //variabel untuk menit
            ss<--integer ////variabel untuk detik
          >

jika di deklarasikan nama varibel J sebagai berikut :J<–jam cara mengakses nilai elemen yang tersimpan pada J yang telah terdefinisi adalah :

J.hh //menghasilkan nilai bagian jam bertype integer [0..23]
J.mm //menghasilkan nilai bagian menit bertype integer[0…59]
J.ss //menghasilkan nilai bagian detik berype integer [0…59]

contoh notasi:

//judul : data diri 
//kamus :    type lahir : < 
                            tempat<--string
                            tanggal<--integer
                            bulan<--string
                            tahun<--integer
                          >
                            
             type data  : < 
                            nama<--string
                            ttl<--lahir
                            umur<--integer
                            alamat<--string
                            agama<--string
                          >

            orang<--data //artinya data merupakan type seperti                      
                           integer,string dan lain-lain.

/deskripsi :

 orang.nama<--input //misalnya "Joni"
       orang.ttl.tempat<--input "Jakarta"
       orang.ttl.tanggal<--input "23"
       orang.ttl.bulan<--input "januari"
       orang.ttl.tahun<--input "1998"

 orang.umur<--input //19
 orang.alamat<--input //"jl.mangga No.10"
 orang.agama<--input  //"Islam"


 orang.nama--> output "Joni"

          orang.ttl.tempat<--input "Jakarta"
          orang.ttl.tanggal<--input "23"
          orang.ttl.bulan<--input "januari"
          orang.ttl.tahun<--input "1998"

 orang.umur--> output 19
 orang.alamt-->output "jl.mangga No.10"
 orang.agama--> output "islam"

jika di aplikasikan kedalam program, disini akan menggunakan bahas C :

#include <stdio.h>
#include <stdlib.h>

typedef struct
{
       char tempat[50];
       int tanggal;
       char bulan[50];
       int tahun;
}lahir;


typedef struct
{
       char nama[50];
       lahir ttl;
       int umur;
       char alamat[50];
       char agama[50];
}data;



int main()
{
data orang;

///contoh inputan pada type bentukan

   strcpy(orang.nama,"joni");

   strcpy(orang.ttl.tempat,"Jakarta");
   orang.ttl.tanggal=23;
   strcpy(orang.ttl.bulan,"januari");
   orang.ttl.tahun=1998;

   orang.umur=19;
   strcpy(orang.alamat,"Jl.Manggis no 10");
   strcpy(orang.agama,"islam");

     printf("===========output type bentukan==========\n");
     printf("Nama : %s\n",orang.nama);
     printf("tempat dan tanggal lahir : %s,%d-%s-%d\n"
                                      ,orang.ttl.tempat,orang.ttl.tanggal,
                                       orang.ttl.bulan,orang.ttl.tahun);
printf("Umur : %d\n",orang.umur);
printf("Alamat : %s\n",orang.alamat);
printf("Agama : %s\n",orang.agama);


}

hasil program setelah di jalankan :

type_bentukan_blog

Algoritma dan Program

Program adalah kumpulan pernyataan komputer, sedangkan metode dan tahapan sistematis dalam program adalah algoritma. Program ditulis dengan menggunakan bahasa pemrograman. Jadi bisa disebut bahwa program adalah suatu implementasi dari bahasa pemrograman. Beberapa pakar memberi formula bahwa :

Program = Algoritma + Bahasa (Struktur Data)

Bagaimanapun juga struktur data dan algoritma berhubungan sangat erat pada sebuah program. Algoritma yang baik tanpa pemilihan struktur data yang tepat akan membuat program menjadi kurang baik, demikian juga sebaliknya.

Pembuatan algoritma mempunyai banyak keuntungan di antaranya :
Pembuatan atau penulisan algoritma tidak tergantung pada bahasa pemrograman manapun, artinya penulisan algoritma independen dari bahasa pemrograman dan komputer yang melaksanakannya.
Notasi algoritma dapat diterjemahkan ke dalam berbagai bahasa pemrograman.
Apapun bahasa pemrogramannya, output yang akan dikeluarkan sama karena algoritmanya sama.

Beberapa hal yang perlu diperhatikan dalam membuat algoritma :
Teks algoritma berisi deskripsi langkah-langkah penyelesaian masalah. Deskripsi tersebut dapat ditulis dalam notasi apapun asalkan mudah dimengerti dan dipahami.
Tidak ada notasi yang baku dalam penulisan teks algoritma seperti notasi bahasa pemrograman. Notasi yang digunakan dalam menulis algoritma disebut notasi algoritmik.
Setiap orang dapat membuat aturan penulisan dan notasi algoritmik sendiri. Hal ini dikarenakan teks algoritma tidak sama dengan teks program. Namun, supaya notasi algoritmik mudah ditranslasikan ke dalam notasi bahasa pemrograman tertentu, maka sebaiknya notasi algoritmik tersebut berkorespondensi dengan notasi bahasa pemrograman secara umum.
Notasi algoritmik bukan notasi bahasa pemrograman, karena itu pseudocode dalam notasi algoritmik tidak dapat dijalankan oleh komputer. Agar dapat dijalankan oleh komputer, pseudocode dalam notasi algoritmik harus ditranslasikan atau diterjemahkan ke dalam notasi bahasa pemrograman yang dipilih. Perlu diingat bahwa orang yang menulis program sangat terikat dalam aturan tata bahasanya dan spesifikasi mesin yang menjalannya.
Algoritma sebenarnya digunakan untuk membantu kita dalam mengkonversikan suatu permasalahan ke dalam bahasa pemrograman.
Algoritma merupakan hasil pemikiran konseptual, supaya dapat dilaksanakan oleh komputer, algoritma harus ditranslasikan ke dalam notasi bahasa pemrograman. Ada beberapa hal yang harus diperhatikan pada translasi tersebut, yaitu :

a. Pendeklarasian variabel

Untuk mengetahui dibutuhkannya pendeklarasian variabel dalam penggunaan bahasa pemrograman apabila tidak semua bahasa pemrograman membutuhkannya.

b. Pemilihan tipe data

Apabila bahasa pemrograman yang akan digunakan membutuhkan pendeklarasian variabel maka perlu hal ini dipertimbangkan pada saat pemilihan tipe data.

c. Pemakaian instruksi-instruksi

Beberapa instruksi mempunyai kegunaan yang sama tetapi masing-masing memiliki kelebihan dan kekurangan yang berbeda.

d. Aturan sintaksis

Pada saat menuliskan program kita terikat dengan aturan sintaksis dalam bahasa pemrograman yang akan digunakan.

e. Tampilan hasil

Pada saat membuat algoritma kita tidak memikirkan tampilan hasil yang akan disajikan. Hal-hal teknis ini diperhatikan ketika mengkonversikannya menjadi program.

f. Cara pengoperasian compiler atau interpreter.

Bahasa pemrograman yang digunakan termasuk dalam kelompok compiler atau interpreter.

Fungsi dan Prosedur dalam Algoritma Pemrograman

  1. fungsi
    Fungsi/function adalah cuplikan program atau pengelompokan instruksi berdasarkan kegunaanya atau kumpulan statement yang dikelompokan yang mempunyai maksud dan tujuan tertentu. dalam fungsi ada yang disebut denga parameter,parameter adalah data masukan untuk subprogram yang nantinya akan diproses lebih lanjut dalam subprogram tersebut. Parameter ada 2 yaitu :
  2. Parameter formal : variable yang ada pada daftar parameter dalam definisi fungsi dan dijelaskan typenya.
  3. Parameter aktual : varibale yang dipakai dalam pemanggilan fungsi dan dijelaskan typenya.berbeda dengan procedure yang bisa dengan tidak menggunakan parameter, fungsi harus menggunakan parameter dalam penggunaanya.contoh:

fungsi f(x) dengan satu parameter x dalam matematika yang didefinisikan sebagai f(x)=X2+3x-5
jika x=4 maka f(4)=42+3(4)-5=23
jika x= 1 maka f(1)=12+3(1)-5=-1

contoh notasi :

//judul :  menghitung funsi f(x)=x2+3x-5
//kamus :   //pertama deklarasikan nama dan tipe fungsi terlebih dahulu
           function menghitungf(x <--integer)<--
           integer
           angka<--integer
           jawab<--integer


//deskripsi :
            angka <--4
            menghitungf(nilai) //dimana nilai x 
                              diisi dengan nilai  
                              yang berada di dalam
                              angka yaitu 4 dan akan 
                              menjalan kan perintah 
                              yang ada difunction


 jawab<--menghitungf(nilai)  //merupakan parameter  
                               aktual .hasil dari   
                               fungsi mengitung akan 
                               di return atau di 
                               kembalikan ke dalam 
                               variabel jawab.
output--> jawab

//contoh function
function menghitungf(x <--integer)<--integer

{ 
   hasil <--integer //merupakan parameter formal
   hasil<--(x*x)+(3*x)-5
   return hasil 
}

//jika di jalan kan maka akan menjadi

x==nilai==4

hasil<–(4*4)+(3*4)-5
hasil=23 di return/di kembalikan ke dan di input ke jawab
di output di jawab =23

2. prosedur
prosedur adalah suatu program terpisah dalam blok sendiri yang berfungsi sebagai subprogram (program bagian). Diawali dengan kata cadangan “procedure” didalam bagian deklarasi prosedur. Procedure biasanya bersifat suatu aktifitas seperti mengitung,mencari,menampilkan dan sebagainya.

//contoh procedure

//procedure menghitungf(x <--integer)<--integer
{ 
        hasil <--integer //merupakan parameter  
                           formal ]
        hasil<--(x*x)+(3*x)-5
        hasil--> output 
}

//jika di jalan kan maka akan menjadi

x==nilai==4

hasil<–(4*4)+(3*4)-5
output –> hasil=23

contoh fungsi setelah di aplikasi kan dalam program.= program dalam bahasa C.

#include <stdio.h>
#include <stlib.h>
///judul     :  menghitung fungsi F(x)=x^2+3x-5
///kamus     :
                int menghitungf(int x);
                int angka;
                int jawab;
///deskripsi :
int main(){
angka=4;                  ///angka diberikan nilai 4
printf("fungsi menghitungf(angka=%d)\n",angka);
jawab=menghitungf(angka); /// nilai x didalam fungsi di masukan
                          /// nilai dari angka yaitu 4 kemudian akan mengerjakan
                          /// prosedur di dalam fungsi dan di return
                          /// ke dalam jawab
printf("hasil dari fungsi menghitungf adalah: %d\n",jawab);
}

///fungsi

int menghitungf(int x)
{
int hasil;///parameter formal
printf("niali x=%d\n",x);
printf("(x*x)+(3*x)-5\n");
hasil=(x*x)+(3*x)-5;
return hasil;
}


int main() di dalam program, merupakan contoh dari prosedur.

jika di jalan kan program akan seperti berikut :
fungsi_program_blog

1 lagi contoh program prosedur :

#include <stdio.h>
#include <stdlib.h>
///judul :  prosedur menghitung F(x)=x^2+3x-5
///kamus :
            void menghitungf(int x);
            int angka;
            int jawab;
///deskripsi :
    int main()
{
       angka=4;///angka diberikan nilai 4
       printf("prosedur menghitungf(angka=%d)\n",angka);
       menghitungf(angka); /// nilai x didalam prosedur di masukan
                           /// nilai dari angka yaitu 4 kemudian akan 
                           /// mengerjakan prosedur di dalam mengitungf
}
///prosedur

void menghitungf(int x)
{
      int hasil;///parameter formal
      printf("nilai x=%d\n",x);
      printf("(x*x)+(3*x)-5\n");
      hasil=(x*x)+(3*x)-5;
      printf("hasil dari prosedur menghitungf adalah: %d\n",hasil);
}

int main dan void menghitungf merupakan prosedur
berikut setelah program dijalankan :
prosedur_blog