laporan sorting, script di dalamnya juga searching kok :)

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 PTI'13 OFF B
UNIVERSITAS NEGERI MALANG
FAKULTAS TEKNIK
JURUSAN TEKNIK ELEKTRO
PRODI PENDIDIKAN TEKNIK INFORMATIKA
Februari 2014

SORTING
Tujuan instruksional umum :
Mahasiswa mampu melakukan perancangan aplikasi menggunakan Struktur Sorting
(pengurutan).
Mahasiswa mampu melakukan analisis pada algoritma Sorting yang dibuat.
Mahasiswa mampu mengimplementasikan algoritma Sorting pada sebuah aplikasi secara tepat dan efisien.
Tujuan instruksional khusus:
Mahasiswa mampu menjelaskan mengenai algoritma Sorting.
Mahasiswa mampu membuat dan mendeklarasikan struktur algoritma Sorting.
Mahasiswa mampu menerapkan dan mengimplementasikan algoritma Sorting.
Tujuan
Mampu melakukkan perancangan aplikasi menggunakan Strucktur Sorting (Pengurutan).
Mampu melakukkan analisis pada algoritma Sorting yang dibuat
Mampu mengimplementasikan algoritma Sorting pada sebuah aplikasi secara tepat dan efesien.

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)
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:
Simpan nilai Ti kedalam variabel sementara, dengan i = 1.
Bandingkan nilainya dengan elemen sebelumnya.
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).
Lakukan terus poin ke-tiga, sampai Ti-1 Ti.
Jika Ti-1 Ti terpenuhi, tindih nilai di Ti dengan variabel sementara yang disimpan sebelumnya.
Ulangi langkah dari poin 1 di atas dengan i di-increment (ditambah satu).

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:
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.
Tukar nilai tersebut dengan nilai pada posisi pertama di bagian struktur data yang belum diurutkan.
Ulangi langkah di atas untuk bagian struktur data yang tersisa.

Bubble Sort

Bubble Sort merupakan cara pengurutan yangsederhana. Konsep dari ide dasarnya adalah seperti"gelembung 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 perbandingan nilai elemen untukmengoperasikan elemennya.

Algoritma Bubble Sort

Algoritma bubble sort dapat diringkas sebagaiberikut, jika N adalah panjang elemen struktur data, dengan elemen-elemennya adalah T1, T2, T3, …, TN-1,TN, maka:
Lakukan traversal untuk membandingkan
dua elemen berdekatan. Traversal ini
dilakukan dari belakang.
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.
Ulangi langkah di atas untuk struktur data
yang tersisa.
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:
Jika struktur data terdiri dari 1 atau 0 elemen yang harus diurutkan, kembalikan struktur data itu apa adanya.
Ambil sebuah elemen yang akan digunakansebagai pivot point (poin poros). (Biasanyaelemen yang paling kiri.)
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.
Ulangi algoritma secara rekursif terhadapkedua paruh struktur data.
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,
Sebuah list yang kecil membutuhkan langkahyang lebih sedikit untuk pengurutan daripadasebuah list yang besar.
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:
Bagi list yang tak terurut menjadi dua samapanjang atau salah satunya lebih panjang satu elemen.
Bagi masing-masing dari 2 sub-list secara rekursif sampai didapatkan list dengan ukuran 1.
Gabung 2 sublist kembali menjadi satu list terurut.
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 :

Percobaan 1
Algoritma dan Struktur Data
Nama Program : Program Sorting Data denga Metode buble sort.
Bahasa Pemrogramam : C++
Compiler : Code Blocks
Script program :
#include

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< )
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)"< }
Script yang benar :
/*program sorting data dengan metode bubble sort */
#include
#include
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< }
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;
}
for(int iii=0; iii<8; iii++)
cout< }

Output Program :

Algoritma :
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;
Cetak hasil.
Tampilan data setelah diurutkan.
Membaca fungsi perulangan.
Cetak hasil.
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 . 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

Percobaan 2
Nama Program : Program sorting data dengan selection sort.
Script program :
#include
#include

void SelectionSort (int Array [], const int Size)
{
int i,j,kecil,temp;
for (i=0; i {
kecil=i;
for(j=1; 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< }
cout<<"\n\n";
SelectionSort (NumList, 8);

for (int iii=0; iii<8; iii++)
cout<<"setw(3)"< }
Script yang benar :
/*Selection Sort*/
#include
#include

void SelectionSort (int array [], const int size)
{
int i,j,kecil,temp;
for (i=0; i {
kecil=i;
for(j=i+1; 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;
for(int d=0; d<8;d++)
{
cout< }
cout<<"\n\n";
SelectionSort (NumList, 8);

cout< }
Output Program:

Algoritma :
Mulai.
Membaca fungsi,int, kecil, temp.
Membaca perulangan beserta fungsi kecil dan temp.
Membaca fungsi utama, fungsi numlist dan temp.
Membaca perulangan.
Cetak hasil.
Membaca fungsi metode selection sorting.
Membaca perulangan.
Cetka hasil.
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 swap"penukaran" sebanyak 7x. begitu seterusnya sehingga bilangan menjadi urut, karena ada 8 data maka akan terjadi tahapan sebanyak 7 kali.

Percobaan 3
Nama Program : Program shell sort.
Script program :
/*shell sort*/
#include

int main(void)
{
int array[5]; // An array of integer
int length = 5; // Length of the array
int i, j, d;
int tmp, flag;

//some input
for(i=0; 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< }
}
Output Program :

Algoritma :
Mulai
Membaca fungsi main.
Membaca fungsi array yang didalamnya terdpat fungsi panjang.
Membaca perulangan.
Membaca percabangan.
Membaca perulangan.
Pemanggilan array[i].
Cetak hasil.
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.

Percobaan 4
Nama Program : Program Quick sort.
Compiler : Code Blocks.
Script program :
#include
#include
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;
for(int d=0; d<8; d++)
{
cout< }
cout<<"\n\n";
quickSort (NumList,8);
cout<<"Data Setelah Diurutkan: \n";
cout<<"setw(3)"< }

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 {
while((numbers[right]>=pivot "" (left right--;
if(left != right)
{
numbers[left]=numbers[right];
left++;
}
while ((numbers[left] <=pivot) && (left left++;
if (left != right)
{
number[right]=numbers[left];
right--;
}
}
numbers[left]=pivot;
pivot=left;
left=l_hold;
right=r_hold;
if (left q_sort(numbers, left, pivot-1);
if (right>pivot)
q_sort(numbers, pivot+1, right);
}
Script program yang benar:
/*Quick Sort*/
#include
#include
#include

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;
for(int d=0; d<8; d++)
{
cout< }
cout<<"\n\n";
quickSort (NumList,8);
cout<<"Data Setelah Diurutkan: \n";
cout< }

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 {
while((numbers[right]>=pivot) && (left right--;
if(left != right)
{
numbers[left]=numbers[right];
left++;
}
while ((numbers[left] <=pivot) && (left left++;
if (left != right)
{
numbers[right]=numbers[left];
right--;
}
}
numbers[left]=pivot;
pivot=left;
left=l_hold;
right=r_hold;
if (left q_sort(numbers, left, pivot-1);
if (right>pivot)
q_sort(numbers, pivot+1, right);
}
Output Program :

Algoritma :
Mulai.
Membaca fungsi metode quick sort.
Membaca fungsi numlist [8], temp.
Membaca perulangan.
Pemanggilan fungsi quicksort.
Cetak hasil.
Membaca fungsi quicksort (numlist,8).
Cetak hasil.
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.

Percobaan 5
Nama Program : Program Radix sort.
Script program :
#include
#include
#include

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>(byte*8))&0xff]++;

index[0]=0;
for(i=1; i<256; i++) index[i]=index[i-1]+count[i-1];
for(i=0; i>(byte*8))&0xff]++]=
source[i];
}

void radixsort (long *source, long *temp, long N)
{
radix (0, N, source, temp);
radix (1, N, temp, source);
}

void make_random (long *data, long N)
{
for(int i=0; i }
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< }
Script program yang benar:
/*Radix Sort*/
#include
#include
#include

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>(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>(byte*8))&0xff]++]=
source[i];
}

void radixsort (long *source, long *temp, long N)
{
}

void make_random (long *data, long N)
{
for(int i=0; i }
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< }
Output Program :

Algoritma :
Mulai
Membaca fungsi utama radix.
Membaca rumus radix menggunakana memset.
Membaca perulangan.
Membaca fungsi radixsort.
Membaca fungsi make_random.
Pemanggilan fungsi make_random,radixsort.
Membaca perulangan.
Cetak hasil.
Selesai.
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.

Tugas Rumah 1
Nama Program : Program Menu Sorting (mengurutkan) Bilangan.
Script program :
#include
#include
#include
#include

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 {for(int j=n-1;j>=i;j--)
{if(data[j] tukar(j,j-1);
}
}
}
else if (p=='T'""p=='t') //Descending
{
for(int i=1;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"< }
void exchange_sort()
{
A_D();
if (p=='N'""p=='n')
{
for (int i=0; i {
for(int j = (i+1); j {
if (data [i] > data[j])
tukar(i,j);
}
}
}
else if (p=='T'""p=='t')
{
for (int i=0; i {
for(int j = (i+1); j {
if (data [i] < data[j])
tukar(i,j);

}
}
}
cout<<"Exchange Sort Selesai, Silahkan Lihat Data Anda ke Menu No.8"< }
void selection_sort()
{
int pos,i,j;
A_D();

if (p=='N'""p=='n')
{
for(i=0;i {
pos = i;
for(j = i+1;j {
if(data[j] < data[pos])
pos = j;
}
if(pos != i) tukar(pos,i);
}
}
{
for(i=0;i {
pos = i;
for(j = i+1;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"< }

void insertion_sort()
{
int temp,i,j;
A_D();

if (p=='N'""p=='n')
{
for(i=1;i {
temp = data[i];
j = i -1;
while(data[j]>temp && j>=0)
{
data[j+1] = data[j];
j--;
}
data[j+1] = temp;
}
}
{
for(i=1;i {
temp = data[i];
j = i -1;
while(data[j]=0)
{
j--;
}
data[j+1] = temp;
}
}
cout<<"Insertion Sort Selesai, Silahkan Lihat Data Anda ke Menu No.8"< }
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;
}
}
}
}
}
{
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 "< }
void Input_Data()
{
printf("\n Masukkan jumlah data yang dibutuhkan : ");
scanf("%d",&n);
for(int i=0;i {
printf("Masukkan data ke-%d : ",(i+1));
scanf("%d",&data[i]);
data2[i] = data[i];
}
}
void AcakLagi()
{
for(int i=0;i {
data[i] = data2[i];
}
printf("\n Data sudah teracak\n");
}

void Tampil()
{
printf("\n Data = ");
for(int i=0;i {
printf("%d ",data[i]);
}
printf("\n");
}

main()
{
system("cls");
int pil;
do
{
system("cls");
cout<<" >>>>>>>>>>>>>>><<<<<<<<<<<<< "< cout<<" " Program Menu Sorting Data ""< cout<<" >>>>>>>>>>>>>>><<<<<<<<<<<<< "< cout<<" 1. Input Data"< cout<<" 2. Bubble Sort"< cout<<" 3. Exchange Sort"< cout<<" 4. Insertion Sort"< cout<<" 5. Selection Sort"< cout<<" 6. Quick Sort"< cout<<" 7. Shell Sort"< cout<<" 8. Tampilkan Hasil Data"< cout<<" 9. Acak"< cout<<" 10.Exit"< cout<<"**********************************************"< 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 :
Mulai
Membaca file header
Membaca fungsi integer array , integer n , char p.
Membaca fungsi Ascending-descending.
Membaca fungsi tukar.
Membaca fungsi bubble sort,exchange sort, selection sort, insertion sort, quick sort, shell sort, input data, acak lagi, tampil.
Tampilan menu program sorting.
Membaca percabangan menu.
Pemanggilan tiap tiap fungsi dalam percabangan.
Cetak hasil.
Membaca fungsi exit.
Cetak hasil.
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.

Tugas Rumah 2
Nama Program : Program Menu Sorting Bilangan secara Random
Script program :
#include
#include
#include
#include
#include
#define MAX 1


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 {
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<<" "< cout<<"\tMasukkan Jumlah Data : ";
cin>>nx;
cout< }
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 {
data[i]= rand()%n; /*rand berfungsi untuk mengembalikan sebuah nilai integer*/
cout< }
cout<<"\n\n\n";
{
for (hitung=0;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"< 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 for (int ii=0; 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 cout< }
if ((choose=='d')""(choose=='D'))
{

cout<<"\nMenjalankan metode Bubble Sort dengan pengurutan Descending";
for(int iii=n-1; iii>=0; iii--)
cout< }
cout<<"\n";
}

int SelectionSort()
{
cout<<"----------------------------------------------------\n";
int kecil;
for (int i=0;i {
kecil=i;
for (int j=kecil+1; j {
if (data1[kecil]>data1[j])
{kecil=j;}
}
temp=data1[i];
data1[i]=data1[kecil];
data1[kecil]=temp;
}
{
cout<<"\nMenjalankan metode Selection Sort dengan pengurutan Ascending";
{
cout<<"\nMenjalankan metode Selection Sort dengan pengurutan Descending";
cout< }

cout<<"\n";
}

int shell()
{
cout<<"----------------------------------------------------\n";
int gap=n/2;
do
{
int swap;
do

{
swap=0;
for(int i=0;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);

{
cout<<"\nMenjalankan metode Shell Sort dengan pengurutan Ascending";
for(i=0;i cout< }
{
cout<<"\nMenjalankan metode Shell Sort dengan pengurutan Descending";
for(i=n-1;i>=0;i--)
cout<

}
cout< }
int insertion()
{
cout<<"----------------------------------------------------\n";
int temp,i,j;
for(i=1;i {
temp = data[i];
j = i -1;
while(data[j]>temp && j>=0)
{
j--;
}
data[j+1] = temp;
}
{
cout<<"\nMenjalankan metode Insertion Sort dengan pengurutan Ascending";
{
cout<<"\nMenjalankan metode Insertion Sort dengan pengurutan Descending";
cout< }
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 {
for (int j=(i+1); j {
if (data [i] > data [j])
tukar (i, j) ;
}
}
{
cout<<"\nMenjalankan metode Exchange Sort dengan pengurutan Ascending";
{
cout<<"\nMenjalankan metode Exchange Sort dengan pengurutan Descending";
cout< }
cout<<"\n";
}
Output Program :

Algoritma :
Mulai
Membaca fungsi int metode sorting.
Membaca fungsi int data, temp, cek, char ulang-choose, char array.
Masukkan jumlah data.
Membaca perulangan dari fungsi cek.
Membaca fungsi int i.
Membaca perulangan for pada pilihan menu program.
Membaca pemanggilan fungsi choose.
Membaca percabangan switch case.
Membaca pemanggilan fungsi metode sorting.
Membaca fungsi default, jika salah maka akan muncul pemanggilan fungsi repeat untuk mengulang opsi menu.
Cetak hasil.
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.

Tugas Rumah 3
Nama Program : Program sorting untuk abjad.
Script program :
ASCENDING
#include
#include
#include

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 {
cout<<"Masukan huruf ke "<>huruf[b];
cout<<"Masukan angka ke "<>angka[b];
cout<<"\n";
}
system("cls");
cout<<"\n tampilkan sebelum sorting: \n";
for(b=0;b {
cout< }
cout<<"\n";
for(b=0;b {
cout< }
for(b=0;b for(c=0;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 cout< }
cout<<"\n";
for(b=0;b cout< }
}
DESCENDING
#include
#include
#include

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 {
cout<<"Masukan huruf ke "<>huruf[b];
cout<<"Masukan angka ke "<>angka[b];
cout<<"\n";
}
system("cls");
cout<<"\n tampilkan sebelum sorting: \n";
for(b=0;b {
cout< }
cout<<"\n";
for(b=0;b {
cout< }
for(b=0;b for(c=0;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 cout< }
cout<<"\n";
for(b=0;b cout< }
}
Output Program :
Desceding

Ascending

Algoritma :
Ascending
Mulai
Entrain data sebelum sorting.
Cetak hasil.
Membaca perulangan for untuk proses sorting.
Membaca fungsi tmp, tmp1.
Entrain data setelah sorting.
Membaca perulangan untuk proses hasil sortingan.
Cetak hasil.
Selesai.
Descending
Mulai.
Membaca fungsi typedf struct.
Membaca array data data.
Membaca fungsi main
Membaca perulangan for untuk fungsi sorting.
Entrain huruf dan angka yang akan di sorting.
Cetak hasil.
Membaca perulangan for untuk proses temp.
Entrain data setelah disorting.
Membaca perulangan for untuk proses hasil sortingan.
Cetak hasil.
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
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 tertentu.
Ada 2 jenis sorting : Ascending (naik) & Descending (turun).
Exchange Sort melakukan pembandingan antar data, dan melakukan pertukaran apabila urutan yang didapat belum sesuai.
Prinsip dasar Insertion adalah secara berulang-ulang menyisipkan / memasukan setiap elemen kedalam posisinya / tempatnya yg benar.
Quick sort banyak digunakan utk proses sorting,karena:
merupakan proses sorting yang umum digunakan.
mudah untuk diimplementasikan.
Prosesnya sangat cepat.
Untuk pemrograman konvensional maka pemeriksaan-pemeriksaan pasangan tersebut harus dilakukan satu demi satu, misalnya oleh bubble-sort dilakukan dari 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
Tim Asisten Dosen. 2014. Modul 2 Sorting (Pengurutan). Malang: Unversitas Negeri Malang.

laporan sorting, script di dalamnya juga searching kok :)

Recommend Documents