3 metode sortingPosted October 12, 2009 by tamimi123 in
Uncategorized. 6 Comments 3 Metode Sorting SHELL SORT Shell sort
merupakan suatu bentuk improvisasi dari insertion sort. Metode ini
pertama kali di buat oleh seseorang yang bernama Donald L.Shell.
Sesuai dengan namanya program sorting tersebut di beri nama shell
sort. Metode ini mengurutkan data dengan cara membandingkan suatu
data dengan yang lain yang memiliki jarak tertentu, kemudian
dilakukan penukaran jika diperlukan.Cara kerja shell sort adalah
sebagai berikut : 1. Pertama, metode ini menentukan jarak dari
suatu elemen yang akan di tentukan, kemudian di tukarkan. Biasanya
jarak elemen yang akan di tentukan, di tentukan dengan cacah data =
n di bagi 2. Elemen-elemen yang di pisahkan tersebut di bandingkan
kemudian di pisahkan 2. Kedua, setelah Kemudian dilakukan
perulangan dari j=1 sampai N/2, pada 3. masing-masing pengulangan
dilakukan pembandingan antara data yg ke-j dengan data ke-(j+N/2).
4. Ketiga, Bila data ke-j lebih besar dari data ke (j+n/2),
kemudian harus di tukar 5. Keempat, Proses berikutnya sama, gunakan
jarak (N/2)/2 atau N/4 dan kemudian N/8 dst, hingga N=1 Analisis
shell sort Pseudo code : shellsort(itemType a[], int l, int r) {
int i, j, h; itemType v; int incs[16] = { 1391376, 463792, 198768,
86961, 33936, 13776, 4592, 1968, 861, 336, 112, 48, 21, 7, 3, 1 };
for ( k = 0; k < 16; k++) for (h = incs[k], i = l+h; i h
&& a[j-h] > v) { a[j] = a[j-h]; j -= h; } a[j] = v; } }
Output {336,861,1968,4592,13776,33936,86961,198768,463792,1391376}
Contoh program shell sort : #include< stdio.h> #include<
conio.h> void shellsort(int a[],int n) { int j,i,k,m,tengah;
for(m = n/2;m>0;m/=2) { for(j = m;j< n;j++) {
for(i=j-m;i>=0;i-=m) { if(a[i+m]>=a[i]) break; else { tengah
= a[i]; a[i] = a[i+m]; a[i+m] = tengah; } } } } } main() { int
a[10],i,n; clrscr(); printf(Berapa banyak angka yang ingin anda
masukkan\t: ); scanf(%d,&n);
for(i=0;i< n;i++) { printf(\nAngka ke %d\t: ,i+1);
scanf(%d,&a[i]); } printf(\nAngka sebelum pengurutan: );
for(i=0;i< n;i++) printf(%5d,a[i]); shellsort(a,n);
printf(\nAngka setelah pengurutan: ); for(i=0;i< n;i++)
printf(%5d,a[i]); getch(); return 0; } QUICK SORT Metode quick sort
adalah metode pengurutan yang menggunakan partisi. Quick sort juga
banyak di gunaka untuk proses sorting karena lbh mudah dan cepat.
Pada metode ini, data dibagi menjadi dua bagian, yaitu data
disebelah kiri partisi selalu lebih kecil dari data disebelah
kanan. Namun data pada kedua partisi belum terurut, sehingga untuk
mengurutkannya, proses pengurutan dilakukan pada kedua partisi
secara terpisah. Selanjutnya, data di sebelah kiri dan kanan
dipartisi lagi. Berikut adalah rincian mengenai cara kerja dari
quick sort : 1. 2. 3. 4. 5. 6. 7. 1. Pilih satu data sebarang
sebagai data partisi, misalkan x. 2. Baca data dari ujung kanan ke
kiri sampai ditemukan data a[i] sehingga a[i] < x. 3. (partisi
kiri). 4. Baca data dari ujung kiri ke kanan sampai ditemukan data
a[j] sehingga a[j] >= x. 5. (partisi kanan). 6. Tukar kedua data
a[i] dan a[j]. 7. Ulangi proses di atas sampai seluruh data terbagi
dua bagian kiri yang lebih kecil dari x dan kanan yang lebih besar
dari x.
Prinsip dasar dari quicksort adalah melakukan partisi dari data,
dalam dua bagian. Kemudian secara rekursif melakukan sorting pada
kedua bagian data tersebut. Algoritma quicksort adalah sebagai
berikut: 1. 2. 3. 4. 1. Tentukan unsur partisi yang diperlukan
(gunakan data tengah sebagai unsure partisi). 2. Partisi data dalam
dua bagian yang dipisahkan oleh unsur partisi. 3. Secara rekursif
sort terhadap kedua bagian data diatas dengan dengan metode 4.
partisi (ulangi langkah 1 dan 2 untuk data sebelah kiri dan
kanan).
Analisis dari quicksort
Bahsa manusia Bahasa Algoritmik Mendeklarasikan array yang Array
[110] of integer tabint right); } } // TR create() { TR
head,new,temp; char c; head=new_node(); new=get_node();
head->left=new; printf(\n\n\t Tambah angka lainnya (Y/N) :: );
c=getche(); while(c==y'||c==Y') { new=get_node();
insert_node(head->left,new); printf(\n\n\t Tambah angka lainnya
(Y/N) :: ); c=getche();
} return(head); } // void main() { TR head; int choice;
textcolor(10); while(1) { clrscr(); printf(\n\n\t ******* MENU
*******); printf(\n\n\t 1> READ LIST); printf(\n\n\t 2> HEAP
SORT); printf(\n\n\t 3> KELUAR); printf(\n\n\t PILIH :: );
scanf(%d,&choice); switch(choice) { case 1:head=create();
break; case 2:printf(\n\n\t YANG UDAH DI SORTING :: );
printf(\n\n\t ); heap_sort(head->left); break; case
3:printf(\n\n\t TEKAN ESC KEY UNTUK KELUAR); if(getch()==27)
exit(0); break; } getch(); } } // Ini adalah daftar perbandingan
dari eberapa algoritma sorting : Name HTUBubble sortUTH Best O(n)
Average Worst O(nP2P) Memory Stable Method O(1) Other notes Yes
Exchanging Times are for best variant Yes Exchanging No Yes No Yes
No Exchanging Exchanging Selection Insertion Insertion Times are
for best variant
HTUCocktail O(n) O(nP2P) sortUTH HTUComb sortUTH O(n log n) O(n
log n) HTUGnome sortUTH O(n) O(nP2P) HTUSelection O(nP2P) O(nP2P)
O(nP2P) sortUTH HTUInsertion O(n) O(nP2P) sortUTH HTUShell sortUTH
O(nlog(n)) O(nlogP2P(n))
O(1) O(1) O(1) O(1) O(1) O(1)
HTUBinary tree O(nlog(n)) O(nlog(n)) sortUTH HTULibrary sortUTH
O(n) O(nlog(n)) O(nP2P) HTUMerge sortUTH O(nlog(n)) O(nlog(n))
In-place HTUmerge O(nlog(n)) O(nlog(n)) sortUTH
O(1) O(n) O(n) O(1)
Yes Yes Yes Yes
Insertion Insertion Merging Merging Times are for best variant
Selection Selection PartitioningNaive variants use O(n) space
Hybrid
HTUHeapsortUTH O(nlog(n)) O(nlog(n)) HTUSmoothsortUTH O(n)
O(nlog(n)) HTUQuicksortUTH O(nlog(n)) O(nlog(n)) O(nP2P)
O(1) O(1) O(log n)
No No No
HTUIntrosortUTH O(nlog(n)) O(nlog(n))
O(nlog(n))
O(logn)
No
