TUGAS MATA KULIAH

PEMROGRAMAN DAN STRUKTUR DATA

Dosen Pembimbing : I Ketut Resika Arthana, S.T,.M.Kom.

Oleh :

Ni Komang Winda Damayanti

1815091003

Sistem Informasi B

PROGRAM STUDI SISTEM INFORMASI

JURUSAN TEKNIK INFORMATIKA

FAKULTAS TEKNIK DAN KEJURUAN

UNIVERSITAS PENDIDIKAN GANESHA

TAHUN 2019
1. Jelaskan algoritma rekursif. buat contoh program rekursif untuk menghitung bilangan
faktorial dan fibonacci, berikan analisa.
Jawab :

Perulangan rekursif merupakan salah satu metode didalam pemrograman yang

mana dalam sebuah fungsi terdapat intruksi yang memanggil fungsi itu sendri, atau
lebih sering disebut memanggil dirinya sendiri. Algoritma ini memanggil dirinya
sendiri untuk melakukan proses berulang-ulang. Didalam Rekursif terdapat beberapa
prosedur dan fungsi yang harus dipanggil lewat pemanggilan prosedur atau fungsi itu
sendiri. Algoritma rekursif digunakan karena memiliki kelebihan yaitu penulisan pada
baris program akan akan menjadi lebih singkat. Sementara kekurangan dari algoritma
ini yaitu membutuhkan banyak memori, karena setiap kali program bagian dipanggil
oleh dirinya sendiri pastinya akan membutuhkan ruang memori tambahan. Suatu
algoritma rekrusif akan terjadi apabila dalam sebuah fungsi ada intruksi yang
memanggil fungsi itu sendiri, atau lebih sering juga disebut dengan algoritma yang
memanggil dirinya sendiri.
Contoh sederhana algoritma rekursif dalam kegidupan sehari-hari yaitu
memotong kentang tipis-tipis , yang mana apabila kentang tersebut sudah tidak bisa
diiris tipis maka pemotongan akan diselesaikan, namun apabila kentang tersebutmasih
bisa diiris tipis maka pemotongannya akan dilakukan lagi hingga kentang tidak bisa
untuk diiris lagi. Algoritma fungsi rekursif memiliki beberapa aturan :
1. Memiliki base case
2. Membut progres yang menuju ke base case
3. Mengamsumsikan bahwa pabggilan rekursif bekerja dengan baik.
4. Hindari menghitung sebuah penyelesaian dua kali.
Algoritma rekrusif memiliki beberapa kekurangan dan kelebihan, berikut kekurangan
serta kelebihan dari metode rekursif :
1. Kekurangan
1. Tidak bisa melakukan nested loop atau looping bersarang
2. Metode ini biasannya membuat fungsi yang sulit untuk dipahami dan hanya
cocok untuk persoalan tertentu saja
3. Memerlukan stack yang lebih besar, karena setiap fungsi dipanggil variabel
lokal dan parameter formal akan ditempatkan ke stack dan ada kalannya akan
menyebabkan stack tak cukup lagi (stack Overrun).
4. Proses algoritma ini sedikit berbelit-belit karena pemanggilan fungsi yang
berulang-ulang dan pemanggilan data yang menumpuk.
5. Memungkinkan terjadinya overflow pada stack ( stack tidak lagi mampu
menangani permintaan pemanggilan sebrutin karena kehabisan memori)
 2. Kelebihan dari metode rekursif
1. Mudah untuk melakukan perulangan dengan batasan yang luas dalam artian
melakukan perulangan dalam skala besar.
2. Dapat melakukan perulangan dengan batasan fungsi
Program rekursif untuk menghitung bilangan faktorial :
Perhitungan bilangan faktorial merupakan perhitungan hasil faktorial n yaitu hasil kali bilangan
dengan bilangan pembilang sehingga bilangan 1, dan dapat didefinisikan yaitu n! = n.(n-1)!
Jika n>1 dan n! =1, jika n=0,1.
Dibawah ini merupakan contoh program untuk menghitung bilangan faktorial dari 6.

#include <stdio.h>

int faktorial(int angka){ // bagian ini merupakan proses yang akan

dieksekusi oleh program

if(angka<=1){

return 1;

}else {

return angka*faktorial(angka-1); // bagian untuk mencari

faktorial

int main(){ // int untuk mengimput data yang akan diproses

printf("Faktorial dari 6 = %d", faktorial(6));

getchar();

return 0;

Dari fungsi rekursif diatas program akan selalu memanggil dirinya sendiri sambil mengurangi
atau memecahkan data. Hal ini penting diingat, karena tujuan utama dari rekursif ialah
memecahkan masalah dengan mengurangi masalah tersebut menjadi masalah-masalah kecil.
Faktorial (6) // proses yang dilakukan untuk mencari faktorial pada program adalah sebagai
berikut.
➢ 6 * faktorial (6-1)
➢ 6 * faktorial (5)
➢ 6 * (5 * faktorial (4)
 ➢ 6 * (5 * (4 * faktorial (3)))
➢ 6 * (5 * (4 * ( 3 * faktorial (2))))
➢ 6 * (5 * (4 * (3 * (2 * faktorial (1)))))
➢ 6 * (5 * (4 * (3 * ( 2 *1))))
➢ 6 * (5 * (4 * (3 * 2)))
➢ 6 * (5 * (4* 6))
➢ 6 * ( 5 * 24))
➢ 6 * 120
➢ 720

Bilangan Fibonancci merupakan suatu barisan bilangan yang mana bilangan ke –n merupakan
hasil penjumlahan dari beberapa bilangan yaitu bilangan n-1 dengan bilangan n-2. Atau dapat
lebih diserhanakan deret Fibonacci adalah suatu deret matematika yang berasal dari
penjumlahan dua bilangan sebelumnya. Suku pertama barisan febonancci adalah 1, begitu pula
dengan suku ke-2.
Program rekursif untuk menghitung bilangan fibonacci :

#include<stdio.h>

int main()
{
int nilai,hasil;
printf("masukkan n bilagan fibonensi: ");scanf("%d",&nilai);
hasil=fibo(nilai);
printf("Hasil Fobinacci : %d",hasil);
return 0;
}

int fibo(int a){

if (a==0)
return 0;
else if(a==1)
return 1;
else
return fibo(a-1)+fibo(a-2);
}
2. Buat program sorting (selection, insertion, buble, quick, merge, counting), lakukan analisa
dengan mengurutkan NIM kalian.
Tabel Analisis
Mengurutkan NIM = [1,8,1,5,0,9,1,0,0,3]
1. Bubble Sort
Program Bubble Sort
#include<stdio.h>

int angka [10]={1,8,1,5,0,9,1,0,0,3};

//selanjutnya akan dilakukan bubble sort ascanding

void bubbleSortAsc(){
//Dilakukan pengulangan sebanyak jumlah data dimana jumlah data = (n-1)
for (int a=0; a<10-1; a++){
for(int b=0; b<10-1; b++){
//jika angka index x+1 lebih kecil dari angka index x
if (angka[b+1]<angka[b]){
int temp=angka[b];
//ubah angka index x menjadi angka index x+1
angka[b]=angka[b+1];
//ubah angka index x+1 menjadi angka temp
angka[b+1]=temp;
}
}
}
}

}
}
}
void bubbleSortDesc(){
//Dilakukan pengulangan sebanyak jumlah data dimana jumlah data = (n-1)
pengulangan sebanyak 9 kali
for (int a=0; a<10-1; a++){
for(int b=0; b<10-1; b++){
//apabila index x+1 lebih kecil dari angka index x
if (angka[b+1]>angka[b]){
int temp=angka[b];
//ubah angka index ke-x menjadi angka index x+1
angka[b]=angka[b+1];
//ubah angka index x+1 menjadi angka temp
angka[b+1]=temp;
}
}
}
 }

int main(){
printf("Data Sebelum Sorting : \n");
for(int a=0; a<10; a++){
printf("%d ", angka[a]);
}
bubbleSortAsc();
printf("\n\n Data Setelah Sorting Ascending : \n");
for(int a=0; a<10; a++){
printf("%d ", angka[a]);
}
bubbleSortDesc();
printf("\n\n Data Setelah Sorting Descending : \n");
for(int a=0; a<10; a++){
printf("%d ", angka[a]);
}
getchar();
return 0;
}
Tabel Analisis
i j Sebelum Sesudah Urutan Data
Data [j] Data [j+1] Data [j] Data[j+1]

0 0 1 8 1 8 1,8,1,5,0,9,1,0,0,3
0 1 8 1 1 8 1,1,8,5,0,9,1,0,0,3
0 2 8 5 5 8 1,1,5,8,0,9,1,0,0,3
0 3 8 0 0 8 1,1,5,0,8,9,1,0,0,3
0 4 8 9 8 9 1,1,5,0,8,9,1,0,0,3
0 5 9 1 1 9 1,1,5,0,8,1,9,0,0,3
0 6 9 0 0 9 1,1,5,0,8,1,0,9,0,3
0 7 9 0 0 9 1,1,5,0,8,1,0,0,9,3
0 8 9 3 3 9 1,1,5,0,8,1,0,0,3,9
1 0 1 1 1 1 1,1,5,0,8,1,0,0,3,9
1 1 1 5 1 5 1,1,5,0,8,1,0,0,3,9
1 2 5 0 0 5 1,1,0,5,8,1,0,0,3,9
1 3 5 8 5 8 1,1,0,5,8,1,0,0,3,9
1 4 8 1 1 8 1,1,0,5,1,8,0,0,3,9
1 5 8 0 0 8 1,1,0,5,1,0,8,0,3,9
1 6 8 0 0 8 1,1,0,5,1,0,0,8,3,9
1 7 8 3 3 8 1,1,0,5,1,0,0,3,8,9
2 0 1 1 1 1 1,1,0,5,1,0,0,3,8,9
2 1 1 0 0 1 1,0,1,5,1,0,0,3,8,9
2 2 1 5 1 5 1,0,1,5,1,0,0,3,8,9
2 3 5 1 1 5 1,0,1,1,5,0,0,3,8,9
2 4 5 0 0 5 1,0,1,1,0,5,0,3,8,9
2 5 5 0 0 5 1,0,1,1,0,0,5,3,8,9
 2 6 5 3 3 5 1,0,1,1,0,0,3,5,8,9
3 0 1 0 0 1 0,1,1,1,0,0,3,5,8,9
3 1 1 1 1 1 0,1,1,1,0,0,3,5,8,9
3 2 1 1 1 1 0,1,1,1,0,0,3,5,8,9
3 3 1 0 0 1 0,1,1,0,1,0,3,5,8,9
3 4 1 0 0 1 0,1,1,0,0,1,3,5,8,9
3 5 1 3 1 3 0,1,1,0,0,1,3,5,8,9
4 0 0 1 0 1 0,1,1,0,0,1,3,5,8,9
4 1 1 1 1 1 0,1,1,0,0,1,3,5,8,9
4 2 1 0 0 1 0,1,0,1,0,1,3,5,8,9
4 3 1 0 0 1 0,1,0,0,1,1,3,5,8,9
4 4 1 1 1 1 0,1,0,0,1,1,3,5,8,9
5 0 0 1 0 1 0,1,0,0,1,1,3,5,8,9
5 1 1 0 0 1 0,0,1,0,1,1,3,5,8,9
5 2 1 0 0 1 0,0,0,1,1,1,3,5,8,9
5 3 1 1 1 1 0,0,0,1,1,1,3,5,8,9
6 0 0 0 0 0 0,0,0,1,1,1,3,5,8,9
6 1 0 0 0 0 0,0,0,1,1,1,3,5,8,9
6 2 0 1 0 1 0,0,0,1,1,1,3,5,8,9
7 0 0 0 0 0 0,0,0,1,1,1,3,5,8,9
7 1 0 0 0 0 0,0,0,1,1,1,3,5,8,9
8 0 0 0 0 0 0,0,0,1,1,1,3,5,8,9

2. Insertion Sort
Program Insertion Sort
#include<stdio.h>

//inialisasi data
int angka[10]={1,8,1,5,0,9,1,0,0,3};
void main (){

//Melakukan looping sebanyak jumlah data-1 (10-1)

for(int i=1; i<10; i++){
//looping dilakukan selama angka ke-j (j sudah di tetapkan sebagi i di awal dan lebih
kecil dari j-1)

for (int j=i; j>0 && angka[j]<angka[j-1]; j--){

//melakukan pertukaran
int temp=angka[j-1];
angka[j-1]=angka[j];
angka[j]=temp;
}
}
//mencetak data
for (int i=0; i<10; i++){
printf ("%d",angka[i]);
}
 }
Tabel Analisa Insertion Sort
NIM= [1,8,1,5,0,9,1,0,0,3]
i j Sebelum Ungkapan Sesudah Urutan Data
Data [i] Data[j-1] Data[i] Data[j-1]

1 1 8 1 F
0
2 2 1 8 T 8 1 1,1,8,5,0,9,1,0,0,3
1 1 8 F
0
3 3 5 8 T 8 5 1,1,5,8,0,9,1,0,0,3
2 5 1 F
1
4 4 0 8 T 8 0 1,1,5,0,8,9,1,0,0,3
3 0 5 T 5 0 1,1,0,5,8,9,1,0,0,3
2 0 1 T 1 0 1,0,1,5,8,9,1,0,0,3
1 0 1 T 1 0 0,1,1,5,8,9,1,0,0,3
0
5 5 9 8 F 9 8
4
6 6 1 9 T 9 1 0,1,1,5,8,1,9,0,0,3
5 1 8 T 8 1 0,1,1,5,1,8,9,0,0,3
4 1 5 T 5 1 0,1,1,1,5,8,9,0,0,3
3 1 1 F
2
7 7 0 9 T 9 0 0,1,1,1,5,8,0,9,0,3
6 0 8 T 8 0 0,1,1,1,5,0,8,9,0,3
5 0 5 T 5 0 0,1,1,1,0,5,8,9,0,3
4 0 1 T 1 0 0,1,1,0,1,5,8,9,0,3
3 0 1 T 1 0 0,1,0,1,1,5,8,9,0,3
2 0 1 T 1 0 0,0,1,1,1,5,8,9,0,3
1 0 0 F
0
8 8 0 9 T 9 0 0,0,1,1,1,5,8,0,9,3
7 0 8 T 8 0 0,0,1,1,1,5,0,8,9,3
6 0 5 T 5 0 0,0,1,1,1,0,5,8,9,3
5 0 1 T 0 1 0,0,1,1,0,1,5,8,9,3
4 0 1 T 1 0 0,0,1,0,1,1,5,8,9,3
3 0 1 T 1 0 0,0,0,1,1,1,5,8,9,3
2 0 0 F
1
9 9 3 9 T 9 3 0,0,0,1,1,1,5,8,3,9
8 3 8 T 8 3 0,0,0,1,1,1,5,3,8,9
7 3 5 T 5 3 0,0,0,1,1,1,3,5,8,9
6 3 1 F
5
Sehingga data yang terurut : [0,0,0,1,1,1,3,5,8,9]
3. Selection Sort
Program Selection Sort
#include <stdio.h>
//inisialisasi data
int angka[10]={1,8,1,5,0,9,1,0,0,3};
void main(){
//melakukan looping sebanyak jumlah data
for(int i=0; i<10; i++){
int indexNilaiMinimal=i;
//looping untuk mencari index atau posisi angka yang terkecil
//dengan membandingkan angka satu per satu
for(int j=i; j<10; j++){
//jika ada yang lebih kecil dari angka index ke indexNilaiMinimal
if(angka[j]<angka[indexNilaiMinimal]){
//maka, indexNilaiMinimal menjadi index angka tersebut
indexNilaiMinimal=j;
}
}
//lakukan pertukaran
int temp=angka[i];
angka[i]=angka[indexNilaiMinimal];
angka[indexNilaiMinimal]=temp;
}
//Mencetak data
for(int i=0; i<10; i++){
printf("%d ", angka[i]);
}
getchar();
}

Tabel Analisis Selection Sort

Angka = [1,8,1,5,0,9,1,0,0,3]
I j Angka [i] Urutan Data
Angka Angka > Angka Angka Angka
[j]
[i] [j] [i] [j]
0 1 1 8 F 1 8 1,8,1,5,0,9,1,0,0,3
0 2 1 1 F 1 1 1,8,1,5,0,9,1,0,0,3
0 3 1 5 F 1 5 1,8,1,5,0,9,1,0,0,3
0 4 1 0 T 0 1 0,8,1,5,1,9,1,0,0,3
0 5 0 9 F 0 9 0,8,1,5,1,9,1,0,0,3
0 6 0 1 F 0 1 0,8,1,5,1,9,1,0,0,3
0 7 0 0 F 0 0 0,8,1,5,1,9,1,0,0,3
0 8 0 0 F 0 0 0,8,1,5,1,9,1,0,0,3
0 9 0 3 F 0 3 0,8,1,5,1,9,1,0,0,3
 1 2 8 1 T 1 8 0,1,8,5,1,9,1,0,0,3
1 3 1 5 F 1 5 0,1,8,5,1,9,1,0,0,3
1 4 1 1 F 1 1 0,1,8,5,1,9,1,0,0,3
1 5 1 9 F 1 9 0,1,8,5,1,9,1,0,0,3
1 6 1 1 F 1 1 0,1,8,5,1,9,1,0,0,3
1 7 1 0 T 0 1 0,0,8,5,1,9,1,1,0,3
1 8 0 1 F 0 1 0,0,8,5,1,9,1,1,0,3
1 9 0 3 F 0 3 0,0,8,5,1,9,1,1,0,3
2 3 8 5 T 5 8 0,0,5,8,1,9,1,1,0,3
2 4 5 1 T 1 5 0,0,1,5,8,9,1,1,0,3
2 5 1 9 F 1 9 0,0,1,5,8,9,1,1,0,3
2 6 1 1 F 1 1 0,0,1,5,8,9,1,1,0,3
2 7 1 1 F 1 1 0,0,1,5,8,9,1,1,0,3
2 8 1 0 T 0 1 0,0,0,1,5,8,9,1,1,3
2 9 0 3 F 0 3 0,0,0,1,5,8,9,1,1,3
3 4 1 5 F 1 5 0,0,0,1,5,8,9,1,1,3
3 5 1 8 F 1 8 0,0,0,1,5,8,9,1,1,3
3 6 1 9 F 1 9 0,0,0,1,5,8,9,1,1,3
3 7 1 1 F 1 1 0,0,0,1,5,8,9,1,1,3
3 8 1 1 F 1 1 0,0,0,1,5,8,9,1,1,3
3 9 1 3 F 1 3 0,0,0,1,5,8,9,1,1,3
4 5 5 8 F 5 8 0,0,0,1,5,8,9,1,1,3
4 6 5 9 F 5 9 0,0,0,1,5,8,9,1,1,3
4 7 5 1 T 1 5 0,0,0,1,1,5,8,9,1,3
4 8 1 1 F 1 1 0,0,0,1,1,5,8,9,1,3
4 9 1 3 F 1 3 0,0,0,1,1,5,8,9,1,3
5 6 5 8 F 5 8 0,0,0,1,1,5,8,9,1,3
5 7 5 9 F 5 9 0,0,0,1,1,5,8,9,1,3
5 8 5 1 T 1 5 0,0,0,1,1,1,5,8,9,3
5 9 1 3 F 1 3 0,0,0,1,1,1,5,8,9,3
6 7 5 8 F 5 8 0,0,0,1,1,1,5,8,9,3
6 8 5 9 F 5 8 0,0,0,1,1,1,5,8,9,3
6 9 5 3 T 3 5 0,0,0,1,1,1,3,5,8,9
7 8 5 8 F 5 8 0,0,0,1,1,1,3,5,8,9
7 9 5 9 F 5 9 0,0,0,1,1,1,3,5,8,9
8 9 8 9 F 8 9 0,0,0,1,1,1,3,5,8,9

4. Counting Sort
Program Counting Sort
#include<stdio.h>
int main()
{
int L[20],temp,i,j,n=10,idx;
printf("Urut berdasarkan Counting sort \nmasukkan %d elements: \n",n);
 for(i=0;i<n;i++){
scanf("%d",&L[i]);}

printf("\n Urutan sebelum sorting: ");

for(i=0;i<n;i++){printf("%d ",L[i]);}
for (i=0;i<(n-1);i++){

idx=i;
for (j=i+1;j<n;j++){
if(L[j]<L[idx]){
idx=j;
}
}
temp=L[i];
L[i]=L[idx];
L[idx]=temp;
}
printf("\nUrutan Setelah sorting: ");
for(i=0;i<n;i++){printf("%d ",L[i]);}
printf("\n");
}

Tabel Analisis

A = Inputan
C = Acounting
B = Array Akhir

A=1 2 3 4 5 6 7 8 9 10
1 8 1 5 0 9 1 0 0 3
C1 = 0 1 2 3 4 5 6 7 8 9
3 3 0 1 0 1 0 0 1 1

C2 = 0 1 2 3 4 5 6 7 8 9
3 6 6 7 7 8 8 8 9 9

B =1 2 3 4 5 6 7 8 9 10
0 0 0 1 1 1 3 5 8 9

Tabel Analisa Counting Sort

j A[j] C[A[j]] B[C[A[j]]] C[A[j]]-1
1 1 5 B[6]= 1 C[1]=4
2 8 9 B[9]= 8 C[8]=8
3 1 4 B[4]= 1 C[1]=3
4 5 7 B[7]= 5 C[5]=6
5 0 2 B[2]= 0 C[0]=6
6 9 10 B[10]= 9 C[9]=9
7 1 3 B[3]= 1 C[1]=2
8 0 1 B[1]= 0 C[0]=0
9 0 3 B[3]= 0 C[0]=2
10 3 7 B[7]= 3 C[3]=6

5. Marge Sort

Data = [1,8,1,5,0,9,1,0,0,3]
0 1 2 3 4 5 6 7 8 9
0 8 1 5 0 9 1 0 1 3

Langkah pertama yaitu mencari nilai tengan dengan rumus :

Median = kiri + (kanan – kiri) / 2
Median = 0 + (9-0)/2
Median = 4

Langkah kedua yaitu memecah array menjadi dua sub array yaitu array A dan array B
A=0 1 2 3 4 B= 0 1 2 3 4
0 8 1 5 0 9 1 0 1 3
 Langkah ketiga yaitu mencari nilai tengah dari sub array kemudian masing-masing sub
array akan dipecah menjadi dua bagian. Sehingga didapatkan dua 4 sub array.
A= 0 1 2 B= 0 1 C= 0 1 2 D= 0 1
1 8 1 5 0 9 1 0 0 3

Langkah keempat yaitu mencari nilai tengah dari masing-masing sub array dan memecah
array menjadi 8 sub bagian .
A B C D E F G H
1 8 1 5 0 9 1 0 0 3

Langkah kelima yaitu mencari nilai tengah dari masing-masing sub array, sub array yang
tidak memiliki pasangan tidak akan dipecah. Setelah memecah sub array maka akan
terbentuk 10 sub array.
A B C D E F G H I J
1 8 1 5 0 9 1 0 0 3

Langkah keenam yaitu membandingkan masing-masing sub array yang dimulai dari kiri
nilai yang sebelumnnya tidak memiliki pasangan tidak akan ikut dibandingkan.

1 8 1 5 0 1 9 0 0 3

Langkah ketujuh yaitu setelah membandingkan sub array maka array akan disatukan
kembali. Pada tahap ini akan dilakukan perbandingan. Sub array yang sebelumnnya tidak
mendapat pasangan akan ikut dibandingkan. Sehingga terbentuk sebanyak 4 sub array.

1 1 8 0 5 1 0 9 0 3

Langkah kedelapan yaitu melakukan perbandingan kembali sehingga terbentuk 2 sub

array

0 1 1 5 8 0 0 1 3 9

Langkah kesembilan yaitu melakukan perbandingan antara kedua sub array sehingga akan
terbentuk urutan arrat sebagai berikut
0 0 0 1 1 1 3 5 8 9
6. Quick Sort

Data = [1,8,1,5,0,9,1,0,0,3]

Langkah pertama yang dilakukan yaitu menentukan elemen sementara atau pivot value.
Pivot yang digunakan yaitu. Selanjutnya mencari elemen awal [i]= 1, selanjutnya elemen
akhir [j] = 3. Sehingga data terbagi menjadi dua partisi .
0 1 2 3 4 5 6 7 8 9

1 8 1 5 0 9 1 0 0 3
i Pivot Partisi 2 [j]

Tukarkan atau pindahkan partisi yang nilainnya lebih kecil dari “pivot” disebelah kiri dan
nilai yang ebih besar diletakkan disebelah kanan pivot
0 1 2 3 4 5 6 7 8 9

1 8 1 5 0 9 1 0 0 3
i Pivot j
Pertama bandingkan i dengan pivot. Karena i> pivot maka i berhenti pada index ke-0. Data j>
pivot maka j akan berjalan ke sebelah kiri

0 1 2 3 4 5 6 7 8 9
1 8 1 5 0 9 1 0 0 3
i Pivot j
langkah selanjutnya i tetap pada index ke-0, data j<= pivot maka j berhenti pada index ke-8.
Sehingga data j akan ditukar dengan data i. Dan i bergeser ke sebelah kanan.
0 1 2 3 4 5 6 7 8 9
0 8 1 5 0 9 1 0 1 3
i Pivot j
langkah ketiga yaitu bandingkan i dengan pivot ( i > pivot) sehingga i akan bergeser
kesebelah kanan pivot. Dan j> pivot sehingga data j ber[pindah kesebelah kiri.
0 1 2 3 4 5 6 7 8 9
0 8 1 5 0 9 1 0 1 3
i Pivot j
langkah ke empat bandingkan i dengan pivot ( i>pivot) maka i akan tetap berada pada index
ke-2. Data j <=pivot maka j akan bergeser kesebelah kiri. Sehingga data j akan berada pada
index ke 6.
0 1 2 3 4 5 6 7 8 9
0 8 1 5 0 9 1 0 1 3
i Pivot j