Laporan Praktikum Modul 2 ASD

LAPORAN PRAKTIKUM II
SORTING

Untuk Memenuhi Matakuliah Praktikum Algoritma dan Struktur Data
Yang Dibimbing oleh Ibu Triyanna

Disusun Oleh :
Richi Tirta Harry Sukamto
150533601193

S1 PTI OFF D 2015

UNIVERSITAS NEGERI MALANG
FAKULTAS TEKNIK
JURUSAN TEKNIK ELEKTRO
PRODI S1 PENDIDIKAN TEKNIK INFORMATIKA
MARET 2016

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)

Berikut adalah penjelasan masing masing sorting :

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.

Pseudo Code Bubble Sort :
procedure bubbleSort( A : list of sortable items )
n = length(A)
repeat
swapped = false
for i = 1 to n-1 inclusive do
/* if this pair is out of order */
if A[i-1] > A[i] then
/* swap them and remember something changed */
swap( A[i-1], A[i] )
swapped = true
end if
end for
until not swapped
end procedure

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 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.
Pseudo Code Merge Sort :
# Original data is on the input tape; the other tapes are blank
function merge_sort(input_tape, output_tape, scratch_tape_C, scratch_tape_D)
while any records remain on the input_tape
while any records remain on the input_tape
merge( input_tape, output_tape, scratch_tape_C)
merge( input_tape, output_tape, scratch_tape_D)
while any records remain on C or D
merge( scratch_tape_C, scratch_tape_D, output_tape)
merge( scratch_tape_C, scratch_tape_D, input_tape)

# take the next sorted chunk from the input tapes, and merge into the single given output_tape.
# tapes are scanned linearly.
# tape[next] gives the record currently under the read head of that tape.
# tape[current] gives the record previously under the read head of that tape.
# (Generally both tape[current] and tape[previous] are buffered in RAM ...)
function merge(left[], right[], output_tape[])
do
if left[current] right[current]
append left[current] to output_tape
read next record from left tape
else
append right[current] to output_tape
read next record from right tape
while left[current] < left[next] and right[current] < right[next]
if left[current] < left[next]
append current_left_record to output_tape
if right[current] < right[next]
append current_right_record to output_tape
return

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 :

Latihan Praktikum 1
Algoritma dan Struktur Data

Nama Program : Program Sorting Data denga Metode buble sort.
Bahasa Pemrogramam : C++
Compiler : MinGW Developer Studio
Script program :
/*Bubble Sorting*/
#include
#include

using namespace std;
int main()
{
int NumList[10]={12,29,56,4,31,9,17,19,48,3};
int temp;
cout<<"Data Angka Sebelum diurutkan : \n";
for(int d=0; d<10; d++)
{
cout< }
cout<<"\n\n";
for(int a=0; a<10; a++)
for(int b=0; b<10; b++)
if (NumList [b]>=NumList[b+1])
{
temp=NumList[b];
NumList[b]=NumList[b+1];
NumList[b+1]=temp;
}
cout<<"data setelah diurutkan : \n";
for (int c=0; c<10; c++)
cout< cout< }

Output Program :

Algoritma :
Mulai.
Membaca file header.
Membaca fungsi utama.
Membaca isi array numlist [8].
Membaca fungsi temp.
Cetak hasil.
Tampilan data sebelum diurutkan.
Membaca fungsi perulangan.
Inisialisasi penggantian nilai
temp=NumList[ii];
NumList[ii]=NumList[ii+1];
NumList[ii+1]=temp;
Cetak hasil.
Tampilan data setelah diurutkan.
Membaca fungsi perulangan.
Cetak hasil.
Selesai.

Penjelasan Program:

Program di atas digunakan untuk menampilkan kalimat. Pada program di atas menggunakan header file #include yang berfungsi untuk memanggil fungsi dari cin dan cout 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 Developer Studio. 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 10 data maka akan terjadi 9 langkah. Langkah pertama adalah menentukan 12 dan 29 apakah sudah benar posisinya, karena ascending maka A[i]>A[i+1] geser kanan. Maka 12 dan 29 berpindah logikanya 12>29 tidak ada 12<29. Kemudian seterusnya sampai 9 kali tahap hingga menghasilkan output terurut secara urut dari utrutan terkecil menuju urutan terbesar.

Latihan Praktikum 2

Nama Program : Program sorting data dengan selection sort.
Script program :
/*Selection Sorting*/
#include
#include

void SelectionSort(int Array [], const int Size)
{
int i,j,small,temp;
for (i=0;i {
small=i;
for (j=0;j {
if (Array[j]>Array[small])//Penmbanding
{
small=j;
temp=Array[i];
Array[i]=Array[small];
Array[small]=temp;
}
}
}
}
int main()
{
int NumList[10]={12,29,56,4,31,9,17,19,48,3};
int temp;
cout<<"Data Angka Sebelum diurutkan : \n";
for(int d=0; d<10; d++)
{
cout< }
cout<<"\n\n";
SelectionSort(NumList,10);
cout<<"Data Setelah Diurutkan\n";
for (int a=0; a<10; a++)
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.

Penjelasan Program :
Program di atas digunakan untuk menampilkan kalimat. Pada program di atas menggunakan header file #include yang berfungsi untuk memanggil fungsi dari cin dan cout, int main () deklarasi fungsi main berjenis data integer, { (berfungsi untuk membuka script pemrograman Program diatas menggunakan metode selection sort untuk mengurutkan beberapa bilangan. Penulisan file header dalam MinGW Developer Studio perlu diperhatikan karena tidak sama dengan penulisan script pada MinGw atau visual c++. Dalam MinGW Developer Studio 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 : 12,29,56,4,31,9,17,19,48,3. Pembandingnya terdiri dari 5<34 maka posisinya 0 karena suda benar peletakkan, karena pembanding ini salah maka harus dilakukan swap"penukaran" sebanyak 7x. begitu seterusnya sehingga bilangan menjadi urut, karena ada 10 data maka akan terjadi tahapan sebanyak 9 kali.

Latihan Praktikum 3

Nama Program : Program shell sort.
Script program :
/*Shell Sorting*/
#include

int main()
{
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;

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;
}
}
}
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.

Program di atas digunakan untuk menampilkan kalimat. Pada program di atas menggunakan header file #include yang berfungsi untuk memanggil fungsi dari cin dan cout 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.

Latihan Praktikum 4

Nama Program : Program Quick sort.
Compiler : MinGW Developer Studio.
Script program :
#include
#include

void quicksort (int[],int);
void q_sort (int[],int,int);

int main()
{
int numlist[10]={12,29,56,4,31,9,17,19,48,3};
int temp;
cout<<"Data sebelum diurutkan :\n";
for (int d=0;d<10;d++)
{
cout< }
cout<<"\n\n";
quicksort (numlist,10);
cout<<"Data setelah diurutkan :\n";
for (int iii=0;iii<10;iii++)
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);
}
}
Script program yang benar:
/*Quick Sort*/
#include
#include
#include

void quickSort(int[], int);
void q_sort(int[], int, int);

int main()
{
int NumList[10]={12,29,56,4,31,9,17,19,48,3};
int temp;
cout<<"Data Sebelum Diurutkan: \n";
for(int d=0; d<10; d++)
{
cout< }
cout<<"\n\n";
quickSort (NumList,10);
cout<<"Data Setelah Diurutkan: \n";
for (int iii=0; iii<10; iii++)
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 [10], temp.
Membaca perulangan.
Pemanggilan fungsi quicksort.
Cetak hasil.
Membaca fungsi quicksort (numlist,10).
Cetak hasil.
Selesai.

Program di atas digunakan untuk menampilkan kalimat. Pada program di atas menggunakan header file #include yang berfungsi untuk memanggil fungsi dari cin dan cout 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.

Latihan Praktikum 5

Nama Program : Program Radix sort.
Script program :
/*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)
{
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 }
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.
Program di atas digunakan untuk menampilkan kalimat. Pada program di atas menggunakan header file #include yang berfungsi untuk memanggil fungsi dari cin dan cout 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 sorting untuk abjad.
Script program :
//ASCENDING METHOD
#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 METHOD
#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] {
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 :
Descending

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.

Penjelasan Program:
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. 2015. Modul 2 Sorting (Pengurutan). Malang: Unversitas Negeri Malang.
Wikipedia Online..Bubble Sort.e https://en.wikipedia.org/wiki/Bubble_sort
Wikipedia Online. Merge Sort. https://id.wikipedia.org/wiki/Urut_gabung
Algoritma. Merge Sort. http://www.sorting-algorithms.com/merge-sort

Laporan Praktikum Modul 2 ASD

Recommend Documents