Nama : Khairunnisa

NRP : 17043019
Jurusan : Teknik Informatika
Matkul : Struktur Data
PENGERTIAN SORT
Sorting atau pengurutan data adalah proses yang sering harus dilakukan dalam pengolahan
data. Sort dalam hal ini diartikan mengurutkan data yang berada dalam suatu tempat
penyimpanan, dengan urutan tertentu baik urut menaik (ascending) dari nilai terkecil sampai
dengan nilai terbesar, atau urut menurun (descending) dari nilai terbesar sampai dengan nilai
terkecil.

Terdapat dua macam pengurutan:

 Pengurutan internal (internal sort), yaitu pengurutan terhadap sekumpulan data

yang disimpan dalam media internal komputer yang dapat diakses setiap elemennya
secara langsung. Dapat dikatakan sebagai pengurutan tabel
 Pengurutan eksternal (external sort), yaitu pengurutan data yang disimpan dalam
memori sekunder, biasanya data bervolume besar sehingga tidak mampu untuk
dimuat semuanya dalam memori.

Algoritma pengurutan internal yang utama antara lain:

1.Bubble Sort

2.Selection Sort

3.Insertion Sort

4.Shell Sort

5.Merge Sort

6.Radix Sort

7.Quck Sort

8.Heap Sort

BUBBLE SORT
Bubble sort adalah proses pengurutan sederhana yang bekerja dengan cara berulang kali
membandingkan dua elemen data pada suatu saat dan menukar elemen data yang urutannya
salah. Ide dari Bubble sort adalah gelembung air yang akan “mengapung” untuk table yang
terurut menaik (ascending). Elemen bernilai kecil akan “diapungkan” (ke indeks terkecil),
artinya diangkat ke “atas” (indeks terkecil) melalui pertukaran.

Contoh program lengkap penerapan algoritma Bubble Sort dalam bahasa C

1. #include <stdio.h>2. #include <conio.h>

3.
4. void v_Bubble(int A[],int N);

5. void main()

6. { int L[5];

7. int i,N;

8. //proses untuk memasukkan data array

9. printf(“Banyak data : “);scanf(“%i”,&N);

10. for(i=0;i<N;i++)

11. { printf(“Data ke-%i: “,i+1);

12. scanf(“%i”,&L[i]); } //end loop i

13. //memanggil procedure bubble sort

14. v_Bubble(L,N);

15.

16. //proses menampilkan kembali data array

17. printf(“\nData Array Terurut\n”);

18. for(i=0;i<N;i++)

19. { printf(“%3i”,L[i]); };

20. getche();

21. } //end main program

22.

23. void v_Bubble(int A[5],int N)

24. { int a,b,temp;

25. //proses sortir dengan bubble sort

26. for(a=0;a<=(N-2);a++)

27. { for(b=(N-1);b>=(a+1);b–)

28. { if (A[b-1] > A[b])

29. { temp = A[b-1];

30. A[b-1]= A[b];

31. A[b] = temp; } //endif

32. } //end loop j

33. } //end loop i

34. } //end procedure v_Bubble

SELECTION SORT

Algoritma Selection sort memilih elemen maksimum/minimum array, lalu menempatkan

elemen maksimum/minimum itu pada awal atau akhir array (tergantung pada urutannya
ascending/descending). Selanjutnya elemen tersebut tidak disertakan pada proses selanjutnya.
Karena setiap kali selection sort harus membandingkan elemen-elemen data, algoritma ini
termasuk dalam comparison-based sorting.

Seperti pada algoritma Bubble Sort, proses memilih nilai maksimum /minimum dilakukan
pada setiap pass. Jika array berukuran N, maka jumlah pass adalah N-1.

Terdapat dua pendekatan dalam metode pengurutan dengan Selection Sort :

1. Algoritma pengurutan maksimum (maximum selection sort), yaitu memilih elemen

maksimum sebagai basis pengurutan.

Contoh Program lengkap penerapan algoritma Maximum Selection Sort Ascending dalam
bahasa C

#include <stdio.h>#include <conio.h>

void v_SelAsc(int A[],int N);

void v_Tukar(int *P,int *M);

main()

{ int L[5];

int i,N;

//input data array

printf(“Banyak Data: “);scanf(“%i”,&N);

for(i=0;i<N;i++)
{ printf(“Data ke-%i: “,i+1);

scanf(“%i”,&L[i]); } //end loop i

//memanggil procedure v_SelAsc

v_SelAsc(L,N);

//menampilkan kembali data array

printf(“\nData Terurut:\n”);

for(i=0;i<N;i++)

{ printf(“%3i”,L[i]); } //end loop i

getche();

void v_SelAsc(int A[5],int N)

{ int maks,k,j,temp;

for(k=(N-1);k>=0;k–)

{ maks=0;

for(j=0;j<=k;j++)

{ if (A[j] > A[maks])

{ maks=j; } //endif

} //end loop j

v_Tukar(&A[k],&A[maks]);

} //end loop k

} //end procedure v_SelAsc

void v_Tukar(int *P,int *M)

{ int temp;

temp = *P;
*P = *M;

*M = temp;

} //end procedure v_Tukar

2. Algoritma pengurutan minimum (minimum selection sort), yaitu memilih elemen

minimum sebagai basis pengurutan.

Contoh program lengkap penerapan algoritma Minimum Selection Sort Ascending dalam
bahasa C

1. #include <stdio.h>

2. #include <conio.h>

3. void v_minAsc(int A[5],int N);

4. void v_Tukar(int *P,int *M);

5. main()

6. { int L[5];

7. int i,j,k,min,temp,N;

8. //input data array

9. printf(“Input Data Array\n”);

10. printf(“\nBanyak Data : “); scanf(“%i”,&N);

11. for(i=0;i<N;i++)

12. { printf(” Data ke-%i = “,i+1);

13. scanf(“%i”,&L[i]); } //end loop i

14. //panggil procedure v_minAsc

15. v_minAsc(L,N);

16. //output data array

17. printf(“\n Data Sortir:\n”);

18. for(i=0;i<N;i++)
19. { printf(” %5i”,L[i]); } //end loop i

20. printf(“\n Tekan Enter\n”);

21. getche();

22. } //end main program

23.

24. void v_minAsc(int A[5],int N)

25. { int k,min,j,temp;

26. //proses minimum ascending selection sort

27. for(k=0;k<=(N-2);k++)

28. { min = k;

29. for(j=(k+1);j<=(N-1);j++)

30. { if (A[j] < A[min])

31. min = j; } //endloop j

32. v_Tukar(&A[k],&A[min]); } //end loop k

33. } //end procedure

34.

35. void v_Tukar(int *P,int *M)

36. { int temp;

37. temp = *P;

38. *P = *M;

39. *M = temp;

INSERTION SORT
Insertion sort adalah sebuah algoritma pengurutan yang membandingkan dua elemen data
pertama, mengurutkannya, kemudian mengecek elemen data berikutnya satu persatu dan
membandingkannya dengan elemen data yang telah diurutkan. Karena algoritma ini bekerja
dengan membandingkan elemen-elemen data yang akan diurutkan, algoritma ini termasuk
pula dalam comparison-based sort.
Contoh program lengkap penerapan algoritma Insertion Sort Ascending dalam bahasa C

#include <stdio.h>

#include <conio.h>

main()

{ int L[7];

int i,N;

void v_insertAsc(int A[7],int N);

//input data array

printf(“Input Data Array\n”);

printf(“\nBanyak Data: “); scanf(“%i”,&N);

for(i=0;i<N;i++)

{ printf(“Nilai ke-%i = “,i+1);

scanf(“%i”,&L[i]); } //end loop i

//panggil procedure v_inAsc

v_insAsc(L,N);

//output data array

printf(“Data terurut:\n”);

for(i=0;i<N;i++)

{ printf(“%5i”,L[i]); } //end loop i

printf(“\nTekan Enter…\n”);

getche();

void v_insAsc(int A[7],int N)

{ int k,X,i;

//insertion sort ascending

k=1;

while(k<=N-1)

{ i=k;

X=A[i];

while(i>=1 && A[i-1]>X)

{ A[i]=A[i-1];

i–; } //endwhile

A[i]=X;

k++; } //endwhile

} //end procedure

SHELL SORT (METODE SHELL)

Metode ini disebut juga dengan metode pertambahan menurun (diminishing increment).
Metode ini dikembangkan oleh Donald L. Shell pada tahun 1959, sehingga sering disebut
dengan Metode Shell Sort. Metode ini mengurutkan data dengan cara membandingkan suatu
data dengan data lain yang memiliki jarak tertentu, kemudian dilakukan penukaran bila
diperlukan.

Contoh prosedur yang menggunakan metode Shell:

void ShellSort(int N)
{
int Jarak, i, j;
bool Sudah;
Jarak = N;
while(Lompat > 1)
{
Jarak = Jarak / 2;
Sudah = false;
while(!Sudah)
{
Sudah = true;
for(j=0; j<N-Jarak; j++)
{
i = j + Jarak;
if(Data[j] > Data[i])
{
Tukar(&Data[j], &Data[i]);
Sudah = false;
}}}}}
MERGE SORT
Merge Sort adalah algoritma yang berdasarkan strategi divide-and-conquer. Algoritma
ini tediri dari dua bagian utama, yaitu bagian pembagian list menjadi sublist-sublist yang
lebih kecil dan bagian sort (pengurutan) dan merge (penggabungan) pada sublist-sublist
tersebut.

1) Divide: membagi masalah menjadi beberapa submasalah yang memiliki kemiripan

dengan masalah semula namun berukuran lebih kecil (idealnya berukuran hampir sama),

2) Conquer: memecahkan (menyelesaikan) masing-masing submasalah (secara rekursif),

dan

3) Combine: mengabungkan solusi masing-masing submasalah sehingga membentuk

solusi masalah semula.

Implementasi Merge Sort :

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

void printv(char* in, int *v, int n) {

printf(“%s”, in);

int i = 0;

for (; i < n; ++i)

printf(“%d “, v[i]);

printf(“\n”);

void merge(int *v, int p, int q, int r) {

int i = p;

int j = q + 1;

int *tmp = (int*)malloc((r – p + 1) * sizeof(int));

int k = 0;

while ((i <= q) && (j <= r)) {

if (v[i] < v[j])

tmp[k++] = v[i++];

else

tmp[k++] = v[j++];

while (i <= q)

tmp[k++] = v[i++];

while (j <= r)

tmp[k++] = v[j++];

memcpy(v + p, tmp, (r – p + 1) * sizeof(int));

free(tmp);

void mergeS(int *v, int p, int r) {

if (p < r) {

int q = (p + r) / 2;

mergeS(v, p, q);

mergeS(v, q + 1, r);

merge(v, p, q, r);

int main(int argc, char *argv[]) {

int n = 10;

int v[] = {9, 8, 7, 6, 5, 5, 4, 3, 2, 1};

printv(“V: “, v, n);

mergeS(v, 0, n – 1);

printv(“V: “, v, n);
return 0;

RADIX SORT

Radix Sort adalah metode sorting tanpa pembandingan dengan kata lain, sorting Non-
Comparasion sort dimana dalam prosesnya tidak melakukan perbandingan antar data. Secara
umum yang proses yang dilakukan dalam metode ini adalah mengklasifikasikan data sesuai
dengan kategori terurut yang tertentu dan dalam tiap kategorinya dilakukan pengklasifikasian
lagi dan seterusnya sesuai dengan kebutuhan. Dan kemudian subkategori-subkategori tersebut
digabungkan kembali, yang secara dilakukan hanya dengan metode sederhana concatenation.

Dibawah ini adalah syntax Radix Sort:

#include

#include

main()

int a, b, leng, data[100], d, m, temp[100], index;

printf(“Banyak data : “);

scanf(“%d”,&leng);

for (a=0;a

printf(“data %d = “,a+1);

scanf(“%d”,&d);

if (d<1000) { data[a]=d; } else a–; }

printf(“\nData Anda: “); for (a=0;a {

printf(“\nData %d= %d “,a+1,data[a]); } index=0; for (a=0;a<=9;a++) //lsb sort for (b=0;b {
if (data[b]<100) { m=data[b]%10; } else { m=data[b]%100; m=m%10; } if (m==a) {
temp[index]=data[b]; index++; } } for (a=0;a<=9;a++) { data[a]=temp[a]; } index=0; for
(a=0;a<=9;a++) //csb sort for (b=0;b { if (data[b]<100) { m=data[b]/10; } else {
m=data[b]%100; m=m/10; } if (m==a) { temp[index]=data[b]; index++; } } for
(a=0;a<=9;a++) { data[a]=temp[a]; } index=0; for (a=0;a<=9;a++) //msb sort for (b=0;b {
m=data[b]/100; if (m==a) { temp[index]=data[b]; index++; } } for (a=0;a<=9;a++) {
data[a]=temp[a]; } printf(“\n\nSetelah di Sorting\n”); for (a=0;a<(leng);a++) {
printf(“%d”,data[a]); printf(“\n”); } }

METODE QUICK SORT

Quick Sort adalah metode pengurutan data yang dikemukan pertama kali oleh C.AR Hoare
pada tahun 1962. Metode ini menggunakan strategi “pecah-pecah” dengan mekanisme seperti
berikut : Larik L[p..r] (dengan indeks terkecil adalah p dan indeks terbesar yaitu r) disusun
ulang (dipartisi) menjadi dua buah larik A[p..q] dan A[q+1..r] sehingga setiap elemen dalam
A[q+1..r]. Selanjutnya kedua larik tersebut diurutkan secara rekursif. Dengan sendirinya
kombinasi kedua larik tersebut membentuk larik dengan data yang telah urut.

Implementasi ke dalam bahasa c++

#include <iostream.h>

#include <conio.h>

void tampilkan_larik(int data[], int n)

int i;

for (i=0;i<n;i++)

cout<<data[i]<<” “;

cout<<“\n”;

int partisi (int data[], int p, int r)

int x,i,j,tmp;

x=data[p];

i=p;

j=r;

while(1)

{
while(data[j]>x)

j=j-1;

while(data[i]<x)

i=i+1;

if (i<j)

//tukarkan data

tmp=data[i];

data[i]=data[j];

data[j]=tmp;

else

return j;

void quick_sort(int data[], int p, int r)

int q;

if(p<r)

q=partisi(data,p,r);

quick_sort(data,p,q);

quick_sort(data, q+1,r);

}
}

int main()

const jum_data=9;

int i;

int data[]={25,57,48,37,12,92,80,33,1};

cout<<“Data sebelum diurut: “<<endl;

for(int ctr=0; ctr<9; ctr++)

cout<<data[ctr]<<” “;

quick_sort(data,0,jum_data-1);

//hasil pengurutan

cout<<endl;

cout<<endl;

cout<<“hasil pengurutan:\n”;

tampilkan_larik(data,jum_data);

getch();

HEAP SORT

Metode heap sort adalah metode dari pengembangan tree. Heap sort memiliki kecepatan
O(NlogN). Heap sort melakukan suatu pengurutan menggunakan suatu struktur data yang di
sebut heap. Heap memiliki kompleksitas yang besar dalam pembuatan kodenya, tetapi heap
sort mampu mengurutkan data-data yang sangat banyak dengan waktu yang cepat.

Contoh program heap sort :

#include<stdio.h>

#include<conio.h>
#include<stdlib.h>

//—————————————————————————

typedef struct heap

int val;

struct heap *left,*right;

}*TR;

//—————————————————————————

TR new_node()

TR new;

new=malloc(sizeof(struct heap));

new->left=new->right=NULL;

return(new);

//—————————————————————————

TR get_node()

TR new;

new=new_node();

printf(“\n\n\t Masukkan angka :: “);

scanf(“%d”,&new->val);

return(new);

//—————————————————————————
void insert_node(TR temp,TR new)

if(temp->val>new->val)

if(temp->left!=NULL)

insert_node(temp->left,new);

else

temp->left=new;

else

if(temp->right!=NULL)

insert_node(temp->right,new);

else

temp->right=new;

//—————————————————————————

void heap_sort(TR temp)

if(temp!=NULL)

heap_sort(temp->left);

printf(“%d\t”,temp->val);

heap_sort(temp->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();

//