Tampilkan postingan dengan label BahasaC. Tampilkan semua postingan
Tampilkan postingan dengan label BahasaC. Tampilkan semua postingan

Selasa, 24 Mei 2016

Struct : Program Penentuan Grade Mahasiswa

Pengantar :
Structure (struct) merupakan kumpulan variable-variable yang bertempat di suatu tempat yang sama. Berbeda dengan array yang berisi kumpulan variable-variable yang bertipe sama dalam satu nama, maka suatu structure dapat terdiri dari variable-variable yang berbeda tipenya yang tersimpan dalam satu nama structure.
Dalam hal ini, dalam suatu structure bisa terdapat berbeda-beda type data seperti char, int, float, dll.
Pola Structure di C++ :

struct himpunan
{
     int n;
     char nama[20];
};

Dalam pola di atas , setiap akhir pendeklarasian variable di dalam struct, harus di akhiri dengan tanda } dan ; .
Dalam penggunaannya di dunia nyata, structure digunakan untuk program antrian dan tumpukan.
Untuk lebih jelasnya , silahkan coba program berikut ini…

#include<stdio.h>
#include<conio.h>
#include<iostream>
using namespace std;
struct nilai{
int kehadiran, tugas, uts, uas;
float na;
};

struct mahasiswa{
char nim[11];
char nama[25];
nilai NM;
};

main(){
char lagi;
mahasiswa mhs;
cout<<"Nilai Mahasiswa"<<endl;
cout<<"NIM : "; cin.getline(mhs.nim,11);
cout<<"Nama : "; cin.getline(mhs.nama,25);
iin:
cout<<"Kehadiran (14) : "; cin>>mhs.NM.kehadiran;
cout<<"Nilai Tugas : "; cin>>mhs.NM.tugas;
cout<<"Nilai UTS : "; cin>>mhs.NM.uts;
cout<<"Nilai UAS : "; cin>>mhs.NM.uas;
while(mhs.NM.kehadiran>14 || mhs.NM.tugas>100 || mhs.NM.uts>100 || mhs.NM.uas>100){
cout<<"\n-------------------------------\nINPUT ERROR !!!"<<endl;
cout<<"Kehadiran maksimal 14"<<endl;
cout<<"Nilai Tugas, UTS dan UAS Maksimal 100"<<endl;
cout<<"-------------------------------"<<endl;
goto iin;
};
mhs.NM.na=(((mhs.NM.kehadiran/14)*10)+(20*mhs.NM.tugas)/100)+((30*mhs.NM.uts)/100)+((40*mhs.NM.tugas)/100);
float NA=mhs.NM.na;
cout<<"\n\nNilai Akhir \t: "<<NA<<endl;
if(NA>=80){cout<<"GRADE : A";}else
if(NA>=70){cout<<"GRADE : B";}else
if(NA>=60){cout<<"GRADE : C";}else
if(NA>=40){cout<<"GRADE : D";}else{cout<<"GRADE : E";}
cout<<"\n\n-------------------------------"<<endl;
cout<<"+ Ohansyah 04TPLMA 2014141384 +"<<endl;
cout<<"-------------------------------"<<endl;
getch();
}
Share:

Array 3 Dimensi

Pengertian :
Array 3 dimensi bisa digambarkan sebagai suatu benda ruang. Untuk deklarasi pada array 3 dimensi tidak jauh berbeda pada array 1 dimensi dan 2 dimensi, kecuali pada indeks array nya.

Bentuk umum array 3 dimensi :
Bentuk umum dari array dimensi 3 pada C++ bisa dilihat sebagai berikut :
tipe data nama variabel [jumlah baris][jumlah kolom][panjang karakter].

Contoh program sederhana array 3 dimensi pada C++;

#include <iostream>
#include <conio.h>
using namespace std;
int main()
{
char matriks[3][3][3]={'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z','0'};
cout<<"Isi Array";
for(int i=0;i<3;i++){
cout<<"\n";
for(int j=0;j<3;j++){
cout<<"\n";
for(int k=0;k<3;k++){
cout<<matriks[i][j][k]<<" ";
}
}
}
cout<<"\n\n-------------------------------"<<endl;
cout<<"+ Ohansyah 04TPLMA 2014141384 +"<<endl;
cout<<"-------------------------------"<<endl;
}
Share:

Kamis, 12 Mei 2016

Searching dalam Array

assalamualaikum guys... sorry nih udah lama gak posting... soalnya sibuk sama urusan duniawi kuliah hehehe :)
okelah kalau begitu... disini saya akan share tentang searching... dimana data yang kita cari terletak didalam kumpulan array 1d, nah langsung aja iini codingnya...

#include<stdio.h>
#include<iostream>
#include<conio.h>
#include<iomanip>
using namespace std;
main(){
int angka[25]={34, 8, 50, 74, 87, 90, 12, 25, 20, 30, 35, 45, 40, 22, 29, 72, 60, 55, 53, 12, 32, 33, 12, 41, 12};
int data=25,banyak=0;
int bilangan[3]={12,15,37};
int posisi[25];
bool ketemu;
int i,j;

cout<<"Data tersedia : "<<endl;
for(i=0;i<data;i++){
cout<<angka[i]<<" ";
}
cout<<"\nDicari : ";
for(i=0;i<3;i++){
cout<<angka[i]<<" ";
}

for(i=0;i<3;i++){
ketemu=false;
for(j=0;j<data;j++){
if(bilangan[i]==angka[j]){
posisi[banyak]=j;
banyak++;
ketemu = true;
}
}if(ketemu){
cout<<"\n\nbilangan "<<bilangan[i]<<" ditemukan sebanyak "<<banyak<<" data pada posisi ke ";
for(int j=0;j<banyak;j++){ cout<<posisi[j]<<" "; }
}else {cout<<"\nbilangan "<<bilangan[i]<<" tidak ditemukan"; }
}

cout<<"\n\n-------------------------------"<<endl;
cout<<"+ Ohansyah 04TPLMA 2014141384 +"<<endl;
cout<<"-------------------------------"<<endl;
getch();
}

kalau gak paham silahkan share comment ya bro...
Share:

Sabtu, 23 Januari 2016

Macam-Macam Metode Sorting

  • Buble Sort :
Merupakan algoritma pengurutan paling tua dengan metode pengurutan paling sederhana. Pengurutan yang dilakukan dengan membandingkan masing-masing item dalam suatu list secara berpasangan, menukar item jika diperlukan, dan mengulaginya sampai akhir list secara berurutan, sehingga tidak ada lagi item yang dapat ditukar.
author : Swfung8
  • Selection Sort :
Ide utama dari algoritma selection sort adalah memilih elemen dengan nilai paling rendah dan menukar elemen yang terpilih dengan elemen ke-i. Nilai dari dimulai dari 1 ke n, dimana adalah jumlah total elemen dikurangi 1.
author : en:Joestape89
  • Insertion Sort :
Algoritma insertion sort pada dasarnya memilah data yang akan diurutkan menjadi dua bagian, yang belum diurutkan dan yang sudah diurutkan. Elemen pertama diambil dari bagian array yang belum diurutkan dan kemudian diletakkan sesuai posisinya pada bagian lain dari array yang telah diurutkan. Langkah ini dilakukan secara berulang hingga tidak ada lagi elemen yang tersisa pada bagian array yang belum diurutkan.
author : Swfung8
  • Shell Sort :
Merupakan algoritma yang stau jenis dengan insertion sort, dimana pada setiap nilai i dalam n/i item diurutkan. Pada setiap pergantian nilai, i dikurangi sampai 1 sebagai nilai terakhir
author: wikipedia
author: wikipedia
  • Merge Sort :
Algoritma dirumuskan dalam 3 langkah berpola divide-and-conquer. Berikut menjelaskan langkah kerja dari Merge sort.
1. Divide
Memilah elemen – elemen dari rangkaian data menjadi dua bagian.
2. Conquer
Conquer setiap bagian dengan memanggil prosedur merge sort secara rekursif
3. Kombinasi
Mengkombinasikan dua bagian tersebut secara rekursif untuk mendapatkan rangkaian data berurutan
Proses rekursi berhenti jika mencapai elemen dasar. Hal ini terjadi bilamana bagian yang akan diurutkan menyisakan tepat satu elemen. Sisa pengurutan satu elemen tersebut menandakan bahwa bagian tersebut telah terurut sesuai rangkaian.
author : Swfung8
author : Swfung8
  • Quick Sort :
Algoritma ini berdasar pada pola divide-and-conquer. Berbeda dengan merge sort, algoritma ini hanya mengikuti langkah – langkah sebagai berikut :
1. Divide
Memilah rangkaian data menjadi dua sub-rangkaian A[p…q-1] dan A[q+1…r] dimana setiap elemen A[p…q-1] adalah kurang dari atau sama dengan A[q] dan setiap elemen pada A[q+1…r] adalah lebih besar atau sama dengan elemen pada A[q]. A[q] disebut sebagai elemen pivot. Perhitungan pada elemen q merupakan salah satu bagian dari prosedur pemisahan.
2. Conquer
Mengurutkan elemen pada sub-rangkaian secara rekursif. Pada algoritma quicksort, langkah ”kombinasi” tidak di lakukan karena telah terjadi pengurutan elemen – elemen pada sub-array
Author:Matt Chan
Author: Matt Chan
  • Heap Sort:
Heap sort adalah sorting yang menggunakan struktur data heap, dengan nilai parent selalu lebih besar dari pada nilai childnya.
Algoritma:
  1. Buat suatu heap.
  2. Ambil isi dari root masukkan kedalam sebuah array.
  3. Hapus element root dengan mempertahankan properti heap.
  4. Ulangi sampai tree menjadi kosong
author : Swfung8
author : Swfung8

  • Bucket Sort :
Algoritma:
  • Cari nilai maksimum dan minimum di array
  • Inisialisasi array bucket Daftar <> unsur (ukuran maxValue – minValue + 1)
  • Pindahkan elemen dalam array untuk bucket
  • Write bucket keluar (dalam rangka) ke array yang asli

  • Radix Sort:
Secara kompleksitas waktu, radix sort termasuk ke dalam Divide and Conquer.Namun dari segi algoritma untuk melakukan proses pengurutan, radix sort tidak termasuk dalam Divide and Conquer.
Radix sortmerupakan sebuah algoritma pengurutan yang mengatur pengurutan nilai tanpa melakukan beberapa perbandingan pada data yang dimasukkan.

Share:

Selasa, 24 November 2015

Program Billing Warnet (menggunakan Struct)

selamat malam semuanya,,, semoga belum pada ngantuk dan masih anteng nongkrong belajar ya,,,, ok langsung aja kali ini saya bagikan source singkat tentang pemakaian struct yang kita gunakan dalam program billing kali ini. nanti yang pada beum paham silahkan comment langsung ya,,,
ok dech kalo gitu gw tidur dulu yak,,,, wsslmlkum wr wb.......



#include<iostream>
using namespace std;

struct billingwarnet{
char no[3];
char nama[20];
int jam, menit, detik;
long int bayar;
};

int main(){
billingwarnet bil;

        //input data
cout<<"Nomor Billing \t : ";cin.getline(bil.no,3);
cout<<"Nama \t\t : ";cin.getline(bil.nama,20);
cout<<"Lama Penggunaan"<<endl;
cout<<"\tJam   : ";cin>>bil.jam;
cout<<"\tMenit : ";cin>>bil.menit;
cout<<"\tDetik : ";cin>>bil.detik;

        //penentuan harga, disini saya memberi tarif Rp.1/detik, kayak paket nelvon ya :) :) :)
bil.bayar=(3600*bil.jam)+(60*bil.menit)+bil.detik;

        //Output data
cout<<"\n\nNomor Billing \t: "<<bil.no<<endl;
cout<<"Nama \t\t: "<<bil.nama<<endl;
cout<<"\nLama Penggunaan"<<endl;
cout<<"\t"<<bil.jam<<" Jam : "<<bil.menit<<" Menit : "<<bil.detik<<" Detik"<<endl;
cout<<"\nJumlah Pembayaran : Rp."<<bil.bayar;


}


Share:

Structure (struct)

Pengertian
Structure (struct) merupakan kumpulan variable-variable yang bertempat di suatu tempat yang sama. Berbeda dengan array yang berisi kumpulan variable-variable yang bertipe sama dalam satu nama, maka suatu structure dapat terdiri dari variable-variable yang berbeda tipenya yang tersimpan dalam satu nama structure.
Dalam hal ini, dalam suatu structure bisa terdapat berbeda-beda type data seperti char, int, float, dll.
Pola Structure di C++ :
struct himpunan
{
     int n;
     char nama[20];
};

Dalam pola di atas , setiap akhir pendeklarasian variable di dalam struct, harus di akhiri dengan tanda } dan ; .
Dalam penggunaannya di dunia nyata, structure digunakan untuk program antrian dan tumpukan.

Akses Data
Untuk menggunakan struct, tulis nama struct beserta field yang dipisahkan dengan tanda titik "."
contoh menampilkan isi dari himpunan : cout<<himpunan.nama;
Share:

Sabtu, 22 Agustus 2015

Program Searching dengan Metode BINARY SEACRH

#include<iostream>
using namespace std;

main()
{
bool ketemu = false;
int a=0,b,tengah,n=11,cari,indxe;
int l[]={5,10,20,30,40,50,60,70,80,90,100};
cout<<"Masukkan Angka : ";
cin>>cari;
b=n-1;
while(a<=b)
{
tengah=(a+b)/2;
if(cari==l[tengah])
{
ketemu=true;
idx=tengah;
break;
}
else if(cari<l[tengah])
{
b=tengah-1;
}
else
{
a=tengah+1;
}
}
if(ketemu==true)
cout<<"Data Ditemukan, Terletak Pada Index ke "<<indxe+1;
else
cout<<"Data Tidak Ditemukan";
return 0;
}


untuk langkah manual & flowchartnya silahkan di kreasikan sendiri ya sob.... :) :) :)
Share:

Selasa, 18 Agustus 2015

Program Kasir

Assalamualaikum bro....
nih saya kasih codingan aplikasi kasir, nah bedanya dengan aplikasi yang lain yaitu di program ini terdapat converter dari angka ke kata, penasaran??? nih codingnya

#include<stdio.h>
#include<conio.h>
#include<iostream>
using namespace std;

void satuan(int x) //satuan
{
if(x==1)cout<<" Satu ";
else if(x==2)cout<<" Dua ";
else if(x==3)cout<<" Tiga ";
else if(x==4)cout<<" Empat ";
else if(x==5)cout<<" Lima ";
else if(x==6)cout<<" Enam ";
else if(x==7)cout<<" Tujuh ";
else if(x==8)cout<<" Delapan ";
else if(x==9)cout<<" Sembilan ";
else if(x==10)cout<<" Sepuluh ";
else if(x==11)cout<<" Sebelas ";
}

void terbilang(long y)
{
if (y<=11) satuan(y);
else if ((y>11)&&(y<=19)) //belasan
{
terbilang(y%10);
cout<<"Belas";
}
else if ((y>=20)&&(y<=99)) //puluhan
{
terbilang(y/10);
cout<<"Puluh";
terbilang(y%10);
}
else if ((y>=100)&&(y<=199)) //seratus
{
cout<<" Seratus";
terbilang(y%100);
}
else if ((y>=200)&&(y<=999)) //Ratusan
{
terbilang(y/100);
cout<<"Ratus";
terbilang(y%100);
}
else if ((y>=1000)&&(y<=1999)) //seribu
{
cout<<" Seribu";
terbilang(y%1000);
}
else if ((y>=2000)&&(y<=999999)) //Ribuan
{
terbilang(y/1000);
cout<<" Ribu";
terbilang(y%1000);
}
else if ((y>=1000000)&&(y<=1999999)) //sejuta
{
cout<<" Sejuta";
terbilang(y%1000000);
}
else if ((y>=2000000)&&(y<=999999999)) //Jutaanan
{
terbilang(y/1000000);
cout<<" Juta";
terbilang(y%1000000);
}
else { cout<<"Error"; }
}

main()
{
unsigned long nilai;
int jp, produk;
char ukuran, lagi;
unsigned long total, harga, kembalian, pem;
do{
printf("\n\t++++ Aplikasi Kasir ++++\n");
printf("+--------------------------------------------------+\n");
printf("|NO \tNama Produk \tUkuran \t\tHarga      |\n");
printf("+--------------------------------------------------+\n");
printf("|1 \tSepatu \t\tL \t\t100.000    |\n");
printf("|  \t       \t\tM \t\t80.000     |\n");
printf("|  \t       \t\tS \t\t70.000     |\n");
printf("+--------------------------------------------------+\n");
printf("|2 \tSandal \t\tL \t\t30.000     |\n");
printf("|  \t       \t\tM \t\t25.000     |\n");
printf("|  \t       \t\tS \t\t15.000     |\n");
    printf("+--------------------------------------------------+\n");
printf("|3 \tTas \t\tL \t\t200.000    |\n");
printf("|  \t       \t\tM \t\t150.000    |\n");
printf("|  \t       \t\tS \t\t100.000    |\n");
printf("+--------------------------------------------------+\n");
printf("\nPilih Nomer Produk \t: "); scanf("%d",&produk);

switch(produk){
case 1:
printf("\nPilih Ukuran \t\t: "); scanf("%s",&ukuran);
switch(ukuran){
case 'l':
harga=100000; break;
case 'm' :
harga=80000; break;
case 's':
harga=70000; break;}
break;

case 2:
printf("\nPilih Ukuran \t\t: "); scanf("%s",&ukuran);
switch(ukuran){
case 'l':
harga=30000; break;
case 'm':
harga=25000; break;
case 's':
harga=15000; break;}
break;

case 3:
printf("\nPilih Ukuran \t\t: "); scanf("%s",&ukuran);
switch(ukuran){
case 'l':
harga=200000; break;
case 'm':
harga=150000; break;
case 's':
harga=100000; break;}
break;

}
//angka
printf("\nJumlah Produk \t\t: "); scanf("%d",&jp);
total=jp*harga; //total biaya
printf("\nTotal Biaya \t: Rp.%d ", total);
printf("\nPembayaran \t: Rp."); scanf("%d",&pem);
kembalian=pem-total; //kembalian
printf("Kembalian \t: Rp.%d ", kembalian);
printf("\n+--------------------------------------------------+\n");

//text
cout<<"\nJumlah Produk \t: ";
nilai=jp;
terbilang(nilai);

cout<<"\nTotal Biaya \t: "; //kembalian text
nilai=total;
terbilang(nilai);
cout<<" Rupiah";

cout<<"\nPembayaran \t: "; //kembalian text
nilai=pem;
terbilang(nilai);
cout<<" Rupiah";

cout<<"\nKembalian \t: "; //kembalian text
nilai=kembalian;
terbilang(nilai);
cout<<" Rupiah";
printf("\n+--------------------------------------------------+\n");

printf("\n\n Terimakasih.... :)");
printf("\n\nMenghitung lagi ? y/n  :"); scanf("%s",&lagi);
}while (lagi=='y');
}

//jangan lupa pada dieditin ya









Share:

Rabu, 12 Agustus 2015

Program Pencarian Data (Searching)

#include<iostream>
using namespace std;
main()
{
int h, j, i,idx=-1;
cout<<"Jumlah data  ";
cin>>i;
int l[i];
for(j=0;j<i;j++)
{
cout<<"Data Ke "<<j+1<<" : ";
cin>>l[j];
}
cout<<"\nMasukkan Data yang dicari : ";
cin>>h;
for(j=0; j<i; j++)
{
if(l[j]==h)
{
idx=1;
}
}
if(idx==-1)
{ cout<<"Data tidak ada \n"; }
else
{
cout<<"\nData ketemu"<<endl;
}
cout<<"\n\nOhansyah\t2014141384\t02TPLMA";
}

Share:

Program Pengurutan Data Dari Terbesar Ke Terkecil (Sorting)

#include<iostream>
#include<iomanip>
using namespace std;
int main ()
{
int NumList[10] = {4,8,5,9,6,2,7,5,9,5};
int Swap;
cout<<"data sebelum diurutkan : \n";
for (int ctr=0; ctr<10; ctr++)
{
cout<<setw(3)<<NumList[ctr];
}
cout<<"\n\n";

for(int i=0; i<9; i++)
for(int ii=0; ii<9; ii++)
if (NumList[ii] < NumList[ii+1])
{
Swap=NumList[ii];
NumList[ii]=NumList[ii+1];
NumList[ii+1]=Swap;
}
cout<<"data setelah diurutkan dari terbesar ke terkecil: \n";
for(int iii=0; iii<10; iii++)
cout<<setw(3)<<NumList[iii];
cout<<endl<<endl;
}
Share:

Sorting (Buble Sort)

BUBBLE SORT
A.      Pengertian Bubble Sort
Bubble Sort adalah salah satu algoritma untuk sorting data, atau kata lainnya mengurutkan data dari yang terbesar ke yang terkecil atau sebaliknya (Ascending atau Descending).
Bubble sort (metode gelembung) adalah metode/algoritma pengurutan dengan dengan cara melakukan penukaran data dengan tepat disebelahnya secara terus menerus sampai bisa dipastikan dalam satu iterasi tertentu tidak ada lagi perubahan. Jika tidak ada perubahan berarti data sudah terurut. Disebut pengurutan gelembung karena masing-masing kunci akan dengan lambat menggelembung ke posisinya yang tepat.
                Metode pengurutan gelembung (Bubble Sort) diinspirasikan oleh gelembung sabun yang berada dipermukaan air. Karena berat jenis gelembung sabun lebih ringan daripada berat jenis air, maka gelembung sabun selalu terapung ke atas permukaan. Prinsip di atas dipakai pada pengurutan gelembung.
Algoritma bubble sort adalah salah satu algoritma pengurutan yang paling simple, baik dalam hal pengertian maupun penerapannya. Ide dari algoritma ini adalah mengulang proses pembandingan antara tiap-tiap elemen
array dan menukarnya apabila urutannya salah. Pembandingan elemen-elemen ini akan terus diulang hingga tidak perlu dilakukan penukaran lagi. Algoritma
ini termasuk dalam golongan algoritma comparison sort, karena menggunakan perbandingan dalam operasi antar elemennya. Berikut ini adalah gambaran dari algoritma bubble sort. Misalkan kita mempunyai sebuah array dengan.  Elemen-elemen “4 2 5 3 9”. Proses yang akan terjadi apabila digunakan algoritma bubblesort adalah sebagai berikut.

Pass pertama
(4 2 5 3 9) menjadi (2 4 5 3 9)
(2 4 5 3 9) menjadi (2 4 5 3 9)
(2 4 5 3 9) menjadi (2 4 3 5 9)
(2 4 3 5 9) menjadi (2 4 3 5 9)
Pass kedua
(2 4 3 5 9) menjadi (2 4 3 5 9)
(2 4 3 5 9) menjadi (2 3 4 5 9)
(2 3 4 5 9) menjadi (2 3 4 5 9)
(2 3 4 5 9) menjadi (2 3 4 5 9)
Pass ketiga
(2 3 4 5 9) menjadi (2 3 4 5 9)
(2 3 4 5 9) menjadi (2 3 4 5 9)
(2 3 4 5 9) menjadi (2 3 4 5 9)
(2 3 4 5 9) menjadi (2 3 4 5 9)



Dapat dilihat pada proses di atas, sebenarnya pada pass kedua, langkah kedua, array telah terurut. Namun algoritma tetap dilanjutkan hingga pass kedua berakhir. Pass ketiga dilakukan karena definisi terurut dalam algoritma bubblesort adalah tidak ada satupun penukaran pada suatu pass, sehingga pass ketiga dibutuhkan untuk memverifikasi keurutan array tersebut.
B.      Algoritma Bubble Sort

1.    Membandingkan data ke-i dengan data ke-(i+1) (tepat bersebelahan). Jika tidak sesuai maka tukar (data ke-i = data ke-(i+1) dan data ke-(i+1) = data ke-i). Apa maksudnya tidak sesuai? Jika kita menginginkan algoritme menghasilkan data dengan urutan ascending (A-Z) kondisi tidak sesuai adalah data ke-i > data ke-i+1, dan sebaliknya untuk urutan descending (A-Z).
2.    Membandingkan data ke-(i+1) dengan data ke-(i+2). Kita melakukan pembandingan ini sampai data terakhir. Contoh: 1 dgn 2; 2 dgn 3; 3 dgn 4; 4 dgn 5 … ; n-1 dgn n.
3.    Selesai satu iterasi, adalah jika kita sudah selesai membandingkan antara (n-1) dgn n. Setelah selesai satu iterasi kita lanjutkan lagi iterasi berikutnya sesuai dengan aturan ke-1. mulai dari data ke-1 dgn data ke-2, dst.
4.    Proses akan berhenti jika tidak ada pertukaran dalam satu iterasi.

Contoh Kasus Bubble Sort :

Misalkan kita punya data seperti ini: 6, 4, 3, 2 dan kita ingin mengurutkan data ini (ascending) dengan menggunakan bubble sort. Berikut ini adalah proses yang terjadi:
Iterasi ke-1: 4, 6, 3, 2 :: 4, 3, 6, 2 :: 4, 3, 2, 6 (ada 3 pertukaran)
Iterasi ke-2: 3, 4, 2, 6 :: 3, 2, 4, 6 :: 3, 2, 4, 6 (ada 2 pertukaran)
Iterasi ke-3: 2, 3, 4, 6 :: 2, 3, 4, 6 :: 2, 3, 4, 6 (ada 1 pertukaran)
Iterasi ke-4: 2, 3, 4, 6 :: 2, 3, 4, 6 :: 2, 3, 4, 6 (ada 0 pertukaran) -> proses selesai


C.      Kompleksitas Algoritma Bubble Sort

Kompleksitas Algoritma Bubble Sort dapat dilihat dari beberapa jenis kasus, yaitu worst-case, average-case, dan best-case.

Ø  Kondisi Best-Case

Dalam kasus ini, data yang akan disorting telah terurut sebelumnya, sehingga proses perbandingan hanya dilakukan sebanyak (n-1) kali, dengan satu kali pass.
Proses perbandingan dilakukan hanya untuk memverifikasi keurutan data. Contoh Best-Case dapatdilihat pada pengurutan data “1 2 3 4” di bawah ini.

Pass Pertama
(1 2 3 4) menjadi (1 2 3 4)
(1 2 3 4) menjadi (1 2 3 4)
(1 2 3 4) menjadi (1 2 3 4)

Dari proses di atas, dapat dilihat bahwa tidak terjadi penukaran posisi satu kalipun, sehingga tidak dilakukan pass selanjutnya. Perbandingan elemen dilakukan sebanyak tiga kali. Proses perbandingan pada kondisi ini hanya dilakukan sebanyak (n-1) kali. Persamaan Big-O yang diperoleh dari proses ini adalah O(n). Dengan kata lain, pada kondisi Best-Case algoritma Bubble Sort termasuk pada algoritma
lanjar.


Ø  Kondisi Worst-Case

Dalam kasus ini, data terkecil berada pada ujung array. Contoh Worst-Case dapat dilihat pada pengurutan data “4 3 2 1” di bawah ini.

Pass Pertama
(4 3 2 1) menjadi (3 4 2 1)
(3 4 2 1) menjadi (3 2 4 1)
(3 2 4 1) menjadi (3 2 1 4)
Pass Kedua
(3 2 1 4) menjadi (2 3 1 4)
(2 3 1 4) menjadi (2 1 3 4)
(2 1 3 4) menjadi (2 1 3 4)
Pass Ketiga
(2 1 3 4) menjadi (1 2 3 4)
(1 2 3 4) menjadi (1 2 3 4)
(1 2 3 4) menjadi (1 2 3 4)
Pass Keempat
(1 2 3 4) menjadi (1 2 3 4)
(1 2 3 4) menjadi (1 2 3 4)
(1 2 3 4) menjadi (1 2 3 4)

Dari langkah pengurutan di atas, terlihat bahwa setiap kali melakukan satu pass, data terkecil akan bergeser ke arah awal sebanyak satu step. Dengan kata lain, untuk menggeser data terkecil dari urutan keempat menuju urutan pertama, dibutuhkan pass sebanyak tiga kali, ditambah satu kali pass untuk memverifikasi. Sehingga jumlah proses pada kondisi best case dapat dirumuskan sebagai berikut. Jumlah proses = n2+n (3)
Dalam persamaan (3) di atas, n adalah jumlah elemen yang akan diurutkan. Sehingga notasi Big-O yang didapat adalah O(n2). Dengan kata lain, pada kondisi worst-case, algoritma Bubble Sort termasuk dalam kategori algoritma kuadratik.

Ø  Kondisi Average-Case

Pada kondisi average-case, jumlah pass ditentukan dari elemen mana yang mengalami penggeseran ke kiri paling banyak. Hal ini dapat ditunjukkan oleh proses pengurutan suatu array, misalkan saja (1 8 6 2). Dari (1 8 6 2), dapat dilihat bahwa yang akan mengalami proses penggeseranpaling banyak adalah elemen 2, yaitu sebanyak dua kali.

Pass Pertama
(1 8 6 2) menjadi (1 8 6 2)
(1 8 6 2) menjadi (1 6 8 2)
(1 6 8 2) menjadi (1 6 2 8)
Pass Kedua
(1 6 2 8) menjadi (1 6 2 8)
(1 6 2 8) menjadi (1 2 6 8)
(1 2 6 8) menjadi (1 2 6 8)
Pass Ketiga
(1 2 6 8) menjadi (1 2 6 8)
(1 2 6 8) menjadi (1 2 6 8)
(1 2 6 8) menjadi (1 2 6 8)

Dari proses pengurutan di atas, dapat dilihat bahwa untuk mengurutkan diperlukan dua buah passing,ditambah satu buah passing untuk memverifikasi. Dengan kata lain, jumlah proses perbandingan dapat dihitung sebagai berikut. Jumlah proses = x2+x (4) Dalam persamaan (4) di atas, x adalah jumlahpenggeseran terbanyak. Dalam hal ini, x tidak pernah lebih besar dari n, sehingga x dapat dirumuskan sebagai
Dari persamaan (4) dan (5) di atas, dapat disimpulkan bahwa notasi
big-O nya adalah O(n2). Dengan kata lain, pada kondisi average case algoritma Bubble Sort termasuk dalam algoritma kuadratik.

D.      Implementasi dalam Pseudo-Code

Setiap algoritma akan memiliki implementasi yang berbeda, tergantung dari bahasa program yang dipakai. Oleh karena itu berikut ini adalah pseudo-code dari algoritma bubblesort, untuk memudahkan implementasi bubblesort pada bahasa apapun.

procedure bubbleSort( A list of
sortable items ) defined as:
do
swapped := false
for each in to length(A) - 2
inclusive do:
if A[i] > A[i+1] then
swap( A[i], A[i+1] )
swapped := true
end if
end for
while swapped
end procedure
















E.       Kelebihan dan Kelemahan Bubble Sort

Kelebihan :
·      Metode Buble Sort merupakan metode yang paling simpel
·      Metode Buble Sort mudah dipahami algoritmanya

Kelemahan:
Meskipun simpel metode Bubble sort  merupakan metode pengurutan yang paling tidak efisien.  Kelemahan buble sort adalah pada saat mengurutkan data yang sangat besar akan mengalami kelambatan luar biasa, atau dengan kata lain kinerja memburuk cukup signifikan ketika data yang diolah jika  data cukup banyak. Kelemahan lain adalah jumlah pengulangan akan tetap sama jumlahnya walaupun data sesungguhnya sudah cukup terurut. Hal ini disebabkan setiap data dibandingkan dengan setiap data yang lain untuk menentukan posisinya.
Share:

index

Popular Posts

Categories