TUGAS UJI KUALITAS PERANGKAT LUNAK

IMPLEMENTASI BLACK BOX TESTING

SISTEM INFORMASI PULSA

DISUSUN OLEH :
UMAR FADHLURRACHMAN
H1D015056

KEMENTERIAN RISET, TEKNOLOGI DAN PENDIDIKAN TINGGI

UNIVERSITAS JENDERAL SOEDIRMAN
FAKULTAS TEKNIK
JURUSAN TEKNIK INFORMATIKA
PURWOKERTO
2017
Source Code :
#include <stdio.h>
#include <process.h>
#define max 100

int data[max];
int n;
void awalan();
void bubblesort(int a[], int size);
void selectionsort();
void insertsort();

int main()
{
int i;
int pilihan;

awalan();
printf("\nMasukkan Jumlah Angka yang Ingin Diurutkan : ");
scanf("%d", &n);

for(i=0;i<n;i++) {
printf("Angka ke-%d : ", i+1);
scanf("%d", &data[i]);
}

system("cls");
awalan();

printf("\nAnda Telah Memilih Angka : \n");

for(i=0;i<n;i++)
printf("[%d]", data[i]);

printf("\nPilih Metode Sorting :");

printf("\n1. Bubble Sort");
printf("\n2. Selection Sort");
printf("\n3. Insertion Sort");
printf("\nPilihan Anda : ");
scanf("%d", &pilihan);

switch(pilihan) {
case 1 : {
printf("\nSorting Secara Bubble Sort");
printf("\n==========================\n");
bubblesort(data, n);
printf("Data Setelah Diurutkan : \n");
for(i=0;i<n;i++)
printf("%d ", data[i]);
break;
}
case 2 : {
printf("\nSorting Secara Selection Sort");
printf("\n============================\n");
selectionsort();
printf("Data Setelah Diurutkan : \n");
for(i=0;i<n;i++)
 printf("%d ", data[i]);
break;
}
case 3 : {
printf("\nSorting Secara Insertion Sort");
printf("\n============================\n");
insertsort();
printf("Data Setelah Diurutkan : \n");
for(i=0;i<n;i++)
printf("%d ", data[i]);
break;
}
default : {
printf("Metode Sorting Tidak Tersedia :)");
}
}
}
void awalan() {
printf("----------------------------------------------");
printf("\n----------------METODE SORTING----------------");
printf("\n----------------------------------------------");
}
void bubblesort(int a[], int size) {
int switched = 1;
int hold = 0;
int i = 0;
int j = 0;

size -= 1;

for (i=0;i<size && switched; i++) {

switched = 0;
for(j=0;j<size-i;j++)
if(a[j] > a[j+1]) {
switched = 1;
hold = a[j];
a[j] = a[j+1];
a[j+1] = hold;
}
}
}
void selectionsort()
{
int i, j, swap, temp;
for(i=0; i<n; i++)
{
temp = i;
for(j=i+1;j<n; j++) {
if(data[temp] > data[j])
temp = j;
}
if(temp != i)
{
swap = data[i];
data[i]= data[temp];
data[temp]=swap;
}
}
}
void insertsort()
{
int i, j, temp;
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;
}
}

1. Insertion sort
a. Dasar Teori
Insertion Sort merupakan algoritma yang efisien untuk mengurutkan angka
yang mempunyai jumlah elemen sedikit.
Dimana : - Input : deretan angka sejumlah n buah
- Output : permutasi (pengurutan) sejumlah n angka dari input
yang sudah
terurut secara ascending maupun descending.
Metode penyisipan (Insertion sort) bertujuan untuk menjadikan bagian sisi kiri
array terurutkan sampai dengan seluruh array berhasil diurutkan.
Metode ini mengurutkan bilangan-bilangan yang telah dibaca; dan berikutnya
secara
berulang akan menyisipkan bilangan-bilangan dalam array yang belum terbaca
ke sisi kiri array yang telah terurut.

b. Source code
c. Screenshot

d. Penjelasan
Prosedur ini akan berjalan ketika di panggil oleh fungsi main yang
menerima nilai dari array a dan variable total yang bertipe int dari main atau
fungsi utama.

Pada insertsort ini memerlukan 3 variable lagi yaitu i, j, dan temp yang bertipe
integer

Program dimulai dengan perulangan for yang memberi nilai pada variable i yaitu
1 dan kondisi nilai i tidak boleh lebih dari variable total. Incerement 1 atau nilai
variable i akan bertambah 1 ketika for akan kembali melakukan perulangan.

Kemudian variable j diberi nilai yang sama dengan i

 Didalam perulangan for terdapat perulangan lagi yaitu while yang memiliki
kondisi jika j bernilai lebih 0 dan jika nilai pada array a [j} lebih besar sama
dengan array a[j-1] benar, maka akan masuk pada tahap perhitungan.
Pertama variable temp diisi nilai sama dengan pada array a[j], kemudian nilai a
[j] diubah menjadi sama dengan a[j-1] kemudian nilai pada a[j-1] disimpan pada
variable temp
Intinya pada insertsort ini merubah nilai pada suatu array a [j-1] jika nilai array
tersebut lebih besar dari nilai array setelahnya maka posisinya akan ditukar
sehingga nilai yang tadinya milik a[j-1] sekarang letaknya di a[j]. Hal ini juga
menandakan sorting dari kecil ke besar
Setelah melakukan perubahan nilai pada variable maka akan terjadi perulangan
while dengan perbedaan pada decrement j atau setiap kali perulangan nilai j akan
berkurang 1
Ketika program while kondisinya false maka akan kembali ke perulangan for
dengan terjadinya incerement pada variable i. Ketika variable i kondisinya salah
maka perulangan while didalam perulangan for ini berakhir.

Ketika perulangan for kondisinya salah maka akan masuk pada tahap berikutnya
yaitu memanggil prosedur cetak diisi dengan variable a dan total yang sudah
dapat diperhitungan insertsort ini.
Memanggil prosedur cetak maka mengakhiri prosedur insertsort ini.

e. Ilustrasi

 Bagian biru/abu-abu (dua bilangan pertama) sekarang dalam keadaan terurut

secara relatif.

Berikutnya, kita perlu menyisipkan bilangan ketiga (4) ke dalam bagian biru/abu-
abu sehingga setelah penyisipan tersebut, bagian biru/abu-abu tetap dalam
 keadaan terurut secara relatif;
CARANYA :
pertama : Ambil bilangan ketiga (4).

 Kedua : Geser bilangan kedua (10) shg ada ruang untuk disisipi.

 Ketiga : Sisipkan bilangan 4 ke posisi yang tepat

 Sekarang, tiga bilangan pertama sudah terurut secara relatif dan kita sisipkan
bilangan keempat kepada tiga bilangan pertama tsb. Setelah penyisipan,
empat bilangan pertama haruslah dalam keadaan terurut secara relatif.

 Ulangi proses tsb sampai bilangan terakhir disisipkan

Proses Sorting Selesai.

2. Bubble Sort
a. Dasar Teori
 Bubble sort adalah salah satu jenis metode pengurutan data (sorting). Bubbl
sort adalah metode sorting termudah. Diberikan nama “bubble” karena konsep
dari algoritmanya diibaratkan seperti gelembung air untuk elemen array yang
seharusnya pada posisi awal. Bubble sort mengurut data dengan cara
membandingkan elemen sekarang dengan elemen berikutnya. Dimana cara
kerjanya adalah dengan berulang-ulang melakukan proses looping ( perulangan)
terhadap elemen-elemen array yang belum diurutkan. Nilai dari masing-masing
elemen akan dibandingkan selama proses looping tersebut. Jika selama proses
looping tersebut ditemukan ada urutan yang tidak sesuai dengan permintaan,
maka akan dilakukan proses pemukaran (swap). Sesungguhnya secara tidak
langsung, algoritma dari program ini seolah-olah menggeser satu demi satu
elemen dari kanan ke kiri atau dari kiri ke kanan tergantung pada jenis
pengurutannya ascending atau descending.
Kelebihan bubble sort yakni metodenya yang paling simple, mudah dipahami
algoritmanya, jelas algoritmanya, serta cocok untuk pengurutan data yang telah
terurut.
Akan tetapi meskipun simpel metode bubble sort merupakan metode
pengurutan yang paling tidak efisien. kelemahan buble sort adalah pada saat
mengurutkan data yang sangat besar akan mengalami kelambatan luar biasa, atau
dengan kata lain kinerja memburuk cukup signifikan ketika data yang diolah jika
data cukup banyak. kelemahan lain adalah jumlah pengulangan akan tetap sama
jumlahnya walaupun data sesungguhnya sudah cukup terurut. hal ini disebabkan
setiap data dibandingkan dengan setiap data yang lain untuk menentukan
posisinya.
b. Source Code

void bubblesort(int a[], int total){

int temp, i, j;
for(i=0; i<total-1; i++){
for(j=0; j<(total-1)-i; j++){
if(a[j] > a[j+1]){
temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
}
}
}
cetak(a, total);
c. Screenshot

d. Penjelasan
Pada fungsi sorting diatas menggunakan metode pengurutan data secara
ascending dengan bubble sort, pada fungsi void bubblesort(int a[], int total) Dalam
fungsi bubble sort diatas juga terdapat variabel yang bersifat lokal yakni temp, i, j dan
variabel-variabel tersebut bersifat integer.
Jadi cara kerja fungsi bubble sort pada source code diatas yakni
membandingkan 2 elemen array menggunakan proses perulangan
for(i=0; i<total-1; i++){
for(j=0; j<(total-1)-i; j++){
Setelah dibandingkan kemudian program akan melakukan pengecekan kondisi
if(a[j] > a[j+1]){
Dari pembandingan kedua elemen tadi jika a[j] > a[j+1] atau elemen sebelah kanan
lebih besar dari elemen sebelah kiri maka program akan melakukan proses penukaran
(swap) dengan perintah berikut :
temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
 Jadi nilai dari a[j] akan disimpan dalam variabel temp, lalu posisi dari a[j] yang
sebelumnya akan diisikan oleh nilai dari a[j+1], Selanjutnya posisi dari a[j+1] tadi
diisikan dengan isi dari variabel temp yang mana telah berisi nilai dari a[j]. Dengan
demikian sekarang posisi dari elemen sebelah kiri sudah berpindah ke sebelah kanan
begitu juga berpindah ke sebelah kiri.
Namun jika kedua elemen tersebut tidak memenuhi kondisi (a[j] > a[j+1]) maka tidak
terjadi proses penukaran (swap) dan melanjutkan ke perulangan selanjutnya.
Proses pembandingan 2 elemen dimulai dari elemen yang paling awal sampai ke
elemen paling akhir.

e. Ilustrasi
Elemen array : 0 1 2 3 4

2 1 3 4 5

Variabel temp

1 3 1 2

2
Varabel temp

1 3 1 2

Variabel temp

1 2 3 4 5
 Variabel temp

1 2 3 4 5

Data setelah diurutkan :

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

Metode Shell Sort memiliki beberapa kelebihan serta kekurangan, antara lain:

Kelebihan:

1. Algoritma ini sangat rapat dan mudah untuk diimplementasikan.

2. Operasi pertukarannya hanya dilakukan sekali saja.
3. Waktu pengurutan dapat lebih ditekan.
4. Mudah menggabungkannya kembali.
5. Kompleksitas selection sort relatif lebih kecil.

Kekurangan :

1. Membutuhkan method tambahan.

2. Sulit untuk membagi masalah.

4. Source Code

void shellsort(int a[],int total){

int i, j, increment, temp;

for(increment = total/2;increment > 0; increment /= 2){

for(i = increment; i<total; i++){

temp = a[i];

for(j = i; j >= increment ;j-=increment){

5. Screenshot

6. Penjelasan:
Pada program ini kita tambahkan variabel i, j, increment, serta temp. Kemudian
dilakukan pengulangan yang syaratnya variabel increment merupakan hasil dari
pembagian variabel total yang berisikan banyak data keseluruhan dengan 2. Lalu pada
tiap pengulangan, isi dari variabel increment dibagi sama dengan 2. Lalu pada
pengulangan for tadi tedapat pengulangan kembali yang syaratnya i diberikan nilai
increment yang dimana nilai dari variabel i kurang dari variabel total dan pada setiap
pengulangannya nilai i ditambah 1. Di dalam pengulangan yang kedua, array data i
akan dipindahkan ke dalam variabel temp. Lalu di sana terdapat pengulangan kembali
dengan for yang memiliki syarat nilai dari variabel i dimasukkan pada variabel j yang
dimana variabel j harus lebih dari sama dengan nilai dari variabel increment. Dan
pada setiap pengulangan nilai dari variabel j akan dikurangi dengan nilai pada
variabel increment. Kemudian masuk pada percabangan if yang dimana jika nilai dari
variabel temp kurang dari array j dikurangi increment makan array yang berisi dengan
data j akan dimasukkan nilai pada array yang berisi data j dikurangi increment tadi.
7. Ilustrasi
 2 1 3 4 5

Data setalah diurutkan:

1 2 3 4 5