Senin, 03 Januari 2011

Selection Sort

Selection Sort Merupakan kombinasi antara sorting dan searching
-Untuk setiap proses, akan dicari elemen-elemen yang belum diurutkan yang memiliki nilai terkecil atau terbesar akan dipertukarkan ke posisi yang tepat di dalam array.
-Misalnya untuk putaran pertama, akan dicari data dengan nilai terkecil dan data ini akan ditempatkan di indeks terkecil (data[0]), pada putaran kedua akan dicari data kedua terkecil, dan akan ditempatkan di indeks kedua (data[1]).
-Selama proses, pembandingan dan pengubahan hanya dilakukan pada indeks pembanding saja, pertukaran data secara fisik terjadi pada akhir proses.

berikut Algoritmanya :

#include "conio.h"
#include "stdio.h"

int main() {

int i, j, iMin;
int n, Urut;
int Tmp, code;
int Arr[100];
do {


printf("=====================================\n");
printf("| Pilihan Program Sorting |\n");
printf("=====================================\n");
printf("| 1. Selection Sorting (Ascending) |\n");
printf("| 2. Selection Sorting (Descending) |\n");
printf("| 3. Bubble Sorting (Ascending) |\n");
printf("| 4. Bubble Sorting (Descending) |\n");
printf("| 5. Insertion Sorting (Ascending) |\n");
printf("| 6. Insertion Sorting (Descending) |\n");
printf("| 7. Keluar . . . |\n");
printf("=====================================\n\n");
printf("Masukan Pilihan Anda : ");
scanf("%d", &code);
switch (code) {

case 1 :
printf("\nInputkan banyak data yang akan diurutkan : ");
scanf("%i", &n);
Urut = 1;
for(i = 0; i < n; i++) {
printf("Masukan data ke %i : ", i + 1);
scanf("%i", &Arr[i]);
}
for(i = 0; i < n - 1; i++) {
iMin = i;
for(j = Urut; j < n; j++) {
if(Arr[j] < Arr[iMin]) {
iMin = j;
if(Arr[i] != Arr[iMin]) {
Tmp = Arr[i];
if(Arr[i] > Arr[iMin]) {
Arr[i] = Arr[iMin];
Arr[iMin] = Tmp;
}
}
}
}
Urut = Urut + 1;
}
printf("\nSetelah Pengurutan\n");
for(i = 0; i < n; i++) {
printf("Elemen ke %i : %i\n", i + 1, Arr[i]);
}
getch();
break;

Read More..

Bubble Sort

Bubble Sort Merupakan sebuah algoritma penyortiran yang dimulai dan berakhir pada sebuah daftar dengan n elemen dan memindahkan seluruhnya, menguji nilai setiap pasangan item yang berdekatan dan menukarkannya jika mereka tidak berada dalam urutan yang tepat.
contoh algoritmanya :

#include "stdio.h"
#include "conio.h"
#define n 7
void main()
{
int A[n] = {15,10,7,22,17,5,12};
int X, I, K;
printf("Sebelum di-sort\n");
for (I=0; I <= n-1; I++)
printf("%3i", A[I]);
printf("\n");

K=0;
while(K<=n-2)
{
I=0;
while(I<=n-2 - K)
{
if (A[I] > A[I+1])
{
X = A[I];
A[I] = A[I+1];
A[I+1] = X;
}
I++;
}
K++;
}
printf("Sesudah di-sort\n");
for (I=0; I<= n-1; I++)
printf("%3d", A[I]);
}

Read More..

Sabtu, 25 Desember 2010

Algoritma Sorting

Algoritma Sorting
ada beberapa Algoritma Sorting, yaitu :
1.Insertion Sort
Salah satu algoritma sorting yang paling sederhana adalah insertion sort. Ide dari algoritma ini dapat dianalogikan seperti mengurutkan kartu. Penjelasan berikut ini menerangkan bagaimana algoritma insertion sort bekerja dalam pengurutan kartu.
Anggaplah anda ingin mengurutkan satu set kartu dari kartu yang bernilai paling
kecil hingga yang paling besar. Seluruh kartu diletakkan pada meja,sebutlah meja
ini sebagai meja pertama, disusun dari kiri ke kanan dan atas ke bawah. Kemudian
kita mempunyai meja yang lain,meja kedua, dimana kartu yang diurutkan akan diletakkan.Ambil kartu pertama yang terletak pada pojok kiri atas meja pertama
dan letakkan pada meja kedua. Ambil kartu kedua dari meja pertama, bandingkan
dengan kartu yang berada pada meja kedua, kemudian letakkan pada urutan yang
sesuai setelah perbandingan. Proses tersebut akan berlangsung hingga seluruh kartu
pada meja pertama telah diletakkan berurutan pada meja kedua.
Algoritma insertion sort pada dasarnya memilah data yang akan diurutkan menjadi
dua bagian, yang belum diurutkan (meja pertama) dan yang sudah diurutkan (meja
kedua). 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.


2.Selection Sort
Jika anda diminta untuk membuat algoritma sorting tersendiri, anda mungkin akan
menemukan sebuah algoritma yang mirip dengan selection sort. Layaknya insertion
sort, algoritma ini sangat rapat dan mudah untuk diimplementasikan. Mari kita kembali menelusuri bagaimana algoritma ini berfungsi terhadap satu paket kartu. Asumsikan bahwa kartu tersebut akan diurutkan secara ascending. Pada awalnya, kartu tersebut akan disusun secara linier pada sebuah meja dari kiri ke kanan, dan dari atas ke bawah. Pilih nilai kartu yang paling rendah, kemudian tukarkan posisi kartu ini dengan kartu yang terletak pada pojok kiri atas meja. Lalu cari kartu dengan nilai paling rendah diantara sisa kartu yang tersedia. Tukarkan kartu yang baru saja terpilih dengan kartu pada posisi kedua. Ulangi langkah–langkah tersebut hingga posisi kedua sebelum posisi terakhir dibandingkan dan dapat digeser dengan kartu yang bernilai lebih rendah.Ide utama dari algoritma selection sort adalah memilih elemen dengan nilai paling rendah dan menukar elemen yang terpilih dengan elemen ke-i. Nilai dari i dimulai dari 1 ke n, dimana n adalah jumlah total elemen dikurangi

3.Merge Sort
Sebelum mendalami algoritma merge sort, mari kita mengetahui garis besar dari
konsep divide and conquer karena merge sort mengadaptasi pola tersebut.
Pola Divide and Conquer
Beberapa algoritma mengimplementasikan konsep rekursi untuk menyelesaikan
permasalahan. Permasalahan utama kemudian dipecah menjadi sub-masalah,
kemudian solusi dari sub-masalah akan membimbing menuju solusi permasalahan
utama.
Pada setiap tingkatan rekursi, pola tersebut terdiri atas 3 langkah.
- Divide
Memilah masalah menjadi sub masalah
- Conquer
Selesaikan sub masalah tersebut secara rekursif. Jika sub-masalah tersebut
cukup ringkas dan sederhana, pendekatan penyelesaian secara langsung akan
lebih efektif
- Kombinasi
Mengkombinasikan solusi dari sub-masalah, yang akan membimbing menuju
penyelesaian atas permasalahan utama

4.Quicksort
Quicksort ditemukan oleh C.A.R Hoare. Seperti pada merge sort, algoritma ini juga
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

berikut contoh algoritmanya :

#include
#include

int data[100],data2[100];
int n;

void tukar(int a,int b)
{
int t;
t = data[b];
data[b] = data[a];
data[a] = t;
}

void bubble_sort()
{
for(int i=1;i{
for(int j=n-1;j>=i;j–)
{
if(data[j]}
}
cout<<”bubble sort selesai!”<}

void exchange_sort()
{
for (int i=0; i{
for(int j = (i+1); j{
if (data [i] > data[j]) tukar(i,j);
}
}
cout<<”exchange sort selesai!”<}

void selection_sort()
{
int pos,i,j;
for(i=0;i{
pos = i;
for(j = i+1;j{
if(data[j] < data[pos]) pos = j;
}
if(pos != i) tukar(pos,i);
}
cout<<”selection sort selesai!”<}

void insertion_sort()
{
int temp,i,j;
for(i=1;i{
temp = data[i];
j = i -1;
while(data[j]>temp && j>=0)
{
data[j+1] = data[j];
j–;
}
data[j+1] = temp;
}
cout<<”insertion sort selesai!”<}

void QuickSort(int L, int R) //the best sort i’ve ever had
{
int i, j;
int mid;

i = L;
j = R;
mid = data[(L+R) / 2];

do
{
while (data[i] < mid) i++;
while (data[j] > mid) j–;

if (i <= j)
{
tukar(i,j);
i++;
j–;
};
} while (i < j);

if (L < j) QuickSort(L, j);
if (i < R) QuickSort(i, R);
}

void Input()
{
cout<<”Masukkan jumlah data = “; cin>>n;
for(int i=0;i{
cout<<”Masukkan data ke-”<<(i+1)<<” = “; cin>>data[i];
data2[i] = data[i];
}
}

void Tampil()
{
cout<<”Data : “<for(int i=0;i{
cout<}
cout<}

void AcakLagi()
{
for(int i=0;i{
data[i] = data2[i];
}
cout<<”Data sudah teracak!”<}

void main()
{
int pil;
clrscr();
do
{
clrscr();
cout<<”Program Sorting Komplit!!!”<cout<<”*********************************************”<cout<<” 1. Input Data”<cout<<” 2. Bubble Sort”<cout<<” 3. Exchange Sort”<cout<<” 4. Selection Sort”<cout<<” 5. Insertion Sort”<cout<<” 6. Quick Sort”<cout<<” 7. Tampilkan Data”<cout<<” 8. Acak Data”<cout<<” 9. Exit”<cout<<” Pilihan Anda = “; cin>>pil;
switch(pil)
{
case 1:Input(); break;
case 2:bubble_sort(); break;
case 3:exchange_sort(); break;
case 4:selection_sort(); break;
case 5:insertion_sort(); break;
case 6:QuickSort(0,n-1);
cout<<”quick sort selesai!”<break;
case 7:Tampil(); break;
case 8:AcakLagi(); break;
}
getch();
}while(pil!=9);
}

Read More..
Copyrigt @ : Rahman Avenged SMK N 2 SURAKARTA