MENU SORTING

1. LISTING PROGRAM
A. Menu Program Data Int
#include <stdio.h> menu(array);

#include <stdlib.h> }while(1);

#include <time.h> return 0;

#include <math.h> }

void generate(int x[]){

void generate(int []); int i;

void backup(int [], int []); for(i=0;i<n;i++)

void menu(int []); x[i] = rand()/1000;

void insertion(int []); }

void selection(int []); void backup(int T[], int A[]){

void bubble(int []); int i;

void shell(int []); for(i=0;i<n;i++)

void merge_sort(int [], int, A[i] = T[i];

int, int);
}
void merge(int [], int, int,
int, int); void menu(int A[]){

void quick_sort(int [], int, int pilih, flag;

int, int);
long t1, t2;
int partition(int [], int, int,
puts("\nMenu program : ");
int);
printf("1. Insertion
void tukar(int *, int *);
Sort\n");
void tampil(int []);
printf("2. Selection
int ascdesc(); Sort\n");

int n; printf("3. Bubble Sort\n");

int main() printf("4. Shell Sort\n");

{ printf("5. Merge Sort\n");

puts("\n\t\tMENU printf("6. Quick Sort\n");

SORTING\n"); printf("7. Keluar\n");

printf("Banyak data : "); printf("\nMasukkan pilihan

anda : ");
scanf("%d",&n);
scanf("%d", &pilih);
int temp[n], array[n];
switch(pilih){
srand(time(NULL));
case 1:
generate(temp);
time(&t1);
do{
insertion(A);
backup(temp, array);
time(&t2);
 break; printf("\nTime : %d\n",t2-
t1);
case 2:
puts("");
time(&t1);
}
selection(A);
int ascdesc(){
time(&t2);
int pilih, flag;
break;
puts("\nMode Urut : ");
case 3:
puts("1. Ascending");
time(&t1);
puts("2. Descending");
bubble(A);
printf("\nPilih menu : ");
time(&t2);
scanf("%d",&pilih);
break;
switch(pilih){
case 4:
case 1:
time(&t1);
flag = 1;
shell(A);
break;
time(&t2);
case 2:
break;
flag = 0;
case 5:
break;
time(&t1);
default:
flag = ascdesc();
puts("Menu tidak
merge_sort(A, 0, n- ada");
1, flag);
ascdesc();
time(&t2);
break;
break;
}
case 6:
return flag;
time(&t1);
}
flag = ascdesc();
void insertion(int A[]){
quick_sort(A, 0, n-
1, flag); int i, key, j, kondisi;

time(&t2); int flag = ascdesc();

break; for(i=1;i<n;i++){

case 7: key = A[i];

exit(0); j = i-1;

default: do{

puts("Menu tidak if(flag == 1)

ada.");
kondisi = A[j]
break; > key;

} else

if(pilih > 0 && pilih < 7) kondisi = A[j]

< key;
 if(kondisi){ kondisi = A[i]
< A[i+1];
A[j+1] = A[j];
if(kondisi){
j--;

} tukar(&A[i],&A[i+1]);

}while(kondisi && j >= did_swap = 1;

0);
}
A[j+1] = key;
i++;
}
}
}
pos_akhir--;
void selection(int A[]){
}
int i, min, j, kondisi;
}
int flag = ascdesc();
void shell(int A[]){
for(i=0;i<n-1;i++){
int jarak = n, did_swap, i,
min = i; kondisi;

for(j=i+1; j<n; j++){ int flag = ascdesc();

if(flag == 1) while(jarak > 1){

kondisi = A[j] jarak /= 2;

< A[min];
did_swap = 1;
else
while(did_swap){
kondisi = A[j]
> A[min]; i = 0;

if(kondisi) did_swap = 0;

min = j; while(i < (n-

jarak)){
}
if(flag == 1)
tukar(&A[i], &A[min]);
kondisi =
} A[i] > A[i+jarak];

} else

void bubble(int A[]){ kondisi =

A[i] < A[i+jarak];
int pos_akhir = n-2,
did_swap = 1, i, kondisi; if(kondisi){

int flag = ascdesc();

tukar(&A[i],&A[i+jarak]);
while((pos_akhir >= 0) &&
did_swap){ did_swap =
1;
i = 0;
}
did_swap = 0;
i++;
while(i <= pos_akhir){
}
if(flag == 1)
}
kondisi = A[i]
> A[i+1]; }

else }
void merge_sort(int A[], int l, ki1++;
int r, int flag){
i++;
int med;
}

while(ki2 <= ka2){

if(l < r){
hsl[i] = A[ki2];
med = (l+r) / 2;
ki2++;
merge_sort(A, l, med,
flag); i++;

merge_sort(A, med+1, r, }
flag);
j = l;
merge(A, l, med, r,
while(j <= r){
flag);
A[j] = hsl[j];
}
j++;
}
}
void merge(int A[], int l, int
med, int r, int flag){ }
int ki1 = l; void quick_sort(int A[], int p,
int r, int flag){
int ka1 = med;
int q;
int ki2 = med + 1;
if(p < r){
int ka2 = r;
q = partition(A, p, r,
int i = l, j, kondisi;
flag);
int hsl[n];
quick_sort(A, p, q,
while((ki1 <= ka1) && (ki2 flag);
<= ka2)){
quick_sort(A, q+1, r,
if(flag == 1) flag);

kondisi = A[ki1] <= }

A[ki2];
}
else
int partition(int A[], int p,
kondisi = A[ki1] >= int r, int flag){
A[ki2];
int pivot = A[p];
if(kondisi){
int i = p;
hsl[i] = A[ki1];
int j = r;
ki1++;
int kondisi;
}else{
while(i < j){
hsl[i] = A[ki2];
do{
ki2++;
if(flag == 1)
}
kondisi = A[j]
i++; > pivot;

} else

while(ki1 <= ka1){ kondisi = A[j]

< pivot;
hsl[i] = A[ki1];
 if(kondisi)

j--;

}while(kondisi);

do{

if(flag == 1)

kondisi = A[i]
< pivot;

else

kondisi = A[i]
> pivot;

if(kondisi)

i++;

}while(kondisi);

if(i < j){

tukar(&A[i],
&A[j]);

j--;

i++;

}else

return j;

return j;

void tukar(int *x, int *y){

int z;

z = *x;

*x = *y;

*y = z;

void tampil(int A[]){

int i;

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

printf("%d ",A[i]);}
B. Menu Sorting Data Struct printf("Input banyak mahasiswa :
");
#include <stdio.h>
scanf("%d",&n);
#include <stdlib.h>
for(i=0;i<n;i++){
#include <string.h>
printf("\nData siswa ke-
#define MAX 20 %d : \n", i+1);

fflush(stdin);

typedef struct{ printf("No\t: ");

int no; fflush(stdin);

char nama[MAX]; scanf("%d",&A[i].no);

float nilai; printf("Nama\t: ");

} mhs; fflush(stdin);

scanf("%s",&A[i].nama);

void menu(); printf("Nilai\t: ");

void urut(); fflush(stdin);

void sort_by(); scanf("%f",&A[i].nilai);

void selection(); awal[i] = A[i];

void insertion(); }do{

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

void shell(); A[i] = awal[i];

void merge(int, int, int); printf("\nMenu program :

\n");
void mergeR(int, int);
printf("1. Insertion
void quick(int, int); Sort\n");
int partition(int, int); printf("2. Selection
Sort\n");
void tukar(mhs *, mhs *);
printf("3. Bubble Sort\n");

printf("4. Shell Sort\n");

mhs
A[MAX],hasil[MAX],backup[MAX],key,x,a printf("5. Merge Sort\n");
wal[MAX],temp;
printf("6. Quick Sort\n");

printf("7. Exit\n");
int n, i, j, flag, sort;
printf("Pilih Menu [1-6]\t:
int main(){ ");
puts("\n\t\tMENU SORTING DATA scanf("%d", &pil);
STRUCT\n");
fflush(stdin);
menu();
switch(pil){
return 0;
case 1 :
}
urut();
void menu(){
sort_by();
int pil;
 printf("\nData sebelum case 5 :
diurutkan :\n");
urut();
tampil();
sort_by();
printf("\nData setelah
diurutkan :\n"); printf("\nData sebelum
diurutkan :\n");
insertion();
tampil();
tampil();
printf("\nData setelah
break; diurutkan :\n");

case 2 : mergeR(0, n-1);

urut(); tampil();

sort_by(); break;

printf("\nData sebelum case 6 :

diurutkan :\n");
urut();
tampil();
sort_by();
printf("\nData setelah
diurutkan :\n"); printf("\nData sebelum
diurutkan :\n");
selection();
tampil();
tampil();
printf("\nData Setelah
break; diurutkan :\n");

case 3 : quick(0, n-1);

urut(); tampil();

sort_by(); break;

printf("\nData sebelum case 7 :

diurutkan :\n");
exit(0);
tampil();
break;
printf("\nData setelah
diurutkan :\n"); default :

bubble(); printf(" Menu tidak

tersedia");
tampil();
}
break;
}while(pil!=7);
case 4 :
}
urut();
void urut(){
sort_by();
printf("\n Mode Urut:\n");
printf("\nData sebelum
diurutkan :\n"); printf(" 1. Ascending \n");

tampil(); printf(" 2. Descending \n");

printf("\nData setelah printf(" Pilih menu\t: ");

diurutkan :\n");
scanf("%d", &flag);
shell();
fflush(stdin);
tampil();
}
break;
void sort_by(){
 printf("\nSorting Data By\t: }
\n");
}
printf("1. Nomor \n");
}else{
printf("2. Nama \n");
if(flag==1){
printf("3. Nilai \n");
while(j>=0 &&
printf("Pilih menu\t: "); A[j].nilai>key.nilai){

scanf("%d", &sort); A[j+1] = A[j];

printf("\n"); j--;

fflush(stdin); }

} }else{

void insertion(){ while(j>=0 &&

A[j].nilai<key.nilai){
for(i=1; i<n; i++){
A[j+1] = A[j];
key = A[i];
j--;
j=i-1;
}
if(sort==1){
}
if(flag==1){
}
while(j>=0 &&
A[j].no>key.no){ A[j+1]=key;

A[j+1] = A[j]; }

j--; }

} void selection(){

}else{ int min;

while(j>=0 &&
A[j].no<key.no){
for(i=0; i<n-1; i++){
A[j+1] = A[j];
min=i;
j--;
j=i+1;
}
while(j<n){
}
if(sort==1){
}else if(sort==2){
if(flag==1){
if(flag==1){

while(j>=0 && if(A[j].no<A[min].no)

strcmpi(A[j].nama,key.nama) > 0){
min=j;
A[j+1] = A[j];
}else{
j--;

} if(A[j].no>A[min].no)

}else{ min=j;

while(j>=0 && }
strcmpi(A[j].nama,key.nama) < 0){
}else if(sort==2){
A[j+1] = A[j];
if(flag==1){
j--;
 A[i+1] =
if(strcmpi(A[j].nama,A[min].nama)<0) temp;

min=j; }

}else{ }else{

if(strcmpi(A[j].nama,A[min].nama)>0) if(A[i].no<A[i+1].no){

min=j; temp = A[i];

} A[i] =
A[i+1];
}else{
A[i+1] =
if(flag==1){ temp;

}
if(A[j].nilai<A[min].nilai)
}
min=j;
}else if(sort==2){
}else{
if(flag==1){

if(A[j].nilai>A[min].nilai)
if(strcmpi(A[i].nama,A[i+1].nama) >
min=j; 0){

} temp = A[i];

} A[i] =
A[i+1];
j++;
A[i+1] =
}
temp;
tukar(&A[i], &A[min]);
}
}
}else{
}

void bubble(){ if(strcmpi(A[i].nama,A[i+1].nama) <

0){
int i, j, pos_akhir, did_swap;
temp = A[i];

A[i] =
pos_akhir = n-2; A[i+1];

while(pos_akhir>=0 || A[i+1] =
did_swap==1){ temp;

for(i=0; i <= pos_akhir; i++) }

{
}
did_swap = 0;
}else{
if(sort==1){
if(flag==1){
if(flag==1){

if(A[i].nilai>A[i+1].nilai){
if(A[i].no>A[i+1].no){
temp = A[i];
temp = A[i];
A[i] =
A[i] = A[i+1];
A[i+1];
A[i+1] =
temp;
 }
tukar(&A[i], &A[i+jarak]);
}else{
did_swap
= 1;
if(A[i].nilai<A[i+1].nilai){
}
temp = A[i];
}
A[i] =
A[i+1]; }else if(sort==2){

A[i+1] = if(flag==1){
temp;

} if(strcmpi(A[i].nama,A[i+jarak].nama)
>0){
}

} tukar(&A[i], &A[i+jarak]);

} did_swap
= 1;
pos_akhir--;
}
}
}else{

}
if(strcmpi(A[i].nama,A[i+jarak].nama)
void shell(){ <0){

int jarak=n, did_swap, i;

tukar(&A[i], &A[i+jarak]);
mhs temp;
did_swap
= 1;

while(jarak>1){ }

jarak /= 2; }

did_swap = 1; }else{

while(did_swap){ if(flag==1){

did_swap = 0;
if(A[i].nilai>A[i+jarak].nilai){
i=0;
temp =
while(i-(n-jarak)){ A[i];

if(sort==1){ A[i] =
A[i+1];
if(flag==1){
A[i+1] =
temp;
if(A[i].no>A[i+jarak].no){
}

tukar(&A[i], &A[i+jarak]); }else{

did_swap
= 1; if(A[i].nilai<A[i+jarak].nilai){

} temp =
A[i];
}else{
A[i] =
A[i+1];
if(A[i].no<A[i+jarak].no){
 A[i+1] =
temp; hasil[i]=A[kiri2];

} kiri2++;

} i++;

} }

i++; }else{

}
if(A[kiri1].no<=A[kiri2].no){
}

} hasil[i]=A[kiri1];

} kiri1++;

void mergeR(int kiri,int kanan){ i++;

int med; }else{

hasil[i]=A[kiri2];
if(kiri<kanan){
kiri2++;
med=(kiri+kanan)/2;
i++;
mergeR(kiri,med);
}
mergeR((med+1),kanan);
}
merge(kiri,med,kanan );
}else if(sort==2){
}
if(flag==1){
}

void merge(int kiri,int med,int

if(strcmpi(A[kiri1].nama,A[kiri2].nam
kanan){
a)<=0){
int kiri1=kiri;

int kanan1=med; hasil[i]=A[kiri1];

int kiri2=med + 1; kiri1++;

int kanan2=kanan; i++;

int i = kiri; }else{

int j;
hasil[i]=A[kiri2];

while((kiri1<=kanan1)&&(kiri2<=kanan2 kiri2++;
)){
i++;
if(sort==1){
}
if(flag==1){
}else{

if(A[kiri1].no<=A[kiri2].no){
if(strcmpi(A[kiri1].nama,A[kiri2].nam
a)>=0){
hasil[i]=A[kiri1];

kiri1++; hasil[i]=A[kiri1];

i++; kiri1++;

}else{ i++;
 }else{ kiri1++;

i++;
hasil[i]=A[kiri2];
}while(kiri2<=kanan2){
kiri2++;
hasil[i]=A[kiri2];
i++;
kiri2++;
}
i++;
}
}for(j=kiri;j<=kanan;j++)
}else if(sort==3){
A[j] = hasil[j];
if(flag==1){
}

if(A[kiri1].nilai<=A[kiri2].nilai){ void quick(int l,int r){

int q;
hasil[i]=A[kiri1];
if(l<r){
kiri1++;
q=partition(l,r);
i++;
quick(l,q);
}else{
quick((q+1),r);

}
hasil[i]=A[kiri2];
}
kiri2++;
int partition(int l,int r){
i++;
mhs x;
}
int i = l;
}else{
int j = r;
if(A[kiri1].nilai=A[kiri2].nilai){ x = A[l];

while(i<j){
hasil[i]=A[kiri1];
if(sort==1){
kiri1++;
if (flag==1){
i++;
while(A[j].no>x.no)
}else{
j--;

hasil[i]=A[kiri2]; while(A[i].no<x.no)

kiri2++; i++;

i++; }else{

} while(A[j].no < x.no)

} j--;

}else{ while(A[i].no > x.no)

printf("Pilihan i++;
salah\n");
}
}
}else if(sort==2){
}while(kiri1<=kanan1){
if (flag==1){
hasil[i]=A[kiri1];
 mhs temp;
while(strcmpi(A[j].nama, x.nama)>0)

j--;
temp = *x;

while(strcmpi(A[i].nama, x.nama)<0) *x = *y;

i++; *y = temp;

}else{ }

void tampil(){
while(strcmpi(A[j].nama, x.nama)<0)
int i;
j--;
puts("\nNo\tNama\t\tNilai");

for(i=0;i<n;i++)
while(strcmpi(A[i].nama, x.nama)>0)
printf("%d\t%s\t\t
i++;
%g\n",A[i].no,A[i].nama,A[i].nilai);
}
puts("");
}else{
}
if (flag==1){

while(A[j].nilai >
x.nilai)

j--;

while(A[i].nilai <
x.nilai)

i++;

}else{

while(A[j].nilai <
x.nilai)

j--;

while(A[i].nilai >
x.nilai)

i++;

}if(i<j){

tukar(&A[i], &A[j]);

j--;

i++;

}else{

return j;

return j;

void tukar(mhs *x, mhs *y){

1. CAPTURE PROGRAM
a. Insertion Sort b. Selection Sort
c. Bubble Sort d. Shell Sort

e. Merge Short
f. Quick Sort
a. Insertion

b. Selection
 d. Shell

c. Bubble
e. Merge f. Quick

2. ANALISA DAN KESIMPULAN

 Pengurutan (sorting) merupakan proses pengurutan sejumlah data berdasarkan
susunan tertentu. Pengurutan itu sendiri dapat dilakukan dari nilai terkecil hingga
nilai terbesar (ascending) atau juga dari nilai terbesar ke nilai terkecil (descending).
Sorting ini sendiri digunakan untuk Menyelesaikan masalah-masalah kompleks
seperti pengolahan basis data, riset operasi, dll.

Pada percobaan diatas merupakan percobaan menghitung

waktu performance pada menu sorting. Metode sorting sendiri
terbagi atas Insertion, Selection, Bubble, Shell, Merge, dan Quick.
Dan ternyata pada setiap metode berbeda-beda waktu performance,
berdasarkan data terurut ascending atau descending , namun pada
perhitungan waktu performance yang menginputkan banyak data
lebih cepat daripada menginputkan sedikit data. Itu terbukti dengan
adanya diagram batang yang sudah tertera, yang membuktikan
bahwa metode yang paling cepat adalah Quick dan metode yang
paling lambat adalah Bubble karena bubble membutuhkan waktu
yang lama untuk mengurutkan data. Sedangkan berdasarkan
namanya quick membutuhkan waktu yang cepat untuk
mengurutkan data. Untuk metode lainnya membutuhkan waktu
yang sama untuk mengurutkan sebuah data