Dasar-Dasar Pemprograman

1. SORTING (PENGURUTAN)
Sorting adalah proses mengatur sekumpulan objek m
enurut aturan atau susunan tertentu. Urutan objek ters
ebut dapat menaik (ascending = dari data kecil ke dat
a lebih besar) atau menurun (descending = dari data b
esar 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) diinspiras
i oleh gelembung sabun yang ada di permukaan air. Kar
ena berat jenis gelembung sabun lebih ringan daripada
berat jenis air maka gelembung sabun akan selalu men
gapung.
Prinsip pengapungan ini juga dipakai pada pengurutan
gelembung. Elemen yang berharga paling kecil “diapun
gkan”, 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 terdir
i 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 ku
rang efisien karena terlalu banyak penukaran y
ang dilakukan pada setiap langkah dan memb
utuhkan banyak waktu serta proses lebih lama
, sehingga tidak direkomendasikan untuk dipa
kai. Namun metode ini mudah dipahami dan s
ederhana.

11. Kuis :
• Urutkan larik berikut menggunakan metode b
ubble 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 / minim
um karena didasarkan pada pemilihan elemen maksimum atau
minimum kemudian mempertukarkan elemen maksimum/mini
mum tersebut dengan elemen terujung larik (elemen ujung kiri
atau elemen ujung kanan). Selanjutnya elemen terujung itu kit
a “isolasi” dan tidak diikut sertakan pada proses selanjutnya. K
arena proses utama dalam pengurutan adalah pemilihan eleme
n maksimum / minimum, maka metode ini disebut metode pe
milihan (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] mak
s = 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] mak
s = 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] mak
s = 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] mak
s = 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] mak
s = 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 yan
g minimum bukan maksimum.

22. Kesimpulan :
dibandingkan dengan pengurutan gelembung
(bubble sort) pengurutan dengan metode sele
ction sort (maksimum/minimum) ini memiliki
kinerja yang lebih baik. Operasinya pertukaran
hanya sekali saja dilakukan pada setiap langka
h sehingga waktu pengurutan dapat lebih dite
kan. Metode ini direkomendasikan untuk dipa
kai.

23. Kuis :
• Urutkan larik berikut menggunakan metode se
lection sort (maksimum/minimum) dengan as
cending 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 men
yisipkan elemen larik pada posisi yang tepat. P
encarian posisi yang tepat dilakukan dengan p
encarian beruntun. Selama pencarian posisi ya
ng 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],di
peroleh :
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],di
peroleh :
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],di
peroleh :
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],di
peroleh :
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] pada L[1..6],d
peroleh :
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 banyak
nya operasi yang diperlukan dalam mencari po
sisi yang tepat untuk elemen larik. Untuk larik
yang jumlahnya besar ini tidak praktis. Dari ket
iga metode tersebut, pengurutan maksimum/
minimum memiliki kinerja yang terbaik.

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