LAPORAN PRAKTIKUM II

SORTING (PENGURUTAN)
Disusun untuk Memenuhi Matakuliah Praktikum Algoritma dan Struktur Data
Dibimbing oleh Bpk. Utomo Pujianto

Oleh:
Ananda Putri Syaviri
130533608243
S1 PTI13 OFF B
UNIVERSITAS NEGERI MALANG
FAKULTAS TEKNIK
JURUSAN TEKNIK ELEKTRO
PRODI PENDIDIKAN TEKNIK INFORMATIKA
Februari 2014

SORTING

a) Tujuan instruksional umum :

1) Mahasiswa mampu melakukan perancangan aplikasi menggunakan Struktur Sorting
(pengurutan).
2) Mahasiswa mampu melakukan analisis pada algoritma Sorting yang dibuat.
3) Mahasiswa mampu mengimplementasikan algoritma Sorting pada sebuah aplikasi
secara tepat dan efisien.
Tujuan instruksional khusus:
1) Mahasiswa mampu menjelaskan mengenai algoritma Sorting.
2) Mahasiswa mampu membuat dan mendeklarasikan struktur algoritma Sorting.
3) Mahasiswa mampu menerapkan dan mengimplementasikan algoritma Sorting.
Tujuan
1. Mampu

melakukkan

perancangan

aplikasi

menggunakan

Strucktur

Sorting

(Pengurutan).
2. Mampu melakukkan analisis pada algoritma Sorting yang dibuat
3. Mampu mengimplementasikan algoritma Sorting pada sebuah aplikasi secara tepat
dan efesien.
b) Dasar Teori
- Pendahuluan
Pengurutan data dalam struktur data sangat penting terutama untuk data yang beripe
data numerik ataupun karakter. Pengurutan dapat dilakukan secara ascending (urut naik)
dan descending (urut turun). Pengurutan (Sorting) adalah proses pengurutan data yang
sebelumnya disusun secara acak sehingga tersusun secara teratur menurut aturan tertentu.
Contoh:
Data Acak : 5 6 8 1 3 25 10
Ascending : 1 3 5 6 8 10 25
Descending : 25 10 8 6 5 3 1
Deklarasi Array Sorting
Mendeklarasikan array secara global:
int data[100];
int n; //untuk jumlah data
Fungsi Tukar 2 Buah Data:
void tukar(int a,int b){
int tmp;
tmp = data[a];
data[a] = data[b];
data[b] = tmp;}

Sorting merupakan suatu proses untuk menyusun kembali humpunan obyek menggunakan
aturan tertentu. Sorting disebut juga sebagai suatu algoritma untuk meletakkan kumpulan
elemen data kedalam urutan tertentu berdasarkan satu atau beberapa kunci dalam tiap-tiap
elemen. Pada dasarnya ada dua macam urutan yang biasa digunakan dalam suatu proses
sorting:
1. Urut naik (ascending)
Mengurutkan dari data yang mempunyai nilai paling kecil sampai paling besar
2. Urut turun (descending)
Mengurutkan dari data yang mempunyai nilai paling besar sampai paling kecil.
Mengapa harus melakukan sorting data? Ada banyak alasan dan keuntungan dengan
mengurutkan data. Data yang terurut mudah untuk dicari, mudah untuk diperiksa, dan mudah
untuk dibetulkan jika terdapat kesalahan. Data yang terurut dengan baik juga mudah untuk
dihapus jika sewaktu-waktu data tersebut tidak diperlukan lagi. Selain itu, dengan
mengurutkan data maka kita semakin mudah untuk menyisipkan data atapun melakukan
penggabungan data.
Metode-metode sorting meliputi:
1. Insertion Sort (Metode Penyisipan)
2. Selection Sort (Metode Seleksi)
3. Bubble sort(Metode Gelembung)
4. Shell Sort (Metode Shell)
5. Quick Sort (Metode Quick)
6. Merge Sort (Metode Penggabungan)
1. Insertion Sort
Cara kerja insertion sort sebagaimana namanya.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 yangtelah di-sorting
dan bagian yang belum.
Algoritma Insertion Sort.
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).

2. Selection Sort
Algoritma sorting sederhana yang lain adalahSelection Sort. Ide dasarnya adalah
melakukan beberapa kali pass untuk melakukan penyeleksianelemen struktur data.
Untuk

sorting

ascending(menaik),

elemen

yang

paling

kecil

di

antara

elemenelemenyang belum urut, disimpan indeksnya,kemudian dilakukan pertukaran

nilai elemen denganindeks yang disimpan tersebut dengan elemen yangpaling depan
yang belum urut. Sebaliknya, untuksorting descending (menurun), elemen yang
paling. besar yang disimpan indeksnya kemudian ditukar.
Algoritma Selection Sort
Algoritma selection sort dapat dirangkum sebagaiberikut:

1.) Temukan nilai yang paling minimum (atau sesuaikeinginan) 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 posisi pertama di bagian struktur data yang
belum diurutkan.
3.) Ulangi langkah di atas untuk bagian struktur data yang tersisa.
3. Bubble Sort

Bubble Sort merupakan cara pengurutan yangsederhana. Konsep dari ide dasarnya
adalah sepertigelembung air untuk elemen struktur data yangsemestinya berada
pada posisi awal. Cara kerjanyaadalah 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. Jikaternyata urutannya tidak sesuai dengan pesanan,maka
dilakukan pertukaran (swap). Algoritma sortingini disebut juga dengan comparison
sort

dikarenakanhanya

mengandalkan

untukmengoperasikan elemennya.
Algoritma Bubble Sort

perbandingan

nilai

elemen

Algoritma bubble sort dapat diringkas sebagaiberikut, 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.
4. 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 Quick Sort
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).
(Biasanyaelemen yang paling kiri.)
3.) Bagi struktur data menjadi dua bagian satudengan elemen-elemen yang lebih
besar daripada pivot point, dan yang lainnya denganelemen-elemen yang lebih
kecil dari pada pivot point.
4.) Ulangi algoritma secara rekursif terhadapkedua paruh struktur data.
5. Merge Sort
Algoritma Merge Sort ditemukan oleh John vonNeumann di tahun 1945. Merge Sort
termasuk paradigma algoritma divide and conquer (kurang lebihberarti: bagi dan
atasi). Hal ini dikarenakan algoritma ini melakukan pembagian struktur data

sebelumkemudian dioperasi satu per satu. Intinya, algoritma ini menggunakan dua ide
utama sebagai berikut,
1.) Sebuah list yang kecil membutuhkan langkahyang lebih sedikit untuk pengurutan
daripadasebuah list yang besar.
2.) Untuk membentuk sebuah list terurut dari duabuah list terurut membutuhkan
langkah yanglebih sedikit daripada membentuk sebuah listterurut dari dua buah list
tak terurut. Contoh: hanya diperlukan satu kali traversal untukmasing-masing list
jika keduanya sudah terurut.
Algoritma Merge Sort
Algoritma Merge Sort sederhananya, dapat ditulis berikut:
1.) Bagi list yang tak terurut menjadi dua samapanjang 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.
6. Shell Sort
Metode ini dikembangkan oleh Donald L. Shell pada tahun 1959. Dalam metode ini
jarak antara dua elemen yang dibandingkan dan ditukarkan tertentu. Secara singkat
metode ini dijelaskan sebagai berikut. Pada langkah pertama, kita ambil elemen
pertama dan kita bandingkan dan kita bandingkan dengan elemen pada jarak tertentu
dari elemen pertama tersebut. Kemudain elemen kedua kita bandingkan dengan eleen
lain dengan jarak yang sama seperti jarak yang sama seperti diatas. Demikian
seterusnya sampai seluruh elemen dibandingkan. Pada langkah kedua proses diulang
dengan langkah yang lebih kecil, pada langkah ketiga jarak tersebut diperkecil lagi
seluruh proses dihentikan jika jarak sudah sama dengan satu.
Contoh dari proses Sorting dengan menggunakan metode Shell Sort :

Nama Program
Bahasa Pemrogramam
Compiler
Script program

Percobaan 1
Algoritma dan Struktur Data
: Program Sorting Data denga Metode buble sort.
: C++
: Code Blocks
:

#include <iostream.h>

void main ()
{
int NumList [8]=(5,34,32,25,75,42,22,2);
int temp;
cout<<"Data Sebelum Diurutkan : \n';
for (int d=1; d<8; d++)
(
cout<<setw(3)<<NumList(d);
)
cout<<"\n\n";
for(int i=0; i<7; i++)
for(int ii=0; ii<7; ii++)
if (NumList[ii] >= NumList[ii+1])
(
temp=NumList[ii]
NumList[ii]=NumList[ii+1]
NumList[ii+1]=temp
)
cout<<"Data Setelah Diurutkan : \n";
for(int iii=1; iii<8; iii++)
cout<<"setw(3)"<<NumList[iii]<<endl<<endl;
}

Script yang benar :

/*program sorting data dengan metode bubble sort */

#include <iostream>
#include <iomanip>
using namespace std;
int main ()
{
int NumList [8]={5,34,32,25,75,42,22,2};
int temp;
cout<<"Data Sebelum Diurutkan : \n";
for (int d=0; d<8; d++)
{
cout<<setw(3)<<NumList[d];

}
cout<<"\n\n";
for(int i=0; i<7; i++)
for(int ii=0; ii<7; ii++)
if (NumList[ii] >= NumList[ii+1])
{
temp=NumList[ii];
NumList[ii]=NumList[ii+1];
NumList[ii+1]=temp;
}
cout<<"Data Setelah Diurutkan : \n";
for(int iii=0; iii<8; iii++)
cout<<setw(3)<<NumList[iii]<<endl<<endl;

Output Program :

Algoritma :
1.
2.
3.
4.
5.
6.
7.
8.
9.

Mulai.
Membaca file header.
Membaca fungsi utama.
Membaca fungsi numlist [8].
Membaca fungsi temp.
Cetak hasil.
Tampilan data sebelum diurutkan.
Membaca fungsi perulangan.
Membaca fungsi metode bubble sort.
temp=NumList[ii];
NumList[ii]=NumList[ii+1];
NumList[ii+1]=temp;

10. Cetak hasil.

11. Tampilan data setelah diurutkan.
12. Membaca fungsi perulangan.
13. Cetak hasil.
14. Selesai.
Deskripsi:
Program diatas mengurutkan data yang sudah ada dengan menggunakan
bubble sort. Cara penggunaan file header dalam program ini tidak sama dengan
penggunaan file header dalam MinGw atau Visual C++. Penulisan array menggunakan

[ ]. Apabila menggunakan fungsi setw maka menggunakan file header <iomanip>.

Sistematika bubble sort dalam pengeksekusian program diatas adalah melakukan
traversal untuk membandingkan dua elemen berdekatan yang dilakukan dari belakang,
tergantung

perintahnya.

yang

diminta

asscending

atau

desscending.

maka

membandingkana mana angka yang lebih kecil atau lebih besar sesusai urutan tata
letaknya. jika lebih besar atau lebih kecil (tata urutannya salah) maka lakukan
pertukaran(swap). jika tidak lanjutkan ke proses traversal lainnya sampai urutannya
benar.

Penggunaan iostream dalam kode blocks tidak menggunakan .h dan

ditambah dengan using namespace std. algoritma program diatas singkatnya adalah
terdapat 8 data maka akan terjadi 7 langkah. Langkah pertama adalah menentukan 22
dan 2 apakah sudah benar posisinya, karena ascending maka A[i]>A[i+1] geser kanan.
Maka 22 dan 2 berpindah logikanya 22>2 tidak ada 22<2. Kemudian seterusnya
sampai 7 kali tahap

Nama Program
Bahasa Pemrogramam
Compiler
Script program

Percobaan 2
Algoritma dan Struktur Data
: Program sorting data dengan selection sort.
: C++
: Code Blocks
:

#include <iostream.h>
#include <iomanip.h>
void SelectionSort (int Array [], const int Size)
{
int i,j,kecil,temp;
for (i=0; i<Size; i++)
{
kecil=i;
for(j=1; j<Size; j++)
{
if (Array[kecil]>Array[j])
{kecil=j;}
}
Array[i]=Array[kecil];
Array[kecil]=temp;
temp= Array [i];
}
}
int main ()
{
int NumList[8]={5,34,32,25,75,42,22,2};
int temp;
cout<<"Data Sebelum Diurutkan: \n";
for(int d=0; d<8;d++)
{
cout<<setw(3)<<NumList(d);
}
cout<<"\n\n";
SelectionSort (NumList, 8);

cout<<"Data Setelah Diurutkan : \n";

for (int iii=0; iii<8; iii++)
cout<<"setw(3)"<<NumList[iii]<<endl<<endl;

Script yang benar :

/*Selection Sort*/
#include <iostream>
#include <iomanip>
using namespace std;
void SelectionSort (int array [], const int size)
{
int i,j,kecil,temp;
for (i=0; i<size; i++)
{
kecil=i;
for(j=i+1; j<size; j++)
{
if (array[kecil]>array[j])
{kecil=j;}
}temp= array [i];
array[i]=array[kecil];
array[kecil]=temp;
}
}
int main ()
{
int NumList[8]={5,34,32,25,75,42,22,2};
int temp;
cout<<"Data Sebelum Diurutkan: \n";
for(int d=0; d<8;d++)
{
cout<<setw(3)<<NumList[d];
}
cout<<"\n\n";
SelectionSort (NumList, 8);

cout<<"Data Setelah Diurutkan : \n";

for (int iii=0; iii<8; iii++)
cout<<setw(3)<<NumList[iii]<<endl<<endl;

Output Program:

Algoritma :
1. Mulai.
2. Membaca file header.
3. Membaca fungsi,int, kecil, temp.
4. Membaca perulangan beserta fungsi kecil dan temp.

5. Membaca fungsi utama, fungsi numlist dan temp.

6. Membaca perulangan.
7. Cetak hasil.
8. Tampilan data sebelum diurutkan.
9. Membaca fungsi metode selection sorting.
10. Membaca perulangan.
11. Cetka hasil.
12. Tampilan data setelah diurutkan.
13. Selesai.
Deskripsi :
Program diatas menggunakan metode selection sort untuk mengurutkan
beberapa bilangan. Penulisan file header dalam code blocks perlu diperhatikan
karena tidak sama dengan penulisan script pada MinGw atau visual c++. Dalam
code blocks untuk penulisan fungsi atau rumus biasanya berwarna, jika terdapat
kesalahan pada saat pengeksekusian hal lain yang perlu diperhatikan adalah
penulisan rumus. Sistematika pengurutan bilangan dengan metode selection sort
adalah menemukan nilai paling minimum/maksimum sesuai dengan perintah
apakah assceding atau desscending. kemudia tukar nilai dengan nilai pada posisi
pertama pada bagian struktur data yang belum diurutkan. kemudian lakukan terus
penukaran nilai sampai semua struktur data tidak ada yang tdak di seleksi.
Algoritma program diatas adalah menggunakan pembanding dan posisi. Angka
tersebut di urutkan kemudian di posusikan barulah dilakukan pertukaran bilangan
apabila memenuhi syarat. Seperti program diatas : 5 34 32 25 75 42 22 2.
Pembandingnya terdiri dari 5<34 maka posisinya 0 karena suda benar peletakkan,
kemudian 5<32 juga 0, 5<25= 0, 5<75=0, 5<42=0, 5<22=0, 5<2 karena
pembanding ini salah maka harus dilakukan swappenukaran sebanyak 7x.
begitu seterusnya sehingga bilangan menjadi urut, karena ada 8 data maka akan
terjadi tahapan sebanyak 7 kali.

Nama Program
Bahasa Pemrogramam
Compiler
Script program

Percobaan 3
Algoritma dan Struktur Data
: Program shell sort.
: C++
: Code Blocks
:

/*shell sort*/
#include<iostream>
using namespace std;
int main(void)
{
int array[5];
int length = 5;

// An array of integer
// Length of the array

int i, j, d;
int tmp, flag;
//some input
for(i=0; i<length; i++)
{
cout<<"Enter a number: ";
cin>>array[i];
}
//Algorithm
d=length;
flag=1;
while(flag || (d>1))
{
flag=0;
d=(d+1)/2;
for(i=0; i<(length -d); i++)
{
if(array[i+d]>array[i])
{
tmp=array[i+d];
array[i+d]=array[i];
array[i]=tmp;
flag=1;
}
}
}

//Some output
for(i=0; i<5; i++)
{
cout<<array[i]<<endl;
}

Output Program :

Algoritma :
1. Mulai
2. Membaca file header.
3. Membaca fungsi main.
4. Membaca fungsi array yang didalamnya terdpat fungsi panjang.
5. Membaca perulangan.
6. Membaca percabangan.
7. Membaca fungsi temp.
8. Membaca perulangan.
9. Pemanggilan array[i].
10. Cetak hasil.
11. Selesai.
Deskripsi :

Program diatas menggunakan metode sheel short yang sistematika

membandingkan elemen pertama dengan elemen lain yang berada dalam jarak
yang sama namun yang lingkupnya paling jauh, begitu seterusnya sampai
membandingkan elemen pada jarak yang berdekatan satu sama lain. Algroitma
program diatas adalah karena sistematikanya membandingkan antar elemen yang
letaknya berjauhan sampai terdekat maka seperti ini ilustrasinya : angka yang
diinputkan tergantung pengguna. Misalnya ingin menginputkan 4 data maka aka
nada 4 data , misalnya 6 9 7 4 maka sistematika kerjanya adlaah 6 akan
dibandingkan dengan 4 , 7, 9 dari jarak terjauh-terdekat. Kemudian tentukan jika
ascending atau descending pernyataan bilangannya seperti apa contoh 6<4 dan
lain sebagainya.

Nama Program
Bahasa Pemrogramam
Compiler
Script program

Percobaan 4
Algoritma dan Struktur Data
: Program Quick sort.
: C++
: Code Blocks.
:

#include<iostream.h>
#include<iomanip.h>
void quickSort(int[], int);
void q_sort(int[], int, int);
void main()
{
int NumList[8]={5,34,32,25,75,42,22,2};
int temp;
cout<<"Data Sebelum Diurutkan: \n";
for(int d=0; d<8; d++)
{
cout<<setw(3)<<NumList(d);
}
cout<<"\n\n";
quickSort (NumList,8);
cout<<"Data Setelah Diurutkan: \n";
for (int iii=0; iii<8; iii++)
cout<<"setw(3)"<<NumList[iii]<<endl<<endl;
}
void quickSort(int numbers[], int array_size)
{
q_sort(number, 0, array_size-1);
}
void q_sort(int number[], int left, int right)
{
int pivot, l_hold, r_hold;
l_hold=left;
r_hold=right;
pivot = numbers[left];
while (left<right)
{

while((numbers[right]>=pivot || (left<right))
right--;
if(left != right)
{
numbers[left]=numbers[right];
left++;
}
while ((numbers[left] <=pivot) && (left<right))
left++;
if (left != right)
{
number[right]=numbers[left];
right--;
}

}
numbers[left]=pivot;
pivot=left;
left=l_hold;
right=r_hold;
if (left<pivot)
q_sort(numbers, left, pivot-1);
if (right>pivot)
q_sort(numbers, pivot+1, right);

Script program yang benar:

/*Quick Sort*/
#include<iostream>
#include<iomanip>
#include <conio.h>
using namespace std;
void quickSort(int[], int);
void q_sort(int[], int, int);
int main()
{
int NumList[8]={5,34,32,25,75,42,22,2};
int temp;
cout<<"Data Sebelum Diurutkan: \n";
for(int d=0; d<8; d++)
{
cout<<setw(3)<<NumList[d];
}
cout<<"\n\n";
quickSort (NumList,8);
cout<<"Data Setelah Diurutkan: \n";
for (int iii=0; iii<8; iii++)
cout<<setw(3)<<NumList[iii]<<endl<<endl;
}
void quickSort(int numbers[], int array_size)
{
q_sort(numbers, 0, array_size-1);
}
void q_sort(int numbers[], int left, int right)
{
int pivot, l_hold, r_hold;
l_hold=left;
r_hold=right;
pivot = numbers[left];
while (left<right)

while((numbers[right]>=pivot) && (left<right))

right--;
if(left != right)
{
numbers[left]=numbers[right];
left++;
}
while ((numbers[left] <=pivot) && (left<right))
left++;
if (left != right)
{
numbers[right]=numbers[left];
right--;
}

}
numbers[left]=pivot;
pivot=left;
left=l_hold;
right=r_hold;
if (left<pivot)
q_sort(numbers, left, pivot-1);
if (right>pivot)
q_sort(numbers, pivot+1, right);
}

Output Program :

Algoritma :
1. Mulai.
2. Membaca file header.
3. Membaca fungsi metode quick sort.
4. Membaca fungsi numlist [8], temp.
5. Membaca perulangan.
6. Pemanggilan fungsi quicksort.
7. Cetak hasil.
8. Tampilan data sebelum diurutkan.
9. Membaca fungsi quicksort (numlist,8).
10. Cetak hasil.
11. Tampilan data setelah diurutkan.
12. Selesai.
Deskripsi :
Program diatas menggunakan metode quick sort yang sistematika quick
sort adalah pertama jika struktur data terdiri dari 1/0 maka kembalikan struktur
data apa adanya, jangan diubah. kemudian ambil sebuah elemen yang akan
digunakan sebagai pivot biasanya elemen paling kiri. bagi struktur data menjad 2

bagian, satu dengan elemen yang lebih besar daripada pivot, dan lainnya dengan
elemen yang lebih kecil dengan pivot. ulangi terus secara rekursif terhadap kedua
pruh struktur tersebut.

Nama Program
Bahasa Pemrogramam
Compiler
Script program

Percobaan 5
Algoritma dan Struktur Data
: Program Radix sort.
: C++
: Code Blocks.
:

#include <iostream.h>
#include <stdlib.h>
#include <string.h>
void radix (int byte, long N, long *source, long *dest)
{
long count[256];
long index[256];
memset(count, 0, sizeof (count));
for (int i-1; i<N; i++) count[((source[i])>>(byte*8))&0xff]++;
index[0]=0;
for(i=1; i<256; i++) index[i]=index[i-1]+count[i-1];
for(i=0; i<N; i++) dest [index[((source[i])>>(byte*8))&0xff]+
+]=

source[i];

}
void radixsort (long *source, long *temp, long N)
{
radix (0, N, source, temp);
radix (1, N, temp, source);
radix (2, N, source, temp);
radix (3, N, temp, source);
}
void make_random (long *data, long N)
{
for(int i=0; i<N; i++) data[i]=rand()|(rand()<<16);
}
long data [100];
long temp [100];
void main(void)
{
make_random(data, 100);
radixsort(data, temp, 100);
for(int i=0; i<100; i++) cout<<data[i]<<'\n';
}

Script program yang benar:

/*Radix Sort*/
#include <iostream>
#include <stdlib.h>
#include <string.h>
using namespace std;
void radix (int byte, long N, long *source, long *dest)
{
long count[256];

long index[256];
memset(count, 0, sizeof (count));
for (int i=0; i<N; i++) count[((source[i])>>(byte*8))&0xff]++;
index[0]=0;
for(int i=1; i<256; i++)index[i]=index[i-1]+count[i-1];
for(int
i=0;
i<N;
i++)
[index[((source[i])>>(byte*8))&0xff]++]=
source[i];
}
void radixsort (long *source, long *temp, long N)
{
radix (0, N, source, temp);
radix (1, N, temp, source);
radix (2, N, source, temp);
radix (3, N, temp, source);
}
void make_random (long *data, long N)
{
for(int i=0; i<N; i++) data[i]=rand()|(rand()<<16);
}
long data [100];
long temp [100];
int main(void)
{
make_random(data, 100);
radixsort(data, temp, 100);
for(int i=0; i<100; i++) cout<<data[i]<<'\n';
}

Output Program :

Algoritma :
1. Mulai
2. Membaca file header.
3. Membaca fungsi utama radix.
4. Membaca rumus radix menggunakana memset.
5. Membaca perulangan.
6. Membaca fungsi radixsort.
7. Membaca fungsi make_random.
8. Membaca fungsi utama.
9. Pemanggilan fungsi make_random,radixsort.
10. Membaca perulangan.
11. Cetak hasil.
12. Selesai.

dest

Deskripsi :
Program diatas meggunakan metode radix sort yang sistematikanya adalah mengkategorikan
data-data menjadi sub kumpulan data sesuai dengan nilai radix-nya, mengkonkatenasinya,
kemudian mengkategorikannya kembali berdasar nilai radix lainnya.

Nama Program
Bahasa Pemrogramam
Compiler
Script program
#include
#include
#include
#include

Tugas Rumah 1
Algoritma dan Struktur Data
: Program Menu Sorting (mengurutkan) Bilangan.
: C++
: Code Blocks.
:

<stdio.h>
<iostream>
<stdlib.h>
<conio.h>

using namespace std;

int data[10],data2[10];
int n;
char p;
void A_D()
{
printf("\n Pilihan Pengurutan Ascending/Descending (N/T) : ");
scanf("%s",&p);
}
void tukar(int a,int b)
{
int temp;
temp = data[b];
data[b] = data[a];
data[a] = temp;
}
void bubble_sort()
{
A_D();
if (p=='N'||p=='n') //Ascending
{for(int i=1;i<n;i++)
{for(int j=n-1;j>=i;j--)
{if(data[j]<data[j-1])
tukar(j,j-1);
}
}
}
else if (p=='T'||p=='t') //Descending
{
for(int i=1;i<n;i++){
for(int j=n-1;j>=i;j--){
if(data[j]>data[j-1])
tukar(j,j-1);
}
}
}
cout<<"Bubble Sort Selesai, Silahkan Lihat Data Anda ke Menu
No.8"<<endl;
}
void exchange_sort()
{

A_D();
if (p=='N'||p=='n')
{
for (int i=0; i<n-1; i++)
{
for(int j = (i+1); j<n; j++)
{
if (data [i] > data[j])
tukar(i,j);
}
}
}
else if (p=='T'||p=='t')
{
for (int i=0; i<n-1; i++)
{
for(int j = (i+1); j<n; j++)
{
if (data [i] < data[j])
tukar(i,j);
}

}
cout<<"Exchange Sort Selesai, Silahkan Lihat Data Anda ke Menu
No.8"<<endl;
}
void selection_sort()
{
int pos,i,j;
A_D();
if (p=='N'||p=='n')
{
for(i=0;i<n-1;i++)
{
pos = i;
for(j = i+1;j<n;j++)
{
if(data[j] < data[pos])
pos = j;
}
if(pos != i) tukar(pos,i);
}
}
else if (p=='T'||p=='t')
{
for(i=0;i<n-1;i++)
{
pos = i;
for(j = i+1;j<n;j++)
{
if(data[j] > data[pos])
pos = j;
}
if(pos != i) tukar(pos,i);
}
}
cout<<"Selection Sort Selesai, Silahkan Lihat Data Anda ke Menu
No.8"<<endl;
}

void insertion_sort()
{
int temp,i,j;
A_D();
if (p=='N'||p=='n')
{
for(i=1;i<n;i++)
{
temp = data[i];
j = i -1;
while(data[j]>temp && j>=0)
{
data[j+1] = data[j];
j--;
}
data[j+1] = temp;
}
}
else if (p=='T'||p=='t')
{
for(i=1;i<n;i++)
{
temp = data[i];
j = i -1;
while(data[j]<temp && j>=0)
{
data[j+1] = data[j];
j--;
}
data[j+1] = temp;
}
}
cout<<"Insertion Sort Selesai, Silahkan Lihat Data Anda ke Menu
No.8"<<endl;
}
void QuickSort(int L, int R)
{
int i, j;
int mid;

A_D();
if (p=='N'||p=='n'){
i = L;
j = R;
mid = data[(L+R) / 2];
do
{
while (data[i] < mid) i++;
while (data[j] > mid) j--;
if (i <= j)
{
tukar(i,j);
i++;
j--;
};

} while (i < j);

if (L < j) QuickSort(L, j);
if (i < R) QuickSort(i, R);
}
}
void shell_sort()
{
int j,i,k,m,mid;
A_D();
if (p=='N'||p=='n')
{
for(m = n/2;m>0;m/=2)
{
for(j = m;j< n;j++)
{
for(i=j-m;i>=0;i-=m)
{
if(data[i+m]>=data[i])
break;
else
{

mid = data[i];
data[i] = data[i+m];
data[i+m] = mid;

}
}
}
else if (p=='T'||p=='t')
{
for(m = n/2;m>0;m/=2)
{
for(j = m;j< n;j++)
{
for(i=j-m;i>=0;i-=m)
{
if(data[i+m]<=data[i])
break;
else
{
mid = data[i];
data[i] = data[i+m];
data[i+m] = mid;
}
}
}
}
}
cout<<"Shell Sort Selesai, Silahkan Lihat Data Anda ke Menu No.8
"<<endl;
}
void Input_Data()
{
printf("\n Masukkan jumlah data yang dibutuhkan : ");
scanf("%d",&n);
for(int i=0;i<n;i++)

printf("Masukkan data ke-%d : ",(i+1));

scanf("%d",&data[i]);
data2[i] = data[i];

}
}
void AcakLagi()
{
for(int i=0;i<n;i++)
{
data[i] = data2[i];
}
printf("\n Data sudah teracak\n");
}
void Tampil()
{
printf("\n Data = ");
for(int i=0;i<n;i++)
{
printf("%d ",data[i]);
}
printf("\n");
}
main()
{
system("cls");
int pil;
do
{
system("cls");
cout<<" >>>>>>>>>>>>>>><<<<<<<<<<<<< "<<endl;
cout<<" | Program Menu Sorting Data |"<<endl;
cout<<" >>>>>>>>>>>>>>><<<<<<<<<<<<< "<<endl;
cout<<" 1. Input Data"<<endl;
cout<<" 2. Bubble Sort"<<endl;
cout<<" 3. Exchange Sort"<<endl;
cout<<" 4. Insertion Sort"<<endl;
cout<<" 5. Selection Sort"<<endl;
cout<<" 6. Quick Sort"<<endl;
cout<<" 7. Shell Sort"<<endl;
cout<<" 8. Tampilkan Hasil Data"<<endl;
cout<<" 9. Acak"<<endl;
cout<<" 10.Exit"<<endl<<endl;
cout<<"**********************************************"<<endl;
printf(" Pilihan Anda : ");scanf("%d",&pil);
switch(pil) //pemilihan sorting
{
case 1:Input_Data();break;
case 2:bubble_sort();break;
case 3:exchange_sort();break;
case 4:insertion_sort();break;
case 5:selection_sort();break;
case 6:QuickSort(0,n-1);
printf("\n Quick sort selesai, Silahkan Inputkan Data Anda ke
Menu No.1");break;
case 7:shell_sort();break;
case 8:Tampil();break;
case 9:AcakLagi();break;
}
getch();
}

while(pil!=10);

Output Program :

Algoritma :
1. Mulai
2. Membaca file header
3. Membaca fungsi integer array , integer n , char p.
4. Membaca fungsi Ascending-descending.
5. Membaca fungsi tukar.
6. Membaca fungsi bubble sort,exchange sort, selection sort, insertion sort, quick sort,
shell sort, input data, acak lagi, tampil.
7. Membaca fungsi utama.
8. Tampilan menu program sorting.
9. Membaca percabangan menu.
10. Pemanggilan tiap tiap fungsi dalam percabangan.
11. Cetak hasil.
12. Membaca fungsi exit.
13. Cetak hasil.
14. Selesai.
Deskripsi :
Program diatas merupakan kumpulan dari beberapa metode sorting. Dalam program diatas
menggunakan 6 metode sorting, yaitu: bubble sort, exchange sort, insertion sort, selection
sort, quick sort dan shell sort. Dalam program diatas menggunakan beberapa fungsi yaitu
untuk fungsi ascending-descending untuk jenis sorting yang diinginkan saat program berjalan.
Kemudian fungsi tukar untuk proses pengurutan bilangan. Fungsi 6 metode sorting. Fungsi

utama yang di dalamnya terdapat tampilan program menu sorting kemudia percabangan untuk
pemanggilan setiap fungsi ketika program dijalankan. Dan yang terakhir pemanggilan fungsi
while untuk pilihan keluar dari program tersebut.

Nama Program
Bahasa Pemrogramam
Compiler
Script program

Tugas Rumah 2
Algoritma dan Struktur Data
: Program Menu Sorting Bilangan secara Random
: C++
: Code Blocks.
:

#include <iostream>
#include <iomanip>
#include <conio.h>
#include <time.h>
#include <windows.h>
#define MAX 1
using namespace std;
int bubble(); int SelectionSort(); int shell();
int insertion(); int exchange();
int pilihan,hitung,i;
char ulang,choose;
char nx[10]; int data[MAX];
int data1[100];
int temp; int n;
int cek(char str[])
{
int i, panjang;
panjang=strlen(str); /*strlen berfungsi untuk mengetahui jumlah nilai*/
for(i=0;i<panjang;i++)
{
if((i==0)&&(str[i]=='-'))
i++;
if(!isdigit(str[i])) /*isdigit berfungsi untuk mengembalikan nilai selain
nol*/
{
cout<<"Inputan Salah ! Harap Mengulangi !\n";
return 0;
}
}
return 1;
}
int main()
{
mulai :
system ("cls");
do
{
cout<< "\t\t\t ++++++++++++++++++++++++++++++\n";
cout<< "\t\t\t | Program Menu Sorting Data |\n";
cout<< "\t\t\t ++++++++++++++++++++++++++++++\n";
cout<<" "<<endl<<endl;
cout<<"\tMasukkan Jumlah Data : ";
cin>>nx;

cout<<endl;
}
while(!cek(nx));
n=atoi(nx); /*atoi berfungsi untuk mengubah string (teks) angka menjadi
bilangan numerik integer*/
int data[100];
srand(time(NULL)); /*srand berfungsi untuk menentukan seed atau posisi
awal dalam sebuah pengacakan,
sedangkan time(NULL) berfungsi untuk mengembalikan
nilai yang kemudian di jadikan*/
int i;
for(i=0;i<n;i++)
{
data[i]= rand()%n; /*rand berfungsi untuk mengembalikan sebuah nilai
integer*/
cout<<data[i]<<" ";
}
cout<<"\n\n\n";
{
for (hitung=0;hitung<n;hitung++)
data1[hitung]=data[hitung];
cout<<"\t PILIHAN MENU METODE SORTING \n";
cout<<"\t >> [1] Bubble sort\n";
cout<<"\t >> [2] Selection sort\n";
cout<<"\t >> [3] Shell sort\n";
cout<<"\t >> [4] Insertion sort\n";
cout<<"\t >> [5] Exchange sort\n";
cout<<"\t >> [6] EXIT\n";
cout<<" Pilihan Anda ... (1-2-3-4-5-6) ?? : ";
cin>>pilihan;
cout<<"Pilih Ascending or Descending [A/D] ? ";
cin>>choose;
switch (pilihan)
{
case 1:
bubble();
break;
case 2:
SelectionSort();
break;
case 3:
shell();
break;
case 4:
insertion();
break;
case 5:
exchange();
break;
case 6:
exit(1);
default:
{
cout<<"\tInputan Anda Tidak Ada\n\n";
}
break;
}
repeat :
cout<<"\n\t\tUlangi Lagi [Y/N] ?? : ";
cin>>ulang;
cout<<"\n\n";
if (ulang=='y'||ulang=='Y')

goto mulai;
}
else if(ulang=='n'||ulang=='N')
{
system ("cls");
cout<<"\n\n\t\t\tTerima Kasih"<<endl;
exit(1);
}
else
{

}
}

system("cls");
cout<<"Inputan Data Anda Tidak Ada ...\n\n";
getch();
goto repeat;

int bubble()
{
cout<<"----------------------------------------------------\n";
for (int i=0; i<n-1; i++)
for (int ii=0; ii<n-1; ii++)
if (data1[ii]>=data1[ii+1])
{
temp=data1[ii];
data1[ii]=data1[ii+1];
data1[ii+1]=temp;
}
if ((choose=='a')||(choose=='A'))
{
cout<<"\nMenjalankan metode Bubble Sort dengan pengurutan Ascending";
cout<<"\n\nHasil Pengurutan : \n\n";
for(int iii=0; iii<n; iii++)
cout<<data1[iii]<<" ";
}
if ((choose=='d')||(choose=='D'))
{
cout<<"\nMenjalankan metode Bubble Sort dengan pengurutan Descending";
cout<<"\n\nHasil Pengurutan : \n\n";
for(int iii=n-1; iii>=0; iii--)
cout<<data1[iii]<<" ";
}
cout<<"\n";

int SelectionSort()
{
cout<<"----------------------------------------------------\n";
int kecil;
for (int i=0;i<n;i++)
{
kecil=i;
for (int j=kecil+1; j<n;j++)
{
if (data1[kecil]>data1[j])
{kecil=j;}

}
temp=data1[i];
data1[i]=data1[kecil];
data1[kecil]=temp;
}
if ((choose=='a')||(choose=='A'))
{
cout<<"\nMenjalankan metode Selection Sort dengan pengurutan Ascending";
cout<<"\n\nHasil Pengurutan : \n\n";
for(int iii=0; iii<n; iii++)
cout<<data1[iii]<<" ";
}
if ((choose=='d')||(choose=='D'))
{
cout<<"\nMenjalankan metode Selection Sort dengan pengurutan Descending";
cout<<"\n\nHasil Pengurutan : \n\n";
for(int iii=n-1; iii>=0; iii--)
cout<<data1[iii]<<" ";
}
cout<<"\n";
}
int shell()
{
cout<<"----------------------------------------------------\n";
int gap=n/2;
do
{
int swap;
do
{
swap=0;
for(int i=0;i<n-gap;i++)
if(data1[i]>data1[i+gap])
{
int t=data1[i];
data1[i]=data1[i+gap];
data1[i+gap]=t;
swap=1;
}
}
while(swap); /*swap digunakan untuk menukarkan dua buah nilai*/
}
while(gap=gap/2);
if ((choose=='a')||(choose=='A'))
{
cout<<"\nMenjalankan metode Shell Sort dengan pengurutan Ascending";
cout<<"\n\nHasil Pengurutan : \n\n";
for(i=0;i<n;i++)
cout<<data1[i]<<" ";
}
if ((choose=='d')||(choose=='D'))
{
cout<<"\nMenjalankan metode Shell Sort dengan pengurutan Descending";
cout<<"\n\nHasil Pengurutan : \n\n";
for(i=n-1;i>=0;i--)
cout<<data1[i]<<" ";
}

cout<<endl;
}
int insertion()
{
cout<<"----------------------------------------------------\n";
int temp,i,j;
for(i=1;i<n;i++)
{
temp = data[i];
j = i -1;
while(data[j]>temp && j>=0)
{
data[j+1] = data[j];
j--;
}
data[j+1] = temp;
}
if ((choose=='a')||(choose=='A'))
{
cout<<"\nMenjalankan metode Insertion Sort dengan pengurutan Ascending";
cout<<"\n\nHasil Pengurutan : \n\n";
for(int iii=0; iii<n; iii++)
cout<<data1[iii]<<" ";
}
if ((choose=='d')||(choose=='D'))
{
cout<<"\nMenjalankan metode Insertion Sort dengan pengurutan Descending";
cout<<"\n\nHasil Pengurutan : \n\n";
for(int iii=n-1; iii>=0; iii--)
cout<<data1[iii]<<" ";
}
cout<<"\n";
}
void tukar (int a, int b)
{
int t ;
t = data [b] ;

data [b] = data [a] ;

data [a] = t ;
}
int exchange()
{
cout<<"----------------------------------------------------\n";
for (int i=0; i<n-1; i++)
{
for (int j=(i+1); j<n; j++)
{
if (data [i] > data [j])
tukar (i, j) ;
}
}
if ((choose=='a')||(choose=='A'))
{
cout<<"\nMenjalankan metode Exchange Sort dengan pengurutan Ascending";
cout<<"\n\nHasil Pengurutan : \n\n";
for(int iii=0; iii<n; iii++)
cout<<data1[iii]<<" ";
}
if ((choose=='d')||(choose=='D'))
{
cout<<"\nMenjalankan metode Exchange Sort dengan pengurutan Descending";

cout<<"\n\nHasil Pengurutan : \n\n";

for(int iii=n-1; iii>=0; iii--)
cout<<data1[iii]<<" ";
}
cout<<"\n";

Output Program :

Algoritma :
1. Mulai
2. Membaca file header.
3. Membaca fungsi int metode sorting.
4. Membaca fungsi int data, temp, cek, char ulang-choose, char array.
5. Membaca fungsi utama.
6. Masukkan jumlah data.
7. Membaca perulangan dari fungsi cek.
8. Membaca fungsi int i.
9. Membaca perulangan for pada pilihan menu program.
10. Membaca pemanggilan fungsi choose.
11. Membaca percabangan switch case.
12. Membaca pemanggilan fungsi metode sorting.
13. Membaca fungsi default, jika salah maka akan muncul pemanggilan fungsi repeat
untuk mengulang opsi menu.
14. Cetak hasil.
15. Selesai.
Deskripsi :
Program diatas merupakan program pilihan menu sorting secara random , jadi bilangan yang
diinputkan dibaca acak oleh program sesuai dengan rumus fungsi yang ditetapkan dalam
syntax. Dalam program diatas menggunakan banyak fungsi diantaranya int metode sorting
yang digunakan, int data array , temp, cek, char ulang, choose, char array. Menggunakan
perulangan dari fungsi cek yang fungsinya untuk menghitung jumlah data yang diinputkan
saat program berjalan. Kemudian menggunakan fungsi temp untuk penyimpanan sementara.
Penggunaan fungsi int i yang fungsinya untuk fungsi random. Kemudian menggunakan
perulangan for untuk pilihan menu program serta pemanggilan fungsi choose. Percabangan
switch case yang digunakan dalam pilihan menu sorting yang diinginkan saat program
berjalan. Menggunakan pemanggilan fungsi setiap metode sorting yang disediakan. Kemudian

penggunaan fungsi default , jika pilihan yang di entrikan tidak sesuai maka muncul fungsi
untuk mengulang etrian menu yang diinginkan.

Nama Program
Bahasa Pemrogramam
Compiler
Script program
- ASCENDING

Tugas Rumah 3
Algoritma dan Struktur Data
: Program sorting untuk abjad.
: C++
: Code Blocks.
:

#include<iostream>
#include<conio.h>
#include<windows.h>
using namespace std;
main()
{
int angka[20],a,b,c;
char huruf[20],kedua[20][20],pilihan;
cout<<"==============================\n";
cout<<"\t PROGRAM SORTING \n";
cout<<"==============================\n\n";
cout<<"Masukan jumlah maksimal: ";cin>>a;
for(b=0;b<a;b++)
{
cout<<"Masukan huruf ke "<<b+1<<" : ";cin>>huruf[b];
cout<<"Masukan angka ke "<<b+1<<" : ";cin>>angka[b];
cout<<"\n";
}
system("cls");
cout<<"\n tampilkan sebelum sorting: \n";
for(b=0;b<a;b++)
{
cout<<huruf[b]<<" ";
}
cout<<"\n";
for(b=0;b<a;b++)
{
cout<<angka[b]<<" ";
}
for(b=0;b<a-1;b++){
for(c=0;c<a-1-b;c++){
if(huruf[c]>huruf[c+1])
{
int tmp,tmp1;
tmp=huruf[c];
tmp1=angka[c];
huruf[c]=huruf[c+1];
huruf[c+1]=tmp;
angka[c]=angka[c+1];
angka[c+1]=tmp1;
}
}
}
cout<<"\n\nsetelah di sorting berdasarkan huruf\n";
cout<<"\n";
for(b=0;b<a;b++){
cout<<huruf[b]<<" ";
}
cout<<"\n";

for(b=0;b<a;b++){
cout<<angka[b]<<" ";
}
}

DESCENDING
#include<iostream>
#include<conio.h>
#include<windows.h>
using namespace std;
main()
{
int angka[20],a,b,c;
char huruf[20],kedua[20][20],pilihan;
cout<<"==============================\n";
cout<<"\t PROGRAM SORTING \n";
cout<<"==============================\n\n";
cout<<"Masukan jumlah maksimal: ";cin>>a;
for(b=0;b<a;b++)
{
cout<<"Masukan huruf ke "<<b+1<<" : ";cin>>huruf[b];
cout<<"Masukan angka ke "<<b+1<<" : ";cin>>angka[b];
cout<<"\n";
}
system("cls");
cout<<"\n tampilkan sebelum sorting: \n";
for(b=0;b<a;b++)
{
cout<<huruf[b]<<" ";
}
cout<<"\n";
for(b=0;b<a;b++)
{
cout<<angka[b]<<" ";
}
for(b=0;b<a-1;b++){
for(c=0;c<a-1-b;c++){
if(huruf[c]>huruf[c+1])
{
int tmp,tmp1;
tmp=huruf[c];
tmp1=angka[c];
huruf[c]=huruf[c+1];
huruf[c+1]=tmp;
angka[c]=angka[c+1];
angka[c+1]=tmp1;
}
}
}
cout<<"\n\nsetelah di sorting berdasarkan huruf\n";
cout<<"\n";
for(b=0;b<a;b++){
cout<<huruf[b]<<" ";
}
cout<<"\n";
for(b=0;b<a;b++){
cout<<angka[b]<<" ";
}
}

Output Program :
-

Desceding

Ascending

Algoritma :
-

Ascending
1. Mulai
2. Membaca file header.
3. Membaca fungsi utama.
4. Entrain data sebelum sorting.
5. Cetak hasil.
6. Membaca perulangan for untuk proses sorting.
7. Membaca fungsi tmp, tmp1.
8. Entrain data setelah sorting.
9. Membaca perulangan untuk proses hasil sortingan.
10. Cetak hasil.
11. Selesai.
Descending
1. Mulai.
2. Membaca file header.
3. Membaca fungsi typedf struct.
4. Membaca array data data.
5. Membaca fungsi main
6. Membaca perulangan for untuk fungsi sorting.
7. Entrain huruf dan angka yang akan di sorting.
8. Cetak hasil.
9. Membaca fungsi temp.
10. Membaca perulangan for untuk proses temp.

11. Entrain data setelah disorting.

12. Membaca perulangan for untuk proses hasil sortingan.
13. Cetak hasil.
14. Selesai.
Deskripsi:
-

Ascending :
Untuk program diatas yang menggunakan jenis ascending, menggunakan fungsi main,
yang didalamnya terdapat berbagai macam fungsi lainnya. Menggunaka perulangan
for untuk proses sorting dan proses hasil sorting. Menggunakan fungsi tmp, tmp1 yang

fungsinya untuk penyimpanan data bahkan hasil sorting.

Descending:
Untuk program diatas yang menggunakan jenis descending menggunakan fungsi
typdef struct untuk peletakan tipe data char dan int yang dijadikan dalam satu fungsi.
Menggunakan array data untuk syarat metode sorting yang digunakan. Menggunakan
fungsi min. menggunakan perulangan for untuk fungsi sorting. Menggunakan fungsi
temp untuk penyimpanan sementara. Menggunakan perulang for untuk proses temp.
menggunakan perulanag for untuk proses hasil sorting.

KESIMPULAN
1.

Algoritma pengurutan adalah algoritma yang meletakkan elemen-elemen suatu

kumpulan data dalam urutan tertentu. Atau proses pengurutan data yg sebelumnya
disusun secara acak sehingga menjadi tersusun secara teratur menurut suatu aturan

2.
3.

tertentu.
Ada 2 jenis sorting : Ascending (naik) & Descending (turun).
Exchange Sort melakukan pembandingan antar data, dan melakukan pertukaran

4.

apabila urutan yang didapat belum sesuai.

Prinsip dasar Insertion adalah secara berulang-ulang menyisipkan / memasukan

setiap elemen kedalam posisinya / tempatnya yg benar.

5.
Quick sort banyak digunakan utk proses sorting,karena:
merupakan proses sorting yang umum digunakan.
mudah untuk diimplementasikan.
Prosesnya sangat cepat.
6.
Untuk pemrograman konvensional maka pemeriksaan-pemeriksaan pasangan
tersebut harus dilakukan satu demi satu, misalnya oleh bubble-sort dilakukan dari
7.

kanan ke kiri serta di dalam sejumlah iterasi.

Selection Sort , mencari elemen yang tepat untuk diletakkan di posisi yang telah
diketahui, dan meletakkannya di posisi tersebut setelah data tersebut ditemukan.

DAFTAR PUSTAKA
1. Tim Asisten Dosen. 2014. Modul 2 Sorting (Pengurutan). Malang: Unversitas Negeri

Malang.