macam macam sorting lengkap dengan penje

(1)

Macam-macam sorting dan penjelasan lengkap

1. Radix Sort

Radix sort adalah algoritma non-comparation sort atau pengurutan tanpa perbandingan . metode ini mengklarifikisi sebuah data sesuai dengan kategori urutan tertentu. Dan setiap kategori diurutkan lagi dan seterusnya sesuai dengan kebutuhan. Kemudian bagian2 dari kategori tersebut akan digabungkan

kembali.

Catatan : data yang diurutkan pertama kali yaitu berupa input nilai2 yang dimasukkan pertama kali berdasarkan radix pertamanya, lalu diteruskan atau diurutkan lagi berdasarkan radix keduanya, dst…

Pada system decimal radix adalah digit dalam angka decimal. Missal : angka 354 mempunyai 3 digit yaitu 3, 5 dan 4

Contoh algoritma radix sort untuk mengurutkan bilangan bulat positif, dengan jumlah digit maksimal 3 :

313 354 123 321 543 756 834 675

 Pertama kita harus membagi-bagi data sesuai dengan urutan terkanan

 Lihat terlebih dahulu digit yang paling besar untuk menentukan kategori berapa baris data yang akan kita urutkan, dan dicontoh ini nilai digit paling besar yaitu angka 8, sehingga kategori sebanyak 8 baris dan diawali dengan angka 0. Supaya lebih jelas lihat table dibawah :

Kategori digit 1 0 1 2 3 4 5 6 7 8

isi - 321 - 313,123,

543

354,834 675 756 - -

Tabel 1.1

Hasil dari kategori pertama tadi akan digabungkan kembali sesuai dengan penjelasan diatas ;

321 313 123 543 354 834 675 756

Tabel 1.2

Kemdian dilakukan pengkategorian kembali berdasarkan dengan digit yang ke-2 dengan berpatokan / melihat baris urutan dari pengkategorian yang pertama tadi yaitu (Tabel 1.2).

Kategori digit 2 0 1 2 3 4 5 6 7 8

isi - 313 321,123 834 543 354,756 - 675 -

(2)

Selanjutnya hasil dari pengkategorian ke-2 digabungkan kembali sehingga diperoleh :

Table 1.4

Langkah terakhir yaitu pengkategorian ke-3 berdasar digit ke-3 dengan berpatokan melihat baris urutan pengkategorian ke-2 yaitu (Tabel 1.4)

Kategori digit 3 0 1 2 3 4 5 6 7 8

isi - 123 - 313,321,

354

- 543 675 756 834

Tabel 1.5

Jadi, hasil akhirnya dapat dituliskan :

123 313 321, 354 543 675 756 834

Table 1.6

Dari proses2 yang sudah kita kerjakan menggunakan Redix Sort, sangat jelas Radix sort termasuk algoritma pengurutan tanpa pembanding yang bersifat melihat digit2 angka sebagai pengontrolnya. Sebenarnya Radix Sort dapat diimplementasikan dalam pengurutan bilangan Decimal dan bilangan bit. Namun dalam penggunaannya Radix Sort bisa dimodifikasi untuk mengurutkan data2 negatif & pecahan.

Kelebiha : merupakan algoritma pengurutan yang cepat, mudah dan sangat efektif

Kekurangan : pengguaannya terbatas pada kasus2 tertentu dan memerlukan memori tambahan yang besar dalam prosesnya mengkategorikan sebuah data.

Contoh program Radix Sort dengan Dev-C++

#include <stdio.h> #define MAX 20 #define SHOWPASS #define BASE 10 void print(int *a, int n) {

int i;

for (i = 0; i < n; i++)

(3)

printf("%d\t", a[i]); }

void radixsort(int *a, int n) {

int i, b[MAX], m = a[0], exp = 1;

//Get the greatest value in the array a and assign it to m for (i = 1; i < n; i++)

{

if (a[i] > m) m = a[i]; }

//Loop until exp is bigger than the largest number while (m / exp > 0)

{

int bucket[BASE] = { 0 };

//Count the number of keys that will go into each bucket for (i = 0; i < n; i++)

bucket[(a[i] / exp) % BASE]++;

//Add the count of the previous buckets to acquire the indexes after the end of each bucket location in the array

for (i = 1; i < BASE; i++)

(4)

//Starting at the end of the list, get the index corresponding to the a[i]'s key, decrement it, and use it to place a[i] into array b.

for (i = n - 1; i >= 0; i--)

b[--bucket[(a[i] / exp) % BASE]] = a[i];

//Copy array b to array a for (i = 0; i < n; i++) a[i] = b[i];

//Multiply exp by the BASE to get the next group of keys exp *= BASE;

#ifdef SHOWPASS printf("\nPASS : "); print(a, n);

#endif } }

int main() {

int arr[MAX]; int i, n;

printf("Enter total elements (n <= %d) : ", MAX); scanf("%d", &n);

n = n < MAX ? n : MAX;

(5)

for (i = 0; i < n; i++) scanf("%d", &arr[i]);

printf("\nARRAY : "); print(&arr[0], n);

radixsort(&arr[0], n);

printf("\nSORTED : "); print(&arr[0], n); printf("\n");

return 0; }

2. Quick Sort

Quick Sort adalah algoritma sorting yang berdasarkan pembanding dengan metode divide and conqueror, sangat berbeda dengan Radix Sort yang tanpa pembanding. Disebut Quick Sort karena algoritma Quick Sort mengurutkan dengan sangat cepat atau Quick Sort juga bias disebut dengan exchange sort, karena konsepnya yang membuat partisi2 dan Sort yang dilakukan tiap partisi.

Kelebihan :

 Algoritma sederhana dan mudah diterapkan pada berbagai bahasa pemrograman dan arsitektur mesin secara efisien.

 Algoritma pengurutan yang lebih cepat dengan perbandingan seperti Marge Sort dan Heap Sort.

 Melakukan proses secara langsung pada input(in-place) dengan sedikit tambahan memory.

 Bias digunakan dgn baik untuk input angka daan karakter

(6)

 Sedikit kesalahan saja didalam program bisa menyebablkan program tidak beraturan atau outputan tidak benar bahkan eksekusi tidak akan pernah selesai.

 Memiliki ketergantungan terhadap data yang dimasukkan.

 Sifatnya yg kurang stable karena input yang akan dirubah pada hasil akhirnya(output) bernilai sama.

 Memiliki katergantungan terhadap data yang dimasukkan.

 Pada penerapan rekursif(memanggil dirinya sendiri) bahkan dalam kasus terburuk bisa dapat menghabiskan stack dan memacetkan rogram.

Contoh program Quick Sort dengan Dev-C++ #include <stdio.h>

void quickSort( int[], int, int); int partition( int[], int, int);

printf("masukkan jumlah data total = ");scanf("%d",&total);

for(i=0;i<total;i++){

printf("masukkan data index ke %d = ",i+1);scanf("%d",&a[i]); }

printf("\n\nsebelum Di- sorting: "); for(i = 0; i < total; ++i)

(7)

quickSort( a, 0, total-1);

printf("\n\nsesudah Di- sorting: "); for(i = 0; i < total; ++i){

printf(" %d ", a[i]);} printf("\n"); }

void quickSort( int a[], int l, int r) {

int j;

if( l < r ) {

// divide and conquer j = partition( a, l, r); quickSort( a, l, j-1); quickSort( a, j+1, r); }

}

int partition( int a[], int l, int r) { int pivot, i, j, t;

pivot = a[l]; i = l; j = r+1;

(8)

{

Marge Sort merupakan algoritma yang dirancang untuk memenuhi kebutuhan pengurutan atas rangkaian data apabila suatu data tersebut tidak memungkinkan disimpan dalam memory computer yang kikarenakan jumlahnya yang terlalu besar.

Algoritma ini hampir sama dengan algoritma diatas yaitu memecah data yang kemudian digabungkan kembali. Bedanya pertama kita pecah data menjadi 2 bagian yang mana bagian pertama merupakan setengah (jika datanya genap) dan stengah minus satu (jika datanya ganjil) dari seluruh data. Kemudian dilakukan pemacahan kembali untuk masing2 blok sampai haanya terdiri 1 data dari tiap blok. Andthen menggabungkannya kembali dengan membandingkan pada blok yang sama apakah data yang pertama(data nilai pertama pada index ke-1) lebih besar dari pada data ke tengah+1(data setelah index ke-1), jika iya, maka data ke tengah+1 dipindah ke data yang pertama tadi, kemudian data yang pertama sampai ke tengah digesrt ke data yg ke-2 sampai ke tengah+1. Bingung ya gan , langsung saja raktek dengan program aja

Contoh program Merge Sort dengan Dev-C++ #include <stdio.h>

int total,data[10],salin[10]; void input(){

printf("input a value = ");scanf("%d",&total);

(9)

printf("masukkan nilai pada INDEX ke %d = ",a+1);scanf("%d",&data[a]); }

}

void merge(int salin[],int lowptr,int highptr,int upperbound){ int x=0;

int lowerbound=lowptr; int mid=highptr-1;

int n=upperbound-lowerbound+1;

while(lowptr<=mid && highptr<=upperbound){ if(data[lowptr]<data[highptr]){

salin[x++]=data[lowptr++]; }

else{

salin[x++]=data[highptr++]; }

while(lowptr<=mid){ salin[x++]=data[lowptr++]; }

while(highptr<=upperbound){ salin[x++]=data[highptr++]; }

for(int a=0;a<n;a++){

data[lowerbound+a]=salin[a]; }

(10)

void devide(int salin[],int kiri,int kanan){ if(kiri<kanan){

int mid=(kiri+kanan)/2; devide(salin,kiri,mid); devide(salin,mid+1,kanan); merge(salin,kiri,mid+1,kanan); }

}

void sort(){

devide(salin,0,total-1); }

void view(){

for(int a=0;a<total;a++){ printf("%d ",data[a]); }

printf("\n"); }

int main(){ input();

printf("sebelum di- sorting\n"); view();

sort();

(11)

}

Khusus yg marge saya kasihkan outputnya gan biar anda bisa memahami lebih baik

4. Insertion Sort

Insertion Sort adalah sebuah metode pengurutan dgn cara menyisipkan elemen larik/array pada posisi yang tepat.

Keuntungan :

 Sangat sederhana

 Sangat efisien untk data yang sangat kecil misalkan data kurang dari 10 or 20  Prosesnya yang cepat

Kekurangan :

 Banyak operasi yang dilakukan

 Kinerja buruk atau kurang efisien dika data dalam jumlah yang besar (tapi lebih baik daripada buble sort)

Contoph program insertion sort dengan Dev-C++ #include <stdio.h>

(12)

int n, array[1000], c, d, t;

printf("Masukkan Banyak Elemen : "); scanf("%d", &n);

printf("Masukkan %d Bilangan:\n", n);

for (c = 0; c < n; c++) { scanf("%d", &array[c]); }

for (c = 1 ; c <= n - 1; c++) { d = c;

while ( d > 0 && array[d] < array[d-1]) { t = array[d];

array[d] = array[d-1]; array[d-1] = t;

d--; } }

printf("Data Yang Sudah Terurut :\n");

(13)

return 0; }

5. Heap Sort

6. Bubble Sort

Bubble Sort adalah metode Sorting paling mudah. Diberi nama bubble karena proses

pengurutannya secara berangsur-angsur bergerak / berpendah ke posisinya yang tepat, seperti gelembung yang keluar dari minuman bersoda.

Simpelnya ialah bahwa bubble sort mengurutkan data dengan membandingkan elemen sekarang dengan elemen berikutnya, meskipun dibilang paling simple dan algoritmanya paling mudah untuk dipahami disisi lain bubble sort mempunyai kelemahan yg jauh lebih buruk daripada metode insertion sort misalkan saja jika jumlah data yang diolah cukup banyak maka data akan mengalami kelembatan yang sangat parah, karena disetiap data akan dibandingkan untuk menentukan posisinya

Contoh algoritma bubble sort dengan Dev-C++ #include <stdio.h>

#define N 20 int bubble(int n); int i,j,A[N]; main() {

int jml;

printf("\t METODE BUBBLE SORT \n\n"); printf("Masukkan jumlah bilangan: "); scanf("%d",&jml);

printf("\n"); // input data

(14)

{

printf("Bilangan ke %d : ",i+1); scanf("%d",&A[i]);

}

printf("\n"); // mengurutkan data bubble(jml); // menampilkan data

printf("Data yang sudah terurut : \n"); for (i=0;i<jml;i++)

{ printf("%d\n",A[i]); } }

// fungsi bubble int bubble(int n) {

int temp;

for (i=1;i<=n-1;i++) {

for (j=i;j<n;j++) {

if (A[i-1]>A[j]) {

(15)

} } }

7. Shell Sort

Shell Sort merupakan perbaikan metode pengurutan sisip dan merupakan salahsatu algoritma sorting pada sebuah deklarasi array

Kelebihan :

 Operasi pertukarannya hanya sekali  Mudah menggabungkaannya kembali  Kompleksitas selection relative lebih kecil

Kekurangan :

 Membutuhkan methot tambahan

 Sulit untuk membagi sbuah masalah pada data

Contoh program algoritma shell sort dengan Dev-C++ yang berupa karakter : #include <string.h>

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

void shell_sort(char *chars, int c) {

register int i, j, space, k; char x, a[5];

a[0]=9; a[1]=5; a[2]=3; a[3]=2; a[4]=1;

(16)

for(i=space; i < c; ++i) { x = chars[i];

for(j=i-space; (x < chars[j]) && (j >= 0); j=j-space) chars[j+space] = chars[j];

chars[j+space] = x; }

} }

int main() { char string[3];

printf("Masukkan Karakter: "); gets(string);

shell_sort(string, strlen(string));

printf("Pengurutan karakter: %s.\n", string); return 0;

}