ini makalah jadi shell sort nya :)

1. SHELL SORT
Nama : 1. Apriyanti 13312320
2. Bella Angriani 13312294
3. Endah Yushairani 13312362
4. Intan Purnama Sari 13312532
Kelas : TI A SP
Mata Kuliah : Struktur Data
TEKNIK INFORMATIKA
SEKOLAH TINGGI MANAJEMEN INFORMATIKA & KOMPUTER
PERGURUAN TINGGI TEKNOKRAT
BANDAR LAMPUNG
2014

2. KATA PENGANTAR
Assalamu’alaikum Wr. Wb
Puji dan Syukur Penulis Panjatkan ke Hadirat Tuhan Yang Maha Esa karena berkat limpahan
Rahmat dan Karunia-Nya sehingga penulis dapat menyusun makalah ini tepat pada waktunya.
Makalah ini membahas Shell Sort.
Dalam penyusunan makalah ini, penulis banyak mendapat tantangan dan hambatan akan tetapi
dengan bantuan dari berbagai pihak tantangan itu bisa teratasi. Olehnya itu, penulis
mengucapkan terima kasih yang sebesar-besarnya kepada semua pihak yang telah membantu
dalam penyusunan makalah ini, semoga bantuannya mendapat balasan yang setimpal dari Tuhan
Yang Maha Esa.
Penulis menyadari bahwa makalah ini masih jauh dari kesempurnaan baik dari bentuk
penyusunan maupun materinya. Kritik konstruktif dari pembaca sangat penulis harapkan untuk
penyempurnaan makalah selanjutnya.
Akhir kata semoga makalah ini dapat memberikan manfaat kepada kita sekalian.
Wassalamu’alaikum Wr. Wb
Bandar Lampung, 18 Agustus 2014
Penulis

3. DAFTAR ISI
Kata Pengantar.................................................................................................................... i
Daftar Isi ............................................................................................................................. ii
ABSTRAK.......................................................................................................................... 1
BAB I PENDAHULUAN................................................................................................... 1
BAB II PEMBAHASAN
2.1. Pengertian Pengurutan Cangkang (Shell Sort)...................................................... 5
2.2. Metode Shell Sort ................................................................................................ 5
2.3. Kelebihan dan Kekurangan Shell Sort.................................................................. 9
2.4. Source Code Shell Sort ......................................................................................... 9
BAB III PENUTUP
3.1. Kesimpulan........................................................................................................... 13
DAFTAR PUSTAKA......................................................................................................... 14

4. 1
5
ABSTRAK
Makalah ini membahas dan menganalisa tentang kompleksitas algoritma dari berbagai jenis
pemrosesan tabel pada paradigma pemrograman prosedural. Jenis pemrosesan tabel yang
akan dibahas pada makalah ini adalah pengurutan nilai (sorting).
Jenis-jenis algoritma pengurutan nilai yang akan dibahas pada makalah ini adalah count sort
(pengurutan dengan mencacah), selection sort (pengurutan dengan menyeleksi), insertion sort
(pengurutan dengan penyisipan), quick sort (pengurutan cepat), merge sort (pengurutan
dengan penggabungan),shell sort (pengurutan cangkang, dan bubble sort (pengurutan
gelembung). Algoritma pengurutan nilai yang dibahas pada makalah ini adalah algoritma
untuk pemrosesan tabel yang berisi data bertipe integer.
Masing-masing jenis algoritma mempunyai tingkat kemangkusan (keefektifan) yang berbeda
Kemangkusan (keefektifan) dari suatu algoritma dapat diukur dari berapa jumlah waktu dan
ruang (space/memory) yang dibutuhkan untuk menjalankan algoritma tersebut. Algoritma yang
mangkus adalah algoritma yang dapat meminimumkan kebutuhan waktu dan ruang. Semakin
sedikit ruang yang dibutuhkan untuk menjalankan suatu algoritma, maka semakin mangkus
algoritma tersebut. Dan semakin sedikit waktu yang dibutuhkan untuk menjalankan suatu
algoritma, maka semakin mangkus algoritma tersebut. Namun kebutuhan waktu dan ruang dari
suatu algoritma bergantung pada jumlah data yang diproses dan algoritma yang digunakan.
Karena kompleksitas ruang terkait dengan struktur data yang digunakan dan di luar bahasan
mata kuliah IF2153 Matematika Diskrit, maka kompleksitas ruang tidak akan dibahas pada
makalah ini. Makalah ini hanya akan membahas dan menganalisa kompleksitas waktu untuk
masing-masing jenis algoritma.

5. 2
BAB I
PENDAHULUAN
Dalam pemrosesan suatu data tidak lepas dari struktur data berupa tabel (array). Tabel
adalah suatu tipe yang mengacu pada sebuah atau sekumpulan elemen dan dapat diakses
melalui indeks. Elemen dari tabel dapat diakses langsung jika dan hanya jika indeks
terdefinisi (ditentukan harganya dan sesuai dengan domain yang didefinisikan untuk indeks
tersebut). Struktur data ini dipakai untuk merepresentasikan sekumpulan data yang bertipe
sama (misal : integer, karakter) dan disimpan dengan urutan yang sesuai dengan definisi
indeks secara kontigu dalam memori komputer. Untuk makalah ini akan dibahas tabel
dengan sekumpulan elemen yang bertipe integer. Pemrosesan terhadap struktur data tabel
dapat dilakukan secara linear (sequential) ataupun rekursif.
Pemrosesan terurut terhadap suatu tabel adalah pemrosesan terurut tanpa mark. Akses
terhadap elemen-elemen yang ada dalam tabel dilakukan dengan memanfaatkan keterurutan
indeks. Elemen tabel dengan indeks terkecil adalah elemen pertama dari tabel. Elemen
selanjutnya dapat diakses melalui suksesor indeks. Kondisi berhenti adalah jika indeks
sudah mencapai harga indeks terbesar yang telah terdefinisi. Struktur data tabel tidak
mungkin kosong. Jika kita mendefinisikan suatu tabel, maka minimal mengandung sebuah
elemen.
Skema umum pemrosesan terhadap tabel integer adalah (ditulis dalam notasi algoritmik)
sebagai berikut.
KAMUS UMUM PEMROSESAN TABEL INTEGER
constant Nmin: integer = 1 constant Nmax: integer = 100
{Nmin dan Nmax : batas bawah dan batas atas yang ditentukan}
type Infotype: integer
{suatu tipe terdefinisi, yaitu integer}
T: array [Nmin..Nmax] of infotype
{tabel T yang didefinisikan dengan indeks dari Nmin sampai Nmax dengan elemen
bertipe infotype}

6. 3
procedure Inisialisasi
{persiapan yang harus dilakukan sebelum pemrosesan}
procedure Proses (input x:int)
{proses terhadap “current- element” pada tabel T}
procedure Terminasi
{penutuoan yang harus dilakukan setelah pemrosesan selesai}
SKEMA PEMROSESAN TABEL T UNTUK INDEKS [Nmin..Nmax]
{traversal tabel T untuk indeks bernilai Nmin..Nmax}
Skema:
Inisialisasi i ← Nmin iterate
Proses (Ti)
stop : i = Nmax {EOP}
i ← i + 1 {Next element} Terminasi
Skema pemrosesan tersebut hanyalah skema umum dari pemrosesan terhadap sebuah tabel.
Tidak menutup kemungkinan suatu proses terhadap tabel dapat mempunyai skema yang
berbeda dari skema umum.
Pemrosesan yang paling sering dilakukan terhadap suatu tabel bertipe integer adalah
pencarian nilai (searching) dan pengurutan nilai (sorting). Untuk pencarian dan pengurutan
nilai terdapat berbagai macam jenis algoritma yang dapat digunakan dengan tingkat
keefektifan yang berbeda. Untuk pencarian nilai, ada beberapa jenis metode yaitu pencarian
secara linear (sequential search) dan pencarian biner (binary search) untuk table yang telah
terurut nilainya (sorted tabel). Pencarian secara linear mempunyai dua jenis metode yaitu
dengan boolean dan tanpa boolean. Untuk pengurutan nilai ada beberapa jenis algoritma
yaitu count sort (pengurutan dengan mencacah), selection sort (pengurutan dengan
menyeleksi), insertion sort (pengurutan dengan penyisipan), quick sort (pengurutan cepat),
merge sort (pengurutan dengan penggabungan), heap sort (pengurutan dengan tumpukan),
shell sort (pengurutan cangkang), dan bubble sort (pengurutan gelembung).
Masing-masing metode mempunyai kelebihan dan kekurangan, dari panjang pendeknya
kode, kompleksitas kode, waktu pemrosesan, memori yang digunakan, kompatibilitas, dan
lain sebagainya. Namun keefektifan suat u algoritma dapat diukur atau dihitung dengan
menggunakan teori kompleksitas algoritma yang dipelajari pada mata kuliah matematika
diskrit. Algoritma yang mangkus adalah algoritma yang dapat meminimumkan kebutuhan
waktu dan ruang. Namun kebutuhan waktu dan ruang dari suatu algoritma bergantung pada
jumlah data yang diproses dan algoritma yang digunakan. Karena kompleksitas ruang terkait

7. 4
dengan struktur data yang digunakan dan di luar bahasan mata kuliah IF2153 Matematika
Diskrit, maka kompleksitas ruang tidak akan dibahas pada makalah ini. Makalah ini hanya
akan membahas dan menganalisa kompleksitas waktu untuk masing- masing jenis algoritma.
Kompleksitas waktu untuk algoritma-algoritma yang dibahas akan dinyatakan dengan
notasi O besar (Big-O notation). Definisi dari notasi O besar adalah, jika sebuah algoritma
mempunyai waktu asimptotik O(f(n)), maka jika n dibuat semakin besar, waktu yang
dibutuhkan tidak akan pernah melebihi suatu konstanta C dikali dengan f(n). Jadi f(n)
adalah adalah batas atas (upper bound) dari T(n) untuk n yang besar.
O(n) dihitung berdasarkan banyaknya jumlah operasi perbandingan yang dilakukan dalam
algoritma tersebut.

8. 5
BAB II
METODE PEMBAHASAN
2.1.Pengertian Pengurutan Cangkang (Shell Sort)
Shell sort merupakan salah satu sorting algoritma pada sebuah deklarasi array ([]).
Proses shell sort berbeda dengan sorting algoritma yang lainnya, pada sorting algoritma yang
lainnya lebih banyak menukarkan data secara berurutan atau memindah satu persatu. Selain
itu proses pengurutan data akan berhenti jika proses = jumlah data – 1.
Pengurutan data pada sorting algoritma shell sort berbeda dengan yang lainnya, banyak yang
mengatakan bahwa proses terakhir shell sort sama atau mirip dengan proses insertion sort
karena bentuk atau prosesnya yang juga hampir sama dengan sorting Insertion sort.
Pada pengurutan data ini kita terlebih dahulu harus membuat sub list – sub list yang di
dasarkan pada jarak antar data yang di tentukan. Jarak yang di telah di tentukan biasanya di
lambangkan dengan k, biasanya jarak yang paling di gunakan pada sorting ini saat melakukan
pengurutan data yaitu k5, k3, dan k1. Artinya, dari data yang akan di tentukan atau ditukar
dengan data yang lain berjarak 5, 3 atau 1 data saja.
2.2. Metode Shell Sort
Pemilihan Sequence number :
1. Disarankan jarak mula-mula dari data yang akan dibandingkan adalah (N/2)+1).
2. Pada proses berikutnya, digunakan jarak (N/4)+1).
3. Pada proses berikutnya, digunakan jarak (N/8)+1).
4. Demikian seterusnya sampai jarak yang digunakan adalah 1.
Proses Pengurutannya :
1. Untuk jarak (N/2)+1:
- Data pertama (i=0) dibandingkan dengan data dengan jarak (N/2)+1. Apabila data pertama
lebih besar dari data ke (N/2)+1) tersebut maka kedua data tersebut ditukar.
- Kemudian data kedua (i=1) dibandingkan dengan jarak yang sama yaitu (N/2)+1) = elemen

9. 6
ke-(i+N/2)+1.
- Demikian seterusnya sampai seluruh data dibandingkan sehingga semua data ke-i selalu
lebih kecil dari pada data ke-(i+N/2)+1.
2. Ulangi langakah-langkah diatas untuk jarak = (N/4)+1 kemudian lakukan pembandingan dan
pengurutan sehingga semua data ke-i lebih kecil daripada data ke-(i+N/4)+1.
3. Ulangi langakah-langkah diatas untuk jarak = (N/8)+1 kemudian lakukan pembandingan dan
pengurutan sehingga semua data ke-i lebih kecil daripada data ke-(i+N/8)+1.
4. Demikian seterusnya sampai jarak yang digunakan adalah 1 atau data sudah terurut .
Misal kita ingin mengurutkan data dengan type pengurutan Descending, data yang akan di
urutkan adalah 29, 60, 55, 43, 19, 99, 90, 30.
Proses 1 buatlah k5.
Ingat sorting array [] selalu di mulai dari 0.
Dari data di atas maka akan mengalami perubahan seperti di bawah ini.
Dapat kita lihat data yang mengalami perubahan adalah data ke [0] dan data ke [1] dengan
pasangannya data ke [5] dan data ke [6]. Data ke [0] (29) dan data ke [5] (99) mengalami
perubahan karena data ke [5] lebih besar dari data ke [0].
Perubahan ke 2 pada data ke [1] dengan pasangannya data ke [6], mengalami perubahan
karena data ke [6] (90) lebih besar dari data ke [1] (60). Sehingga k5 menghasilkan data

10. 7
Selanjutnya adalah proses k3, artinya jarak pindah data adalah 3 dari data yang akan di
pindahkan.
Proses k3
Dari proses k3 maka akan mengalami perubahan yaitu
Dari perubahan tersebut dapat kita lihat, pertukaran pertama yaitu data k3 [0], [3] dan [6].
Pada data ke [0] dengan data ke [3] tidak mengalami perubahan karena data ke [0] (99) lebih
besar dari data ke [3] (49). Tetapi mengalami perubahan saat data ke [3] bertemu dengan data
ke [6] yaitu 60 lebih besar dari pada 49.
Pertukaran garis k3 yang ke 2, mengalami perubahan saat data ke [4] bertemu dengan data ke [7]
karena data ke [7] lebih besar dari data ke [4].
Pengurutan shell sort yang terakhir adalah proses k1 yang artinya membandingkan data
secara satu persatu dengan data berikutnya.

11. 8
Proses k1
Mengalami perubahan seperti gambar di bawah ini
Proses di lakukan berdasarkan urutan kolom atau data terbesar maka data tersebut akan di
eksekusi atau di pindahkan dengan data yang sesuai atau yang semestinya menepati posisi
data tersebut.
Pada proses k1 terdapat 3 kali pemidahan data.
Proses1
Data ke [3] di pindah ke posisi data ke [2] karena lebih besar dari data ke [2].
Proses selanjutnya, proses2
Data ke [6] dipindah ke posisi data [4] karena lebih besar dari data [4]
Proses terkahir, proses3

12. 9
Data ke [6] dipindah menjadi data ke [5] karena lebih besar dari data ke [5]. Proses selesai,
data telah terurut sesuai denga type pengurutnan yaitu descending. Untuk pengurutan data
dalam bentuk ascending sama saja, hanya berbeda pada peletakannya saja yaitu data berawal
dari data yang paling rendah ke data yang paling besar nilainya.
2.3. Kelebihan dan Kekurangan Shell Sort
Kelebihan
1. Algoritma ini sangat rapat dan mudah diimplementasikan.
2. Operasi pertukarannya hanya dilakukan sekali saja.
3. Waktu pengurutan dapat lebih ditekan.
4. Mudah menggabungkannya kembali.
5. Kompleksitas selection sort relative lebih kecil.
Kekurangan
1. Membutuhkan metode tambahan.
2. Sulit untuk membagi masalah.
2.4. Source Code Shell Sort
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#define MAX 100
#define INPUT 'i'
#define OUTPUT 'o'
#define _MY_DEBUG
#if defined(_MY_DEBUG)
#define TRACE_LINE printf("nn- Program Statistics :n1. File : %sn2. Date : %sn3.
Time : %sn",__FILE__,__DATE__,__TIME__);
#else
#define TRACE_LINE
#endif

13. 10
// int CheckForBadSorting(int*, const int);
void ShellSortPass(int*, const int, const int);
void ShellSort(int*, const int);
void InputOutput(int*, const int, const char);
void FreeBuffer(int*);
int main(int argc, char* argv[]) {
system("COLOR 5");
int *buffer = NULL, max;
printf("Implementasi Shell SortnMasukkan jumlah data [MAX:100] : ");
scanf("%d",&max);
fflush(stdin);
if((max > 0) && (max <= MAX)) {
buffer = (int*)calloc(max,sizeof(int));
InputOutput(buffer,max,INPUT);
printf("nData yang anda masukkan : ");
InputOutput(buffer,max,OUTPUT);
ShellSort(buffer,max);
printf("nData setelah disorting : ");
InputOutput(buffer,max,OUTPUT);
FreeBuffer(buffer);
/* if(CheckForBadSorting(buffer,max)) {
goto MARK;
} else {
InputOutput(buffer,max,OUTPUT);
} */
} /* MARK : if(buffer != NULL) {
FreeBuffer(buffer);
} */
TRACE_LINE;
getch();
fflush(stdin);
return(EXIT_SUCCESS);
}
/* int CheckForBadSorting(int* buffer, const int max) {
int i;
for(i = 1; i < max; ++i) {
if(buffer[i-1] > buffer[i]) {
printf("Bad Sorting!");

14. 11
return(1);
}
}
return(0);
} */
void ShellSortPass(int* buffer, const int max, const int interval) {
int i;
for(i = 0; i < max; ++i) {
int j, tmp = buffer[i];
for(j = i-interval; j >= 0; j -= interval) {
if(buffer[j] <= tmp) {
break;
} buffer[j+interval] = buffer[j];
} buffer[j+interval] = tmp;
}
}
void ShellSort(int* buffer, const int max) {
int CiuraIntervals[] = {701, 301, 132, 57, 23, 10, 4, 1},
IntervalIdx = 0, interval = CiuraIntervals[0];
double ExtendCiuraMultiplier = 2.3;
if(max > interval) {
while(max > interval) {
--IntervalIdx;
interval = (int)(interval*ExtendCiuraMultiplier);
}
} else {
while(max < interval) {
++IntervalIdx;
interval = CiuraIntervals[IntervalIdx];
}
}
while(interval > 1) {
++IntervalIdx;
if(IntervalIdx >= 0) {
interval = CiuraIntervals[IntervalIdx];
} else {
interval = (int)(interval/ExtendCiuraMultiplier);
} ShellSortPass(buffer,max,interval);

15. 12
}
}
void InputOutput(int* buffer, const int max, const char STAT) {
int i;
if('i' == STAT) {
for(i = 0; i < max; ++i) {
printf("%d. Data ke-%d : ",(i+1),(i+1));
scanf("%d",&buffer[i]);
fflush(stdin);
}
} else if('o' == STAT) {
for(i = 0; i < max; ++i) {
printf("%d ",buffer[i]);
}
}
}
void FreeBuffer(int* buffer) {
free(buffer);
buffer = NULL;
}
OUTPUT:

16. 13
BAB III
PENUTUP
3.1. Kesimpulan
Pengurutan nilai (sorting) adalah operasi yang paling sering dilakukan pada sebuah
tabel. Jenis algoritma untuk pengurutan nilai sangat banyak dengan tingkat keefektifan yang
berbeda - beda untuk masing-masing kasus.
Untuk melakukan pengurutan nilai, algoritma yang paling sederhana dan paling
mudah dimengerti adalah algoritma count sort. Namun algoritma ini tidak efektif untuk
digunakan pada tabel dengan range yang besar.
Algoritma-algoritma pengurutan nilai lainnya, dapat dibagi menjadi dua kelompok.
Algoritma berkompleksitas O(n2
), yaitu pengurutan gelembung (bubble sort), pengurutan
dengan penyisipan (insertion sort), pengurutan dengan menyeleksi (selection sort), dan
pengurutan cangkang (shell sort). Algoritma berkompleksitas O(n log n), yaitu pengurutan
dengan penggabungan (heap sort), pengurutan dengan penggabungan (merge sort), dan
pengurutan cepat (quick sort).

17. 14
DAFTAR PUSTAKA
[1] Munir, Rinaldi. (2003). Matematika Diskrit. Departemen Teknik Informatika, Institut
Teknologi Bandung.
[2] Liem, Inggriani. (2003). Catatan Kuliah Algoritma dan Pemrograman. Departemen
Teknik Informatika, Institut Teknologi Bandung.
[3] Bucknall,Julian (2001). Algorithms and Data Structures. Wordware Publishing.
[4] Wikipedia. Pencarian biner. http://id.wikipedia.org
[5] Michael Lamont. The sorting algorithms. http://linux.wku.edu/~lamonml/algor/sort/in
dex.html.
[6] Computer Science. http://www.cs.hope.edu.