Dokumen tersebut membahas tentang tiga algoritma pengurutan (sorting) yaitu bubble sort, selection sort, dan insertion sort. Bubble sort adalah metode pengurutan terlambat karena banyak melakukan pertukaran, sedangkan selection sort dan insertion sort lebih efisien karena hanya melakukan sedikit pertukaran saat mengurutkan data.

1. SORTING (PENGURUTAN)
Sorting adalah proses mengatur sekumpulan objek
menurut aturan atau susunan tertentu. Urutan objek
tersebut dapat menaik (ascending = dari data kecil ke
data lebih besar) atau menurun (descending = dari
data besar ke data lebih kecil).

2. Algoritma pengurutan (sorting) :
• Bubble sort (gelembung)
• Selection sort (maksimum/minimun)
• Insertion sort (sisip)
• Heap sort
• Shell sort
• Quick sort
• Merge sort
• Radix sort
• Tree sort

3. PENGURUTAN GELEMBUNG
Metode pengurutan gelembung (bubble sort)
diinspirasi oleh gelembung sabun yang ada di
permukaan air. Karena berat jenis gelembung sabun
lebih ringan daripada berat jenis air maka gelembung
sabun akan selalu mengapung.
Prinsip pengapungan ini juga dipakai pada pengurutan
gelembung. Elemen yang berharga paling kecil
“diapungkan”, artinya diangkat ke atas (atau ke ujung
paling kiri) melalui pertukaran. Proses pengapungan ini
dilakukan N kali langkah. Pada langkah ke-I, Larik[1..N]
akan terdiri dari 2 bagian yaitu:
– Bagian yang sudah terurut yaitu L[1]..L[i].
– Bagian yang belum terurut L[i+1]..L[n].

4. ALGORITMA PENGURUTAN GELEMBUNG
(naik /ascending)
Langkah 1: Mulai dari elemen K=N,N-1,N-2,..2 bandingkan L[K] jika
L[K] < L[K-1], pertukarkan L[K] dengan L[K-1].
Pada akhir langkah 1, elemen L[1] berisi harga minimum
pertama.
Langkah 2: Mulai dari elemen K=N,N-1,N-2,..3 bandingkan L[K] jika
L[K] < L[K-1], pertukarkan L[K] dengan L[K-1].
Pada akhir langkah 2, elemen L[2] berisi harga minimum
kedua dan L[1]..L[2] terurut..
Langkah 3: Mulai dari elemen K=N,N-1,N-2,..4 bandingkan L[K] jika
L[K] < L[K-1], pertukarkan L[K] dengan L[K-1].
Pada akhir langkah 3, elemen L[3] berisi harga minimum
ketiga dan L[1]..L[3] terurut ...
Langkah N-1: Mulai dari elemen K=N,N-1,N-2,..4 bandingkan L[K] jika
L[K] < L[K-1], pertukarkan L[K] dengan L[K-1].

5. Contoh: tinjau larik dengan N=6 buah elemen dibawahini.
Larik ini akan diurutkan menaik.
Langkah 1:
K=N=6 21 76
K=5 8 21 76
K=4 8 10 21 76
K=3 8 27 10 21 76
K=2 8 25 27 10 21 76
25 27 10 8 76 21
1 2 3 4 5 6
Hasil akhir langkah 1 : 8 25 27 10 21 76
1 2 3 4 5 6

6. Langkah 2:
K=N=6 21 76
K=5 10 21 76
K=4 10 27 21 76
K=3 10 25 27 21 76
8 10 25 27 21 76
1 2 3 4 5 6
Hasil Akhir dari langkah 2:
Langkah 3:
K=N=6 21 76
K=5 21 27 76
K=4 21 25 27 76
Hasil Akhir dari langkah 3:
8 10 21 25 27 76
1 2 3 4 5 6

7. Langkah 4:
K=N=6 27 76
K=5 25 27 76
Hasil Akhir dari langkah 4:
8 10 21 25 27 76
1 2 3 4 5 6
Langkah 5:
K=N=6 27 76
Hasil Akhir dari langkah 5:
8 10 21 25 27 76
1 2 3 4 5 6
Selesai. Larik sudah terurutkan !

8. Contoh Ascending :
#include <stdio.h>
#include <conio.h>
#include <iostream.h>
main(){
int i,k,temp;
int L[5];
//Jumlah elemen dalam array ada 5
L[0]=1;
L[1]=50;
L[2]=10;
L[3]=3;
L[4]=2;
//Proses secara Ascending(naik)
for(i=0;i<=4;i++)
for(k=0;k<=4;k++)
if (L[k]>L[k+1])
{temp=L[k];
L[k]=L[k+1];
L[k+1]=temp; }
for(i=0;i<=4;i++)
cout<<L[i]<<endl;
getch();}

9. Contoh Descending :
#include <stdio.h>
#include <conio.h>
#include <iostream.h>
main(){
int i,k,temp;
int L[5];
//Jumlah elemen dalam array ada 5
L[0]=1;
L[1]=50;
L[2]=10;
L[3]=3;
L[4]=2;
//Proses secara Descending(menurun)
for(i=4;i>=0;i--)
for(k=5;k>1;k--)
if (L[k]>L[k--])
{temp=L[k];
L[k]=L[k--];
L[k--]=temp; }
for(i=5;i>=1;i--)
cout<<L[i]<<endl;
getch();}

10. Kesimpulan :
Pengurutan dengan metode bubble sort ini
kurang efisien karena terlalu banyak
penukaran yang dilakukan pada setiap langkah
dan membutuhkan banyak waktu serta proses
lebih lama, sehingga tidak direkomendasikan
untuk dipakai. Namun metode ini mudah
dipahami dan sederhana.

11. Kuis :
• Urutkan larik berikut menggunakan metode
bubble sort dengan ascending dan descending
5 2 10 50 70 6
1 2 3 4 5 6

12. PENGURUTAN MAKSIMUM/MINIMUM
Metode pengurutan ini disebut pengurutan maksimum /
minimum karena didasarkan pada pemilihan elemen
maksimum atau minimum kemudian mempertukarkan elemen
maksimum/minimum tersebut dengan elemen terujung larik
(elemen ujung kiri atau elemen ujung kanan). Selanjutnya
elemen terujung itu kita “isolasi” dan tidak diikut sertakan
pada proses selanjutnya. Karena proses utama dalam
pengurutan adalah pemilihan elemen maksimum / minimum,
maka metode ini disebut metode pemilihan (selection sort).

13. Algoritma Pengurutan Maksimum
(naik /ascending)
Langkah 1: Tentukan Harga Maksimum didalam L1[1..N]
Pertukarkan harga maksimum dng L[N]
Langkah 2: Tentukan Harga Maksimum didalam L1[1..N-1]
Pertukarkan harga maksimum dng L[N-1]
Langkah 3: Tentukan Harga Maksimum didalam L1[1..N-2]
Pertukarkan harga maksimum dng L[N-2]
……..
Langkah N-1: Tentukan Harga Maksimum didalam L1[1..2]
Pertukarkan harga maksimum dng L[2].

14. Contoh : Tinjau larik dengan N=6 buah elemen dibawah
ini yang belum terurut menjadi diurut naik.
29 27 10 8 76 21
1 2 3 4 5 6
Langkah 1:
Cari elemen maksimum di dalam larik L[1..6]
maks = L[5] = 76
Tukar maks dengan L[N],hasil akhir langkah 1:
29 27 10 8 21 76
1 2 3 4 5 6

15. 21 27 10 8 29 76
1 2 3 4 5 6
Langkah 2:
(berdasarkan susunan larik hasil langkah 1)
Cari elemen maksimum di dalam larik L[1..5]
maks = L[1] = 29
Tukar maks dengan L[5],hasil akhir langkah 2:
Langkah 3:
(berdasarkan susunan larik hasil langkah 2)
Cari elemen maksimum di dalam larik L[1..4]
maks = L[2] = 27
Tukar maks dengan L[4],hasil akhir langkah 3:
21 8 10 27 29 76
1 2 3 4 5 6

16. Langkah 4:
(berdasarkan susunan larik hasil langkah 3)
Cari elemen maksimum di dalam larik L[1..3]
maks = L[1] = 21
Tukar maks dengan L[3],hasil akhir langkah 4:
10 8 21 27 29 76
1 2 3 4 5 6
Langkah 5:
(berdasarkan susunan larik hasil langkah 4)
Cari elemen maksimum di dalam larik L[1..2]
maks = L[1] = 10
Tukar maks dengan L[2],hasil akhir langkah 5:
8 10 21 27 29 76
1 2 3 4 5 6
Selesai. Larik sudah terurutkan !

17. Contoh ascending :
#include <iostream.h>
#include <conio.h>
#include <iomanip.h>
int main(){
//deklarasi array dengan 7 elemen
int A[7];
int j,k,i,temp;
int jmax,u=6;
//memasukkan nilai sebelum diurutkan
cout<<"Masukkan nilai pada elemen array :"<<endl;
for(i=0;i<7;i++)
{
cout<<"A["<<i<<"]=";
cin>>A[i];
}

18. //Proses pengurutan secara menaik (Ascending)
for(j=0;j<7;j++)
{
jmax=0;
for(k=1;k<=u;k++)
if (A[k] > A[jmax])
jmax=k;
temp=A[u];
A[u]=A[jmax];
A[jmax]=temp;
u--;
}
//menampilkan nilai setelah diurutkan
cout<<"nNilai setelah diurutkan ="<<endl;
for(i=0;i<7;i++)
cout<<A[i]<<" ";
getch();}

19. Contoh descending :
#include <iostream.h>
#include <conio.h>
#include <iomanip.h>
int main(){
//deklarasi array dengan 7 elemen
int A[7];
int j,k,i,temp;
int jmax,u=6;
//memasukkan nilai sebelum diurutkan
cout<<"Masukkan nilai pada elemen array :"<<endl;
for(i=0;i<7;i++)
{
cout<<"A["<<i<<"]=";
cin>>A[i];
}

20. //Proses pengurutan secara turun (descending)
for(j=0;j<7;j++)
{
jmax=0;
for(k=u;k>=1;k--)
if (A[k] < A[jmax])
jmax=k;
temp=A[u];
A[u]=A[jmax];
A[jmax]=temp;
u--;
}
//menampilkan nilai setelah diurutkan
cout<<"nNilai setelah diurutkan ="<<endl;
for(i=0;i<7;i++)
cout<<A[i]<<" ";
getch();}

21. Untuk algoritma Pengurutan Minimum
caranya sama persis dengan maksimum
hanya saja yang ditukar adalah nilai
yang minimum bukan maksimum.

22. Kesimpulan :
dibandingkan dengan pengurutan gelembung
(bubble sort) pengurutan dengan metode
selection sort (maksimum/minimum) ini
memiliki kinerja yang lebih baik. Operasinya
pertukaran hanya sekali saja dilakukan pada
setiap langkah sehingga waktu pengurutan
dapat lebih ditekan. Metode ini
direkomendasikan untuk dipakai.

23. Kuis :
• Urutkan larik berikut menggunakan metode
selection sort (maksimum/minimum) dengan
ascending dan descending
2 0 10 5 70 16
1 2 3 4 5 6

24. PENGURUTAN Sisip (Insertion sort)
Dari namanya, pengurutan sisip (insertion
sort) adalah metode pengurutan dengan cara
menyisipkan elemen larik pada posisi yang
tepat. Pencarian posisi yang tepat dilakukan
dengan pencarian beruntun. Selama
pencarian posisi yang tepat dilakukan
pergeseran elemen larik.

25. ALGORITMA PENGURUTAN SISIP
(naik /ascending)
Andaikan: L[1] dianggap sudah tempatnya.
Langkah 2: L[2] harus dicari tempatnya yang tepat pada L[1..2] dengan
cara menggeser elemen L[1] ke kanan bila L[1] lebih besar
dari L[2]. Misalkan posisi elemen yang tepat adalah K
sisipkan L[2] pada K.
Langkah 3: L[3] harus dicari tempatnya yang tepat pada L[1..3] dengan
cara menggeser elemen L[1..2] ke kanan bila L[1..2 lebih
besar dari L[3]. Misalkan posisi elemen yang tepat adalah K
sisipkan L[3] pada K.

26. Langkah 4: L[4] harus dicari tempatnya yang tepat pada L[1..4]
dengan cara menggeser elemen L[1..4] ke kanan bila
L[1..4] lebih besar dari L[4]. Misalkan posisi elemen yang
tepat adalah K sisipkan L[4] pada K.
Langkah N: L[N] harus dicari tempatnya yang tepat pada L[1..N] dengan
cara menggeser elemen L[1..N ke kanan bila L[1..N] lebih
besar dari L[N]. Misalkan posisi elemen yang tepat adalah K
sisipkan L[N] pada K.

27. Contoh : Tinjau larik dengan N=6 buah elemen dibawah ini
yang belum terurut menjadi diurut naik.
29 27 10 8 76 21
1 2 3 4 5 6
Langkah 1:
Elemen L[1] dianggap sudah terurut
29 27 10 8 76 21
1 2 3 4 5 6
Langkah 2:
(berdasarkan susunan larik pada langkah 1)
Cari posisi yang tepat untuk L[2] pada
L[1..2],diperoleh :
29 27 10 8 76 21
1 2 3 4 5 6

28. Langkah 3:
(berdasarkan susunan larik pada langkah 2)
Cari posisi yang tepat untuk L[3] pada
L[1..3],diperoleh :
10 27 29 8 76 21
1 2 3 4 5 6
Langkah 4:
(berdasarkan susunan larik pada langkah 3)
Cari posisi yang tepat untuk L[4] pada
L[1..4],diperoleh :
8 10 27 29 76 21
1 2 3 4 5 6

29. Langkah 5:
(berdasarkan susunan larik pada langkah 4)
Cari posisi yang tepat untuk L[5] pada
L[1..5],diperoleh :
8 10 27 29 76 21
1 2 3 4 5 6
Langkah 6:
(berdasarkan susunan larik pada langkah 5)
Cari posisi yang tepat untuk L[6] pad
L[1..6],diperoleh :
8 10 21 27 29 76
1 2 3 4 5 6
Selesai. Larik sudah terurutkan !

30. Contoh :
#include <stdio.h>
#include <conio.h>
#include <iostream.h>
main(){
int j,k, temp;
int L[5];
L[1]=1;
L[2]=25;
L[3]=10;
L[4]=30;
L[5]=2;
for(k=2;k<=5;k++){
temp=L[k];/* ambil elemen L[k] supaya tidak tertimpa penggeseran*/
/* Cari Posisi Yang tepat dalam L[1..k-1] sambil menggeser*/
j=k-1;
while(temp<=L[j])
{
L[j+1]=L[j];
j--;
}

31. if((temp >= L[j])|| ( j=1))
L[j+1]=temp; /*posisi yg tepat untuk L[k] ditemukan*/
else
{
L[j+1]=L[j];
L[j]=temp;
}
}
for(k=1;k<=5;k++)
cout<< L[k]<<" ";
getch();}

32. Kesimpulan :
Kelemahan metode sisip terletak pada
banyaknya operasi yang diperlukan dalam
mencari posisi yang tepat untuk elemen larik.
Untuk larik yang jumlahnya besar ini tidak
praktis. Dari ketiga metode tersebut,
pengurutan maksimum/minimum memiliki
kinerja yang terbaik.

33. Kuis :
• Urutkan larik berikut menggunakan metode
sisip dengan ascending dan descending
0 12 100 5 70 3
1 2 3 4 5 6