MAKALAH

ALGORITMA DAN DASAR PEMOGRAMAN

Algoritma Pengurutan (Sorting)

DOSEN PENGAMPU : Amirhud Dalimunthe, S.T., M.Kom.

Kelompok IX :

Juli Elprida Hutagalung (5173351019)

Nancy Ariska Siahaan (5173351032)

Rifandy Fadhillah (5173351037)

FAKULTAS TEKNIK

PRODI PENDIDIKAN TEKNOLOGI INFORMATIKA DAN KOMPUTER

UNIVERSITAS NEGERI MEDAN

MEDAN

2017
 KATA PENGANTAR

Puji dan syukur kami ucapkan kepada Tuhan Yang Maha Esa karena atas berkat dan
rahmatnya kami dapat menyelesaikan makalah yang berjudul “Algoritma Pengurutan
(Sorting)”. Adapun makalah ini kami buat dalam memenuhi tugas dari mata kuliah
Algoritma dan dasar Pemrograman yang telah di berikan oleh Dosen Pengampu Bapak
Amirhud Dalimunthe, S.T., M.Kom. Kami berharap makalah ini dapat bermanfaat bagi
pembaca dalam menambah pengetahuan tentang Algoritma pengurutan (sorting)
Kami ucapkan termakasih kepada pihak-pihak yang telah membantu kami dalam
menyelesaikan makalah ini. Serta kami juga tidak lupa mengucapkan terimakasih kepada
dosen pengampu yang juga bersedia membimbing kami dalam menyusun makalah ini.
Kami mohon maaf apa bila ada kekurangan dan kesalahan dalam tulisan makalah ini
karena pada dasarnya kami masih mahasiswa yang masih dalam proses tahap
pembelajaran. Kami harapkan adanya saran dan kiritikan pada makalah kami ini supaya
makalah kami ini menjadi lebih baik.
Atas perhatiannya kami ucapkan TERIMAKASIH.

Medan, 16 Desember 2017

Kelompok IX

ii
 DAFTAR ISI

HALAMAN JUDUL...............................................................................................................i
KATA PENGANTAR...........................................................................................................ii
DAFTAR ISI.........................................................................................................................iii
1.1 Latar Belakang..............................................................................................................1
1.2 Rumusan Masalah........................................................................................................1
1.3 Tujuan...........................................................................................................................1
BAB II PEMBAHASAN.......................................................................................................2
2.1 Masalah Pengurutan.....................................................................................................2
2.2 Algoritma Pengurutan..................................................................................................3
2.3 Algoritma Pengurutan Apung.....................................................................................10
2.4 Algoritma Pengurutan Seleksi....................................................................................12
2.5 Algoritma Pengurutan Sisip.......................................................................................17
2.6 Pengurutan Pada Array Terstruktur............................................................................21
BAB III PENUTUP..............................................................................................................23
3.1 Kesimpulan.................................................................................................................23
3.2 Saran...........................................................................................................................23
DAFTAR PUSTAKA..........................................................................................................24

iii
 BAB I
PENDAHULUAN

1.1 Latar Belakang

Bahasa pemograman sangat dibutuhkan dalam keperluan tertentu, karena pekerjaan
kita pada saat ini selalu mengikuti kemajuan teknologi. Dari program pengurutan data
terdapat algoritma-algoritma yang digunakan untuk menguruutkan sebuah data, salah
satunya adalah sorting

Adapun Kelebihan Sorting adalah untuk memudahkan dalam pencarian data, dan
juga agar data lebih sestematis karena terurut. Sehingga metode pengurutan dengan
menggunakan sorting sangat bermanfaat dalam pencarian data.

Pada makalah ini kami memilih metode sorting, karena melihat keunggulan yang
dimiliki oleh sorting. Oleh karena itu sorting sangat bermanfaat untuk pencarian data.

1.2 Rumusan Masalah

1. Apakah saja masalah pengurutan dalam algoritma pengurutan ?

2. Apakah yang dimaksud dengan algoritma pengurutan?

3.Apakah yang dimaksud dengan algoritma pengurutan apung?

4. Apakah yang dimaksud dengan algoritma pengurutan seleksi?

5. Apakah yang dimaksud dengan algoritma pengurutan sisip?

6. Apakah yang dimaksud dengan pengurutan pada array terstruktur?

1.3 Tujuan
1. Dapat menjelaskan algoritma pengurutan (sorting).

2. Memenuhi tugas dari mata kuliah algoritma dan dasar pemrogaman.

1
 BAB II
PEMBAHASAN

2.1 Masalah Pengurutan

Dalam Ilmu Komputer, Algoritme Sorting merupakan algoritme yang menempatkan

elemen list pada urutan tertentu. Urutan yang paling sering digunakan ialah urutan
numerikal dan urutan lexicographical. Sorting yang efisien sangat dibutuhkan untuk
mengoptimisasi penggunaan dari algoritme lain seperti pencarian dan penggabungan yang
membutuhkan list terurut untuk berjalan dengan sempurna, yang juga sering digunakan
untuk Canonicalisisasi data dan menghasilkan output yang dapat dibaca manusia. Untuk
lebih lanjutnya, output harus melengkapi dua syarat ini:

1. Output merupakan urutan yang tidak menurut (nondecreasing) (setiap elemen tidak
lebih kecil dari elemen sebelumnya menurut dari urutan keseluruhan yang
diinginkan.
2. Output merupakan permutasi (pengurutan kembali) dari inputan yang diberikan.

Sejak permulaan komputasi, masalah pengurutan ini telah menarik penelitian yang
serius, mungkin dikarenakan kerumitan dari penyelesaian secara efisien disamping mudah,
dan dengan statemen yang kita mengerti. Sebagai contoh, bubble sort pertama sekali
ditemukan pada tahun 1956.[1] Walaupun banyak yang memperkirakan masalahnya telah
terselesaikan, banyak algoritme sorting baru yang masih ditemukan samap sekarang
(sebagai contoh, Library Sort yang baru dipublikasikan pertama sekali pada tahun 2006).
Algoritme sorting sangat umum pada setiap kelas pengenalan bidang Ilmu Komputer,
dimana banyaknya algoritme untuk masalah ini menyediakan pengenalan awal mengenai
banyaknya konsep algoritme inti, seperti Notasi Big O, Algoritme Pembagi, Struktur Data,
Algoritme Acak, Analisa Best, Worst, Average Case, Running Time Calculation, dan
Batas Atas dan Bawah.

2
2.2 Algoritma Pengurutan
Pengaturan (Sorting) didefinisikan sebagai pengurutan sejumlahdata berdasarkan
nilai kunci tertentu. Pengurutan dapat dilakukan dari nilai terkecil ke nilai terbesar
(ascending) atau sebaliknya (descending).Algoritma Sorting termasuk salah satu contoh
yangkaya akan solusi. Dalam makalah ini, hanya akan dibahas lima algoritma sorting yang
populer dipakai didunia informatika.

Bubble Sort

Bubble Sort merupakan cara pengurutan yang sederhana. Konsep dari ide dasarnya
adalah seperti “gelembung air” untuk elemen struktur data yang semestinya berada pada
posisi awal. Cara kerjanya adalah dengan berulang-ulang melakukan traversal (proses
looping) terhadap elemen-elemen struktur datayang belum diurutkan. Di dalam traversal
tersebut, nilai dari dua elemen struktur data dibandingkan. Jika ternyata urutannya tidak
sesuai dengan “pesanan”, maka dilakukan pertukaran (swap). Algoritma sortingini disebut
juga dengan comparison sort dikarenakanhanya mengandalkan perbandingan nilai elemen
untuk mengoperasikan elemennya.

Algoritma bubble sort dapat diringkas sebagai berikut, jika N adalah panjang
elemen struktur data, dengan elemen-elemennya adalah T1, T2, T3, …, TN-1,TN, maka:

1. Lakukan traversal untuk membandingkan dua elemen berdekatan. Traversal ini

dilakukan dari belakang.
2. Jika elemen pada TN-1 > TN , maka lakukan pertukaran (swap). Jika tidak,
lanjutkan ke proses traversal berikutnya sampai bertemu dengan bagian struktur
data yang telah diurutkan.
3. Ulangi langkah di atas untuk struktur data yang tersisa.

Pseudocode dari bubble Sort adalah sebagai berikut;

  For I = 0 to N - 2

       For J = 0 to N - 2

         If (A(J) > A(J + 1)

3
           Temp = A(J)

           A(J) = A(J + 1)

           A(J + 1) = Temp

         End-If

       End-For

     End-For

Selection Sort

Selection Sort adalah sort yang melakukan beberapa kali pass untuk melakukan
penyeleksian elemen struktur data. Untuk sorting ascending (menaik), elemen yang paling
kecil di antara elemen-elemen yang belum urut, disimpan indeksnya, kemudian dilakukan
pertukaran nilai elemen dengan indeks yang disimpan tersebut dengan elemen yang paling
depan yang belum urut. Sebaliknya, untuk sorting descending (menurun), elemen yang
paling  besar yang disimpan indeksnya kemudian ditukar.

Algoritma selection sort dapat dirangkum sebagai berikut:

1. Temukan nilai yang paling minimum (atau sesuai keinginan) di dalam struktur
data. Jika ascending, maka yang harus ditemukan adalah nilai yang paling
minimum. Jika descending, maka temukan nilai yang paling maksimum.
2. Tukar nilai tersebut dengan nilai pada posisipertama di bagian struktur data yang
belum diurutkan.
3. Ulangi langkah di atas untuk bagian struktur datayang tersisa.

Pseudocode dari selection Sort adalah sebagai berikut;

  For I = 0 to N-1 do:

       Smallsub = I

       For J = I + 1 to N-1 do:

         If A(J) < A(Smallsub)

           Smallsub = J

4
         End-If

       End-For

       Temp = A(I)

       A(I) = A(Smallsub)

       A(Smallsub) = Temp

     End-For

Insertion Sort

Metode pengurutan pada insertion sort adalah metode dengan cara menyisipkan ele
men larik pada posisi yang tepat.Cara kerja insertion sort, Pertama-tama, dilakukan iterasi,
dimana di setiap iterasi insertion sort memindahkan nilai elemen,kemudian
menyisipkannya berulang-ulang sampai ketempat yang tepat. Begitu seterusnya dilakukan. 
Dari proses iterasi, seperti biasa, terbentuklah bagian yang telah di-sorting dan bagian yang
belum di-sorting.

Algoritma Insertion Sort dapat dirangkum sebagai berikut:

1. Simpan nilai Ti kedalam variabel sementara, dengan i = 1.

2. Bandingkan nilainya dengan elemen sebelumnya.
3. Jika elemen sebelumnya (Ti-1) lebih besar nilainya daripada Ti, maka tindih nilai
Ti dengan nilai Ti-1 tersebut. Decrement i (kurangi nilainya dengan 1).
4. Lakukan terus poin ke-tiga, sampai Ti-1 ≤ Ti.
5. Jika Ti-1 ≤ Ti terpenuhi, tindih nilai di Ti dengan variabel sementara yang disimpan
sebelumnya.
6. Ulangi langkah dari poin 1 di atas dengan i di-increment (ditambah satu).

Pseudocode dari Insertion Sort adalah sebagai berikut;

procedure insertion;

   var i,j,v: integer;

   begin

5
for i:=2 to N do

begin

v:=a[i];j:=1;

while a[j1] > v do

 begin a[j]:=a[j1]; j:=j1 end;

a[j]:=v;

end

end;

Merge Sort

Algoritma Merge Sort ditemukan oleh John vonNeumann di tahun 1945. Merge

Sort termasuk paradigma algoritma divide and conquer (kurang lebih berarti: bagi dan
atasi). Hal ini dikarenakan algoritma ini melakukan pembagian struktur data sebelum
kemudian dioperasi satu per satu. Intinya, algoritma ini menggunakan dua ide utama
sebagai berikut,

1. Sebuah list yang kecil membutuhkan langkah yang lebih sedikit untuk pengurutan
daripada sebuah list yang besar.
2. Untuk membentuk sebuah list terurut dari duabuah list terurut membutuhkan
langkah yangl ebih sedikit daripada membentuk sebuah list terurut dari dua buah
list tak terurut. Contoh:hanya diperlukan satu kali traversal untuk masing-masing
list jika keduanya sudahterurut.

Algoritma Merge Sort sederhananya, dapat ditulis berikut:

1. Bagi list yang tak terurut menjadi dua sama panjang atau salah satunya lebih
panjang satu elemen.
2. Bagi masing-masing dari 2 sub-list secara rekursif sampai didapatkan list dengan
ukuran 1.
3. Gabung 2 sublist kembali menjadi satu list terurut.

Berikut ini adalah tiga proses di dalam menggunakan algoritma Merge Sort :

6
Divide      :     Bagi array A[l..r] dengan jumlah elemen n menjadi dua subarray
dengan jumlah elemen masingmasing subarray sebanyak n/2.

Conqueror :     Urutkan masing-masing subarray secara rekursif menggunakan prosedur

merge sort

Combine  :      Satukan subarray untuk menghasilkan elemen array A[l..r] yang terurut.

Berikut ini adalah algoritma untuk Merge Sort array A[l..r]:

Merge-Sort (A,l,r)

1.  if l < r

2.     then q :=  [(l+r) /2]

3.     Merge-Sort(A,l,q)

4.     Merge-Sort(A,q+1,r)

5.     Merge(A,p,q,r)

Sedangkan algoritma untuk prosedure Merge adalah sebagai berikut :

MERGE ( A, l, q, r)

1.  n1 ← q − l + 1

2.  n2 ← r − q

3.  create arrays L[1 . . n 1 + 1] and R[1 . . n 2 + 1]

4.  for i ← 1 to n 1

5.          do L[i] ← A[ l + i − 1]

6.  for j ← 1 to n 2

7.          do R[ j ] ← A[q + j ]

8.  L[n 1 + 1] ← ∞

9.  R[n 2 + 1] ← ∞

10. i ← 1

7
11. j ← 1

12. for k ← l to r

13.          do if L[i] ≤ R[ j ]

14.                then A[k] ← L[i]

15.                      i ←i +1

16.                else A[k] ← R[ j ]

17.                       j ← j +1

Quick Sort

Quick Sort adalah algoritma sorting yang terkenal yang dirancang oleh C.A.R.
Hoare pada tahun 1960 ketika bekerja untuk perusahaan manufaktur komputer saintifik
kecil, Elliott Brothers. Algoritma ini rekursif, dan termasuk paradigma algoritma divide
and conquer.

Algoritma ini terdiri dari 4 langkah utama:

1. Jika struktur data terdiri dari 1 atau 0 elemen yang harus diurutkan, kembalikan
struktur data itu apa adanya.
2. Ambil sebuah elemen yang akan digunakansebagai pivot point (poin poros). 
(Biasanya elemen yang paling kiri.)
3. Bagi struktur data menjadi dua bagian – satu dengan elemen-elemen yang lebih
besar daripada pivot point, dan yang lainnya dengan elemen-elemen yang lebih
kecil dari pada pivot point.
4. Ulangi algoritma secara rekursif terhadap kedua paruh struktur data.

Berikut adalah tiga proses di dalam metode divide dan conqueror untuk algoritma

Quick Sort :

Divide        :  Bagi array A[l..r] menjadi dua subarray A[l..pivot-1] dan A[pivot+1..r]

sehingga setiap elemen di dalam sub array A[l..pivot1] bernilai lebih kecil atau
sama dengan A[pivot]. Untuk menghitung nilai pivot merupakan bagian dari
prosedur partition.

8
Conqueror :  Urutkan subarray A[l..pivot1] dan A[pivot+1..r] secara rekursif ke prosedur
quicksort

Combine : Karena subarray sudah terurut, maka array A[l..r] sudah terurut.

Pseudocode dari algoritma quick sort adalah sebagai berikut:

procedure quicksort(l,r:integer);

   var pivot: integer;

   begin

for r > l then

begin

 pivot:=partition(l,r);

 quicksort(l,pivot1);

 quicksort(pivot+1,r);

end

end;

Algoritma dari partisi array A[l..r] adalah :

x := A[r]

i := l-1

for j := l to r-1

do if A[j] <= x

then i := i + 1

exchange A[i] with A[j]

exchange A[i+1] with A[r]

return i+1

9
2.3 Algoritma Pengurutan Apung

Algoritma pengurutan apung (bubble sort) diinspirasi oleh gelembung sabun yang
berada di atas permukaan air. Karena berat jenis gelembung sabun lebih ringan daripada
berat jenis air, maka gelembung sabun selalu terapung ke atas permukaan. Secara umum,
benda-benda yang berat akan terbenam dan benda-benda yang ringan akan terapung ke
permukaan.

Prinsip pengapungan di atas juga digunakan pada pengurutan apung. Apabila kita
menginginkan larik terurut naik, maka elemen yang berharga paling kecil diapungkan,
artinya diangkat ke “atas” atau ke ujung kiri larik melalui proses pertukaran. Proses
pengapungan ini dilakukan sebanyak n-1 langkah (satu langkah disebut juga satu kali pass)
dengan n adalah ukuran larik. Pada akhir setipa langkah ke-i, larik L[1..n] akan terdiri atas
dua bagian, yaitu bagian yang sudah terurut L[1..i] dan bagian yang belum terurut
L[i+1..n]. Setelah langkah terakhir, diperoleh larik L[1..n] yang terurut menaik.

Untuk mendapatkan larik yang terurut menaik, algoritma pengurutan apung secara
global sebagai berikut :

Untuk setiap pass i=1,2,…..n-1 lakukan;

Mulai dari elemen k=n,n-1,…i+1, lakukan;

1.1 Bandingkan L[k] dengan L[k-1].

1.2 Pertukaran L[k] dengan L[k-1] jika L[k]<L[k-1]

Rincian setiap pass sebagai berikut :

Pass 1
Mulai dari elemen ke-k=n, n-1,….2, bandingkan L[k] denagn L[k-1]. Jika, L[k]<L[k-1],
pertukarkan L[k] dengan L[k-1]. Pada akhir langkah 1, elemen L[1] berisi harga minimum
pertama.

10
Pass 2

Mulai dari elemen ke-k=n, n-1, …,3, bandingkan L[k] dengan L[k-1]. Jika,
L[k]<L[k-1], pertukarkan L[k] dengan L[k-1]. Pada akhir langkah 2, elemen L[2] berisi
harga minimum kedua, larik L[1..2] terurut sedangkan L[3..n] belum terurut.

Pass 3

Mulai dari elemen ke-k=n, n-1, …,4, bandingkan L[k] dengan L[k-1]. Jika,
L[k]<L[k-1], pertukarkan L[k] dengan L[k-1]. Pada akhir langkah 2, elemen L[2] berisi
harga minimum kedua, larik L[1..3] terurut sedangkan L[4..n] belum terurut.

Pass n-1

Mulai dari elemen ke-k=n, bandingkan L[k] dengan L[k-1]. Jika, L[k]<L[k-1],
pertukarkan L[k] dengan L[k-1]. Pada akhir pass n-1, elemen L[n-1] berisi nilai minimum
ke-(n-1) dan larik L[1..n-1] terurut menaik (elemen yang tersisa adalah L[n], tidak perlu
diurut karena hanya satu-satunya).

Prosedure Bubble Sort (input/output L : LarikInt, input n : integer)

{ mengurutkan larik L[n-1] sehingga terurut menaik dengan metode pengurutan apung}

{ K.Awal : Elemen larik L sudah terdefenisi nilai-nilainya}

{ K. Akhir : Elemen larik L terurut menaik sedemikian hingga L[1]<=L[2]…L[n]}

DEKLARASI

i : integer (pencacah untuk jumlah langkah)

k : integer (pencacah untuk setiap pengapungan pada setiap langkah)

temp : integer (peubah bantu untuk pertukaran)

ALGORITMA

11
 for i<–1 to n – 1 do

for k<–n downto i+1 do

if L[k]<L[k-1] then

{pertukaran L[k] dengan L[k-1]}

temp <–L[k]

L[k]<–L[k-1]

L[k-1]<–temp

endif

endif

endif

Untuk memperoleh larik yang terurut menurun, kita melakuka proses sebaliknya
yaitu “melemparkan” elemen yang berharga maksimum ke “atas” (ke ujung kiri larik).
Algortima nya hanya mengganti bagian L[k]<L[k-1] menjadi L[k]>L[k-1]

2.4 Algoritma Pengurutan Seleksi

Algoritma pengurutan ini disebut pengurutan seleksi (selection sort) karena
gagasan pada dasarnya adalah memiliki elemen maksimum / minimum dari larik, lalu
menempatkan elemen maksimum / minimum itu pada awal atau akhir larik (elemen
terujung).

Ada dua variasi algoritma pengurutan seleksi ditinjau dari pemilian elemen maksimum /
minimum, yaitu :

1.      Algoritma pengurutan seleksi-maksimum, yaitu memilh elemen maksimum sebagai basis

pengurutan.

2.      Algoritma pengurutan seleksi-minimum, yaitu memilih elemen minimumsebagai basis

pengurutan.

12
Algoritma Pengurutan Seleksi-Maksimum Ascending

Tinjau larik dengan n = 6 buah elemen dibawah ini belum terurut. Larik ini akan
diurut menaik dengan metode seleksi-maksimum :

29 27 10 8 76 21
1 2 3 4 5 6

Proses 1

Cari elemen maksimum didalam larik L[1..6], maka hasilnya : maks = L[5] = 76.
Pertukaran maks dengan L[n], diperoleh :

29 27 10 8 21 76
1 2 3 4 5 6
Proses 2

(Berdasarkan susunan larik hasil proses 1)

Cari elemen maksimum didalam larik L[1..5], maka hasilnya : maks = L[1] = 29.
Pertukaran maks dengan L[5], diperoleh :

21 27 10 8 29 76
1 2 3 4 5 6
Proses 3

(Berdasarkan susunan larik hasil proses 2)

Cari elemen maksimum didalam larik L[1..4], maka hasilnya : maks = L[2] = 27.
Pertukaran maks dengan L[4], diperoleh :

21 8 10 27 29 76
1 2 3 4 5 6
Proses 4

(Berdasarkan susunan larik hasil proses 3)

Cari elemen maksimum didalam larik L[1..3], maka hasilnya : maks = L[1] = 21.
Pertukaran maks dengan L[3], diperoleh :

10 8 21 27 29 76
1 2 3 4 5 6
Proses 5

(Berdasarkan susunan larik hasil proses 4)

13
Cari elemen maksimum didalam larik L[1..2], maka hasilnya : maks = L[1] = 10.
Pertukaran maks dengan L[2], diperoleh :

8 10 21 27 29 76
1 2 3 4 5 6
Sehingga tersisa satu elemen yaitu 8, maka pengurutan selesai. Larik L sudah terurut
menaik.

Algoritma Pengurutan Seleksi-Maksimum(menaik).

Procedure SelectionSort1 (input / output L : Larikint, input n : integer )

{I.S. : Elemen larik L sudah terdefinisi harganya. }

{F.S. : Elemen larik L terurut menaik sedemikian sehingga L[1]  <  L[2]  <  _  < L[n] }

Kamus

            i                       : integer           {pencacah proses}

            j                       : integer           {pencacah untuk mencari nilai maksimum}

            imaks               : integer           {indeks yang berisi nilai maksimum sementara}

            maks    : integer           {elemen maksimum}

            temp                : integer           {peubah bantu untuk pertukaran}

Algoritma

for  i    n  downto  2 do       { jumlah proses sebanyak  n – 1 }

              { Carielemen maksimum pada elemen L[1..i] }

              imaks    1   {Elemen pertama diasumsikan sebagai elemen maksimum sementara }

             maks    L[1]            { Elemen maksimum }

             for  j    2  to  i  do

                  if  L[j]  > maks  then

                        imaks    j

                        maks    [j]

14
                  endif

            endfor

    { pertukaran maks dengan L[i] }

    temp    L[i]

    L[i]    maks

    L[imaks]    tempt

endfor

Apabila ingin larik yang terurut menurun, maka algoritma pengurutan seleksi-minimum sebagai sbb :

Tinjau larik dengan  n = 6 buah elemen dibawah ini yang belum terurut. Larik ini akan diurut menurun (
Descending ) dengan metode pengurutan seleksi-maksimum.

29 27 10 8 76 21
1 2 3 4 5 6

Proses 1

Cari elemen maksimum didalam larik L[1..6], maka hasilnya : imaks = 5, L[imaks] = 76.
Pertukaran L[imaks] dengan L[1], diperoleh :

76 27 10 8 29 21
1 2 3 4 5 6
Proses 2
(berdasarkan susunan larik hasil proses 1)

Cari elemen maksimum didalam larik L[2..6], maka hasilnya : imaks = 5, L[imaks] = 29.

Pertukaran L[imaks] dengan L[2], diperoleh :

76 29 10 8 27 21
1 2 3 4 5 6
Proses 3
(berdasarkan susunan larik hasil proses 2)

Cari elemen maksimum didalam larik L[3..6], maka hasilnya : imaks = 5, L[imaks] = 27.

15
Pertukaran L[imaks] dengan L[3], diperoleh :

76 29 27 8 10 21
1 2 3 4 5 6
Proses 4
(berdasarkan susunan larik hasil proses 3)

Cari elemen maksimum didalam larik L[4..6], maka hasilnya : imaks = 6, L[imaks] = 21.

Pertukaran L[imaks] dengan L[4], diperoleh :

76 29 27 21 10 8
1 2 3 4 5 6
Proses 5
(berdasarkan susunan larik hasil proses 4)

Cari elemen maksimum didalam larik L5..6], maka hasilnya : imaks = 5, L[imaks] = 10.

Pertukaran L[imaks] dengan L[5]  (sebenarnya tidak perlu dilakukan sebab 10 sudah
berada pada posisi yang tepat), diperoleh :

76 29 27 21 10 8
1 2 3 4 5 6
Sehingga larik L sudah terurut menurun.

Algoritma Pengurutan Seleksi-Maksimum(menurun)

Procedure SelectionSort2 (input / output  L : Larikint, input n : integer )

{I.S. : Elemen larik L sudah terdefinisi harganya. }

{F.S. : Elemen larik L terurut menurun sedemikian sehingga L[1]  >  L[2]  >  _  > L[n] }

Kamus

            i                       : integer           {pencacah proses}

            j                       : integer           {pencacah untuk mencari nilai maksimum}

            imaks               : integer           {indeks yang berisi nilai maksimum sementara}

            maks                : integer           {elemen maksimum}

            temp                : integer           {peubah bantu untuk pertukaran}

16
Algoritma

for  i    1  to  n  -  1  do       

              { Cari indeks elemen maksimum pada elemen L[i..n] }

              imaks    i    {Elemen pertama diasumsikan sebagai elemen maksimum sementara }

             for  j    i  +  1  to  n  do

                  if  L[j]  >  L[imaks]  then

                        imaks    j

                  endif

            endfor

    { pertukaran maks dengan L[i] }

    temp    L[i]

    L[i]    maks

    L[imaks]    tempt

Endfor

2.5 Algoritma Pengurutan Sisip

Pengurutan Sisip (Insertion Sort) merupakan algoritma pengurutan dengan mengambil

setiap elemen dari awal sampai akhir dan memindahkan elemen tersebut ke posisi yang
terurut.

Pengurutan identik dengan mengurutkan data yang banyak dalam pemrograman,

dalam kasus ini menggunakan suatu variabel yang dapat menyimpan banyak data atau
sering di sebut Array dapat menjadi media dalam pemahaman algoritma ini . Insertion Sort
merupakan pengurutan yang efisien dalam mengurutkan data yang mempunyai elemen
sedikit.

 Cara Pengurutan Sisip (Insertion Sort) mengurutkan data

17
 Dalam pengurutan menggunakan insertion sort ini, kita dapat memahami alur
pertukaran data dengan sebuah array . terdapat array berjumlah 8 data yang belum terurut

array awal yang belum terurut

dua data pertama di bandingkan

pembandingan data pertama

Dari data tersebut, di dapat bahwa dua data 14 dan 33 telah terurut.  14 telah di
anggap sebagai data terurut dan tidak akan berpindah, kemudian pengurutan melakukan
cek pada data selanjutnya yaitu 33. kemudian membandingkan 33 dengan 27

membandingkan index ke 1 dan ke 2

Terdapat bahwa 33 lebih besar dari 27, maka data akan berpindah. selain itu data
yang berpindah akan di bandingkan dengan data yang sudah terurut yaitu 14. maka 27
hanya berpindah ke index 1

27 berpindah

18
 27 lebih besar dari 14

Selanjutnya, 33 melakukan cek terhadap index berikutnya dan mendapati 33 lebih

besar dari 10. maka di lakukan pertukaran , selain itu 10 melakukan perbandingan dengan
27 dan didapati 27 lebih besar dari 10. maka 10 berpindah ke indeks ke 1.

33 lebih besar dari 10

10 lebih kecil dari 27

10 berada di index 1

di dapati 10 lebih kecil dari index 0, maka 10 berpindah ke index 0.

10 menjadi index ter kecil

19
begitu juga seterusnya , sehingga proses ini membuat semua data terurut.

35 dan 19 melakukan pembandingan

19 berpindah dan melakukan oembandingan dengan data sebelumnya

19 berpindah karena lebih kecil dengan data sebelumnya

data yang telah terurut. karena tidak ada data yang lebih kecil dari index

 Algoritma Pengurutan Sisip (Insertion Sort)

lebih jelasnya, Algoritma dari Insertion Sort ini adalah

 Jika data sudah ada, maka pengurutan dimulai dengan mengambil satu data dan
membandingkannya dengan data-data yang ada didepannya.

20
  Jika data yang diambil memenuhi syarat perbandingan, maka data yang diambil
tersebut akan diletakan di depan data yang dibandingkan, kemudian data-data yang
dibandingkan akan bergeser mundur.

2.6 Pengurutan Pada Array Terstruktur

Pada php sudah ada fungsi untuk melakukan pengurutan array berdasarkan value
yakni sort() dan asort() untuk berdasarkan key yakni ksort().

sort() adalah fungsi pengurutan berdasarkan value dan mengabaikan key yang
digunakan,

asort() adalah fungsi untuk mengurutkan berdasarkan value tanpa merubah key
array yang digunakan, sedangkan

ksort() adalah fungsi untuk mengurutkan berdasarkan key array yang digunakan.

Berikut ini merupakan contoh script php yang menggunakan fungsi sort.

1$coba["3"] =
2"satu";
$coba["2"] = "dua";
3
$coba["1"] = "tiga";
4sort($coba);
5print_r($coba);

Apabila menjalankan script php tersebut dilayar browser, maka tampilan layar
browser akan seperti gambar dibawah ini.

array ( [0] => dua [1] => satu [2] =>

1
tiga )

Coba perhatikan indeks array (key) yang terdapat pada browser kamu dan indeks
yang terdapat pada script php. Apabila kamu jeli maka kamu akan tahu bahwa indeks yang
digunakan untuk menyimpan nilai array berubah. Contoh pada script php diatas indeks
array 1 digunakan untuk menyimpan nilai “tiga”, sedangkan pada browser indeks array
justru berubah menjadi 2 yang menyimpan nilai “tiga”.

21
jika indeks (key) tidak ingin berubah maka silahkan gunakan asort() untuk pengurutan.

Berikut ini merupakan contoh script php yang menggunakan fungsi asort.

1$coba["3"] =
2"satu";
$coba["2"] = "dua";
3
$coba["1"] = "tiga";
4asort($coba);
5print_r($coba);

Apabila kamu menjalankan script php tersebut dilayar browser kamu, maka tampilan layar
browser kamu akan seperti gambar dibawah ini.

array ( [2] => dua [3] => satu [1] =>

1
tiga )

Pengurutan berdasarkan indeks/key bisa menggunakan ksort().

Berikut ini merupakan contoh script php yang menggunakan fungsi ksort.

1$coba["3"] =
2"satu";
$coba["2"] = "dua";
3
$coba["1"] = "tiga";
4ksort($coba);
5print_r($coba);

Apabila kamu menjalankan script php tersebut dilayar browser kamu, maka tampilan layar
browser kamu akan seperti gambar dibawah ini.

array ( [1] => tiga [2] => dua [3] =>

1
satu )

Itulah kode script PHP dalam pengurutan menggunakan array. semoga info ini bisa
membantu temen semua.

22
 BAB III
PENUTUP

3.1 Kesimpulan
Penjelasan diatas membahas tentang :

1. masalah pengurutan

2. algoritma pengurutan

3. Algoritma pengurutan apung

4. algoritma pengurutan seleksi

5. algoritma pengurutan sisip

6. Pengurutan pada aray terstruktur

Yang memudahkan programmer dalam menyelesaikan sebuah masalah dalam

pengerjaan algoritma.

3.2 Saran
Saya menyadari bahwa makalah ini jauh dari kata kesempurnaan sebagai mana
yang saya harapkan, maka dari itu saya butuh kritikan dan saran dari bapak dosen
pengampu dan bagi teman-teman yang membaca yang sifatnya membangun demi
kesempurnaannya makalah ini.

23
 DAFTAR PUSTAKA

https://bagussjm.wordpress.com/2016/06/19/pengurutan-sisip-insertion-sort/
http://antarakojot.blogspot.co.id/2013/03/makalah-sorting.html
https://id.wikipedia.org/wiki/Algoritma_sorting

24