Metode Pengurutan (Sort) ~ Kurriah

1. Straight Insertion Sort (Metode Penyisipan langsung)

Proses pengurutan dengan metode penyisipan langsung dapat dijelaskan sebagai berikut :

Data dicek satu per satu mulai dari yang kedua sampai dengan yang terakhir. Apabila ditemukan data yang lebih kecil daripada data sebelumnya, maka data tersebut disisipkan pada posisi yang sesuai. Akan lebih mudah apabila membayangkan pengurutan kartu. Pertama-tama anda meletakkan kartu-kartu tersebut di atas meja, kemudian melihatnya dari kiri ke kanan. Apabila kartu di sebelah kanan lebih kecil daripada kartu di sebelah kiri, maka ambil kartu tersebut dan sisipkan di tempat yang sesuai.

Contoh Insertion Sort :

> 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

Contoh kasus

>Notasi Algoritma Penyisipan Langsung

procedure penyisipan_langsung(input n,i,j,x : integer input/output var data : larikint)

for i <- 2 to n do

x <- data[i]

j <- i-1

ketemu <- false

while (j ≥ 1) and (not ketemu) do

if x < data[j] then

data[j+1] <- data[j]

j <- j-1;

else

ketemu <- true

endif

endwhile

data[j+1] <- x

endwhile

>Pascal

program metode_penyisipan_langsung;

const max = 1000;

type larikint = array [1..max] of integer;

var

data : larikint;

n,i,j,x :integer;

ketemu : boolean;

procedure penyisipan_langsung(n,i,j,x : integer; var data : larikint);

begin

for i := 2 to n do

begin

x := data[i];

j := i-1;

ketemu := false;

while (j>=1) and (not ketemu) do

begin

if x < data[j] then

begin

data[j+1] := data[j];

j := j-1;

end

else

ketemu := true;

end;

data[j+1] := x;

end;

begin

write('Masukkan Jumlah Data : ');readln(n);

for i := 1 to n do

begin

write (' Data Ke ',i,' : ');readln(data[i]);

end;

WriteLn;

write ('Sebelum Di Urutkan : ');

for i := 1 to n do

Write (data[i],' ');

penyisipan_langsung(n,i,j,x,data);

WriteLn;

writeln;

write ('Hasil Pengurutan penyisipan langsung : ');

for i := 1 to n do

write(data[i],' ');

ReadLn;

end.

>Program Penyisipan Langsung

>Flowchart

Gambar 1 Flowchart Penyisipan Langsung

2. Metode Penyisipan Biner ( Binary Insertion Sort)

Metode pengurutan dengan algoritma penyisipan biner ( binary insertion sort )
memperbaiki metode pengurutan dengan algoritma penyisipan langsung dengan
melakukan proses perbandingan yang lebih sedikit sehingga pros es pengurutan lebih cepat.
Metode ini merupakan pengembangan dari metode penyisipan langsung. Dengan cara penyisipan langsung, perbandingan selalu dimulai dari elemen pertama (data ke-0), sehingga untuk menyisipkan elemen ke i kita harus melakukan perbandingan sebanyak i- 1 kali. Ide dari metode ini didasarkan pada kenyataan bahwa pada saat menggeser data ke-i, data ke 0 s/d i-1 sebenarnya sudah dalam keadaan terurut.

Gambar 2 Binary Flowchart

3. Selection Sort

Selection Sort adalah Perbaikan dari metode bubble sort yang mengurangi perbandingan dan pertukaran, metode ini dapat mencari nilai terkecil atau terbesar.

Cara kerja metode ini didasarkan pada pencarian elemen dengan nilai terkecil, kemudian dilakukan penukaran dengan elemen ke-1 secara singkat metode ini bisa dijelaskan sebagai berikut. Pada langkah pertama, dicari data terkecil dari data pertama sampai terakhir. Kemudian data tersebut kita tukar dari data pertama, dengan demikian data pertama sekarang mempunyai nilai paling kecil dibandingkan dengan data lain. Pada langgkah ke-2, data terkecil kita cari mulai dari data kedua sampai data terakhir. Data terkecil yang kita peroleh kita tukar dengan data kedua, demikian seterus nya sampai seluruh data terurut.

Contoh ilustrasi metode selection sort sebagai berikut :

>Algoritma Selection Sort

procedure seleksi(n,i,j,x,m :integer; var L:larikint);

begin

for i <- n downto 2 do

m <- 1

for j <- 2 to i do

if L[j] > L[m] then

m <- j

endfor

x <- L[i]

L[i] <- L[m]

L[m] <- x

endfor

endprocedure

>Pascal Selection Sort

program metode_seleksi;

const max = 1000;

type larikint = array [1..max] of integer;

var

data : larikint;

jml_data,bil,pencari_bil_max,bantu,bil_max :integer;

procedure seleksi(n,i,j,x,m :integer; var L:larikint);

begin

for i := n downto 2 do

begin

m := 1;

for j := 2 to i do

begin

if L[j] > L[m] then

m := j;

end;

x := L[i];

L[i] := L[m];

L[m] := x

end;

begin

write('Masukkan Jumlah Data : ');readln(jml_data);

for bil := 1 to jml_data do

begin

write (' Data Ke ',bil,' : ');readln(data[bil]);

end;

WriteLn;

write ('Sebelum Di Urutkan : ');

for bil := 1 to jml_data do

Write (data[bil],' ');

seleksi(jml_data,bil,pencari_bil_max,bantu,bil_max,data);

WriteLn;

writeln;

write ('Hasil Pengurutan seleksi : ');

for bil := 1 to jml_data do

write(data[bil],' ');

ReadLn;

end.

>Program Pascal Selection Sort

>Flowchart Selection Sort

Gambar 3 Flowchart Selection Sort

4. Bubble Sort

Bubble Sort adalah metode pencarian yang mengambil dari sifat gelembung yaitu mengampung artinya mengambil nilai paling besar dan di letakan dipaling kanan.

Buble sort mengurutkan data dengan cara membandingkan elemen sekarang dan elemen berikutnya. Jika elemen sekarang lebih besar dari elemen berikutnya maka elemen tersebut ditukar (untuk pengurutan ascending). Jika elemen sekarang lebih kecil daripada elemen berikutnya, maka kedua elemen tersebut ditukar (untuk pengurutan descending). Algoritma ini seolah olah menggeser satu persatu elemen dari kanan ke kiri atau kiri ke kanan. Setelah proses telah selesai, maka buble sort akan mengalami proses, demikian seterusnya. Buble sort akan berhenti jika seluruh array telah diperiksa dan tidak ada pertukaran lagi yang bisa dilakukan dan tercapailah pengurutan yang telah diinginkan.

Contoh ilustrasi pengurutan data dengan metode buble sort sebagai berikut:

>Algoritma Bubble Sort

procedure gelembung(n,i,g,x :integer; var L:larikint);

begin

for i <- 1 to n-1 do

begin

for g <- n downto i+1 do

begin

if L[g] < L[g-1] then

begin

x<-L[g]

L[g]<-L[g-1]

L[g-1]<-x

endif

endfor

endprocedure

>Pascal Bubble Sort

program metode_gelembung;

const max = 1000;

type larikint = array [1..max] of integer;

var

data : larikint;

jml_data,bil,gel,bantu :integer;

procedure gelembung(n,i,g,x :integer; var L:larikint);

begin

for i := 1 to n-1 do

begin

for g := n downto i+1 do

begin

if L[g] < L[g-1] then

begin

x:=L[g];

L[g]:=L[g-1];

L[g-1]:=x;

end;

begin

write('Masukkan Jumlah Data : ');readln(jml_data);

for bil := 1 to jml_data do

begin

write (' Data Ke ',bil,' : ');readln(data[bil]);

end;

WriteLn;

write ('Sebelum Di Urutkan : ');

for bil := 1 to jml_data do

Write (data[bil],' ');

gelembung(jml_data,bil,gel,bantu,data);

WriteLn;

writeln;

write ('Hasil Pengurutan Gelembung : ');

for bil := 1 to jml_data do

write(data[bil],' ');

ReadLn;

end.

>Program Metode Bubble Sort

5.Shell Sort (Metode Shell)

Metode ini 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. Proses pengurutan dengan metode Shell dapat dijelaskan sebagai berikut :
Pertama-tama adalah menentukan jarak mula-mula dari data yang akan dibandingkan, yaitu N / 2. Data pertama dibandingkan dengan data dengan jarak N / 2. Apabila data pertama lebih besar dari data ke N / 2 tersebut maka kedua data tersebut ditukar. Kemudian data kedua dibandingkan dengan jarak yang sama yaitu N / 2. Demikian seterusnya sampai seluruh data dibandingkan sehingga semua data ke-j selalu lebih kecil daripada data ke-(j + N / 2).
Pada proses berikutnya, digunakan jarak (N / 2) / 2 atau N / 4. Data pertama dibandingkan dengan data dengan jarak N / 4. Apabila data pertama lebih besar dari data ke N / 4 tersebut maka kedua data tersebut ditukar. Kemudian data kedua dibandingkan dengan jarak yang sama yaitu N / 4. Demikianlah seterusnya hingga seluruh data dibandingkan sehingga semua data ke-j lebih kecil daripada data ke-(j + N / 4).
Pada proses berikutnya, digunakan jarak (N / 4) / 2 atau N / 8. Demikian seterusnya sampai jarak yang digunakan adalah 1.

>Algoritma Shell Sort

procedure sisip (n,start,step:integer; var L:larikint);

var

i,j,x:integer;

ketemu : boolean;

begin

i<- start+step;

while i <- n do

begin

x <- L[i];

j <- i-step;

ketemußfalse;

while (j≥1) and (not ketemu) do

begin

if x < L[j] then

begin

L[j+step] <- L[j];

J<-j-step;

end

else

ketemu<-true;

end;

L[j+step] <- x;

i <- i+step;

endwhile

endif

procedure shell(n,i,j:integer; var L:larikint);

begin

i<-n;

while i > 1 do

begin

i <- i div 3+1;

for j <- 1 to i do

begin

sisip(n,i,j,L)

endwhile

endfor

endprocedure

>Pascal Shell Sort

program metode_shell;

const max = 1000;

type larikint = array [1..max] of integer;

var

data : larikint;

jml_data,bil,step :integer;

procedure sisip (n,start,step:integer; var L:larikint);

var

i,j,x:integer;

ketemu : boolean;

begin

i:= start+step;

while i <= n do

begin

x :=L[i];

j:=i-step;

ketemu:=false;

while (j>=1) and (not ketemu) do

begin

if x < L[j] then

begin

L[j+step] := L[j];

j:=j-step;

end

else

ketemu:=true;

end;

L[j+step] := x;

i := i+step;

end;

procedure shell(n,i,j:integer; var L:larikint);

begin

i:=n;

while i > 1 do

begin

i := i div 3+1;

for j := 1 to i do

begin

sisip(n,i,j,L)

end;

begin

write('Masukkan Jumlah Data : ');readln(jml_data);

for bil := 1 to jml_data do

begin

write (' Data Ke ',bil,' : ');readln(data[bil]);

end;

WriteLn;

write ('Sebelum Di Urutkan : ');

for bil := 1 to jml_data do

Write (data[bil],' ');

shell(jml_data,bil,step,data);

WriteLn;

writeln;

write ('Hasil Pengurutan shell : ');

for bil := 1 to jml_data do

write(data[bil],' ');

ReadLn;

end.

>Program Pascal Shell Sort

6.Quick Sort (Metode Quick)

Metode Quick sering disebut juga metode partisi (partition exchange sort). Metode ini diperkenalkan pertama kali oleh C.A.R. Hoare pada tahun 1962. Untuk mempertinggi efektifitas dari metode ini, digunakan teknik menukarkan dua elemen dengan jarak yang cukup besar.

Proses penukaran dengan metode quick dapat dijelaskan sebagai berikut.: mula-mula dipilih data tertentu yang disebut pivot, misalnya x. Pivot dipilih untuk mengatur data di sebelah kiri agar lebih kecil daripada pivot dan data di sebelah kanan agar lebih besar daripada pivot. Pivot ini diletakkan pada posisi ke j sedemikian sehingga data antara 1 sampai dengan j-1 lebih kecil daripada x. Sedangkan data pada posisi ke j+1 sampai N lebih besar daripada x. Caranya dengan menukarkan data diantara posisi 1 sampai dengan j-1 yang lebih besar daripada x dengan data diantara posisi j+1 sampai dengan N yang lebih kecil daripada x. Ilustrasi dari metode quick dapat dilihat pada Gambar 4

Gambar 4 Ilustrasi Metode Quick Sort

Gambar 4 diatas menunjukkan pembagian data menjadi sub-subbagian. Pivot dipilih dari data pertama tiap bagian maupun sub bagian, tetapi sebenarnya kita bisa memilih sembarang data sebagai pivot. Dari ilustrasi diatas bisa kita lihat bahwa metode Quick Sort ini bisa kita implementasikan menggunakan dua cara, yaitu dengan cara non rekursif dan rekursif. Pada kedua cara diatas, persoalan utama yang perlu kita perhatikan adalah bagaimana kita meletakkan suatu data pada posisinya yang tepat sehingga

memenuhi ketentuan diatas dan bagaimana menyimpan batas-batas subbagian. Dengan cara seperti yang diperlihatkan pada Gambar 6.1, kita hanya menggerakkan data pertama sampai di suatu tempat yang sesuai. Dalam hal ini kita hanya bergerak dari satu arah saja. Untuk mempercepat penempatan suatu data, kita bisa bergerak dari dua arah, kiri dan kanan. Caranya adalah sebagai berikut : misalnya kia mempunyai 10 data (N=9) :

12 35 9 11 3 17 23 15 31 20

i=0 j=9

Pertama kali ditentukan i=0 (untuk bergerak dari kiri ke kanan), dan j=N (untuk bergerak dari kanan ke kiri). Proses akan dihentikan jika nilai i lebih besar atau sama dengan j.

Sebagai contoh, kita akan menempatkan elemen pertama, 12 pada posisinya yang tepat dengan bergerak dari dua arah, dari kiri ke kanan dan dari kanan ke kiri secara bergantian. Dimulai dari data terakhir bergerak dari kanan ke kiri (j dikurangi 1), dilakukan pembandingan data sampai ditemukan data yang nilainya lebih kecil dari 12 yaitu 3 dan kedua elemen data ini kita tukarkan sehingga diperoleh

3 35 9 11 12 17 23 15 31 20

i=0 j=4

Setelah itu bergerak dari kiri ke kanan dimulai dari data 3 (i ditambah 1), dilakukan pembandingan pada setiap data yang dilalui dengan 12, sampai ditemukan data yang nilainya lebih besar dari 12 yaitu 35. Kedua data kita tukarkan sehingga diperoleh

3 12 9 11 35 17 23 15 31 20

i=1 j=4
Berikutnya bergerak dari kanan ke kiri dimulai dari 11. Dan ternyata data 11 lebih kecil dari 12, kedua data ini ditukarkan sehingga diperoleh

63

3 11 9 12 35 17 23 15 31 20

i=1 j=3

Kemudian dimulai dari 9 bergerak dari kiri ke kanan. Pada langkah ini ternyata tidak ditemukan data yang lebih besar dari 12 sampai nilai i=j. Hal ini berarti proses penempatan data yang bernilai 12 telah selesai, sehingga semua data yang lebih kecil dari 12 berada di sebelah kiri dan data yang lebih besar dari 12 berada di sebelah kanan seperti terlihat di bawah ini.

>Algoritma Metode Quick

Procedure Quick(A: Larik; m : integer; Var baca:integer);

Var G:integer;

Procedure Urut(awal, akhir: integer);

Var kiri, kanan, pusat : integer;

Begin

Pusat<-A[(awal+akhir) div 2];

Kiri<-awal;

Kanan<-akhir;

While kiriçkanan Do

Begin

While A[kiri]<pusat Do

Inc(kiri);

While A[kanan]>pusat Do

Dec(kanan);

If kiriçkanan Then

Begin

G<-A[kiri];

A[kiri]<-A[kanan];

A[kanan]<-;

Inc(kiri);

Dec(kanan);

Inc(baca);

Endif

Endwhile

If kanan>awal Then

Urut(awal,kanan);

If akhir>kiri Then

Urut(kiri,akhir);

Endif

Begin

baca:=0;

Urut(1,m);

Write('Hasil Pengurutan Quick: ');

For i <- 1 To m Do

Write(A[i],' ');

Endprocedure

>Pascal Metode Quick

program metode_quick;

Const Max=1000;

Type Larik = Array [1..Max] Of integer;

Var data : Larik;

x,i,n : integer;

Procedure Quick(A: Larik; m : integer; Var baca:integer);

Var G:integer;

Procedure Urut(awal, akhir: integer);

Var kiri, kanan, pusat : integer;

Begin

pusat:=A[(awal+akhir) div 2];

kiri:=awal;

kanan:=akhir;

While kiri<=kanan Do

Begin

While A[kiri]<pusat Do

Inc(kiri);

While A[kanan]>pusat Do

Dec(kanan);

If kiri<=kanan Then

Begin

G:=A[kiri];

A[kiri]:=A[kanan];

A[kanan]:=G;

Inc(kiri);

Dec(kanan);

Inc(baca);

End;

If kanan>awal Then

Urut(awal,kanan);

If akhir>kiri Then

Urut(kiri,akhir);

End;

Begin

baca:=0;

Urut(1,m);

Write('Hasil Pengurutan Quick: ');

For i:= 1 To m Do

Write(A[i],' ');

End;

Begin

Write('Masukkan Jumlah Data: ');Readln(n);

for i := 1 to n do

begin

write (' Data Ke ',i,' : ');readln(data[i]);

end;

WriteLn;

write ('Sebelum Di Urutkan : ');

for i := 1 to n do

Write (data[i],' ');

Writeln;Writeln;

Quick(data,n,X);

ReadLn;

end.

>Program Metode Quick

7. Merge Sort (Metode Penggabungan)

Metode penggabungan biasanya digunakan pada pengurutan berkas. Prinsip dari metode penggabungan sebagai berikut :
Mula-mula diberikan dua kumpulan data yang sudah dalam keadaan urut. Kedua kumpulan data tersebut harus dijadikan satu table sehingga dalam keadaan urut. Misalnya kumpulan data pertama (T1) adalah sebagai berikut :

3

11

12

23

31

Sedangkan kumpulan data kedua (T2) adalah sebagai berikut :

9

15

17

20

35

Proses penggabungan ini dapat dijelaskan sebagai berikut : mula-mula diambil data pertama dari T1 yaitu 3 dan data pertama dari T2 yaitu 9. Data ini dibandingkan, kemudian yang lebih kecil diletakkan sebagai data pertama dari hasil pengurutan, misalnya T3. Jadi T3 akan memiliki satu data yaitu 3. Data yang lebih besar yaitu 9 kemudian dibandingkan dengan data kedua dari T1, yaitu 11. Ternyata 9 lebih kecil dari 11, sehingga 9 diletakkan sebagai data kedua dari T3. Demikian seterusnya sehingga didapat hasil sebagai berikut :

3

9

11

12

15

17

20

23

31

35

>Algoritma Metode Penggabungan

procedure penggabungan (i1,i2: integer; L1,L2 : larikint; n1,n2 : integer; var L3:larikint; i3,n3: integer);

var

k1,k2,k3,j1,j2,j3,x1,x2,x3 : integer;

ketemu : boolean;

n3 <- n1+n2;

k1 <- 1;

k2 <- 1;

k3 <- 1;

for i1 <- 2 to n1 do

x1 <- L1[i1];

j1 <- i1-1;

ketemu <- false;

while (j1≥1) and (not ketemu) do

begin

if x1 < L1[j1] then

begin

L1[j1+1] <- L1[j1];

j1 <- j1-1;

end

else

ketemu <- true;

end;

L1[j1+1] <- x1;

endif

for i2 <- 2 to n2 do

x2 <- L2[i2];

j2 <- i2-1;

ketemu <- false;

while (j2≥1) and (not ketemu) do

if x2 < L2[j2] then

L2[j2+1] <- L2[j2];

j2 <- j2-1;

endif

else

ketemu <- true;

endelse

L2[j2+1] <- x2;

endif

while (k1 <= n1) and (k2 <= n2) do

if L1[k1] <= L2[k2] then

begin

L3[k3] <- L1[k1];

k1 <- k1+1;

end

else

L3[k3] <- L2[k2];

k2 <- k2+1;

endif

k3 <- k3+1;

endelse

while (k1 <= n1) do

L3[k3] <- L1[k1];

k1 <- k1+1;

k3 <- k3+1;

end;

while (k2 <= n2) do

L3[k3] <- L2[k2];

k2 <- k2+1;

k3 <- k3+1;

endwhile

endprocedure

>Pascal Metode Penggabungan

program metode_penggabungan;

const max = 1000;

type larikint = array [1..max] of integer;

var

data1,data2,data3 : larikint;

jml_data1, jml_data2, jml_data3, bil1, bil2, bil3 :integer;

procedure penggabungan (i1,i2: integer; L1,L2 : larikint; n1,n2 : integer; var L3:larikint; i3,n3: integer);

var

k1,k2,k3,j1,j2,j3,x1,x2,x3 : integer;

ketemu : boolean;

begin

n3 := n1+n2;

k1 := 1;

k2 := 1;

k3 := 1;

for i1 := 2 to n1 do

begin

x1 := L1[i1];

j1 := i1-1;

ketemu := false;

while (j1>=1) and (not ketemu) do

begin

if x1 < L1[j1] then

begin

L1[j1+1] := L1[j1];

j1 := j1-1;

end

else

ketemu := true;

end;

L1[j1+1] := x1;

end;

for i2 := 2 to n2 do

begin

x2 := L2[i2];

j2 := i2-1;

ketemu := false;

while (j2>=1) and (not ketemu) do

begin

if x2 < L2[j2] then

begin

L2[j2+1] := L2[j2];

j2 := j2-1;

end

else

ketemu := true;

end;

L2[j2+1] := x2;

end;

while (k1 <= n1) and (k2 <= n2) do

begin

if L1[k1] <= L2[k2] then

begin

L3[k3] := L1[k1];

k1 := k1+1;

end

else

begin

L3[k3] := L2[k2];

k2 := k2+1;

end;

k3 := k3+1;

end;

while (k1 <= n1) do

begin

L3[k3] := L1[k1];

k1 := k1+1;

k3 := k3+1;

end;

while (k2 <= n2) do

begin

L3[k3] := L2[k2];

k2 := k2+1;

k3 := k3+1;

end;

begin

write('Masukkan Jumlah Data Pertama : ');readln(jml_data1);

for bil1 := 1 to jml_data1 do

begin

write (' Data Ke ',bil1,' : ');readln(data1[bil1]);

end;

WriteLn;

write ('Data Pertama Sebelum Di Urutkan : ');

for bil1 := 1 to jml_data1 do

Write (data1[bil1],' ');

WriteLn;

WriteLn; write('Masukkan Jumlah Data kedua : ');readln(jml_data2);

for bil2 := 1 to jml_data2 do

begin

write (' Data Ke ',bil2,' : ');readln(data2[bil2]);

end;

WriteLn;

write ('data kedua Sebelum Di Urutkan : ');

for bil2 := 1 to jml_data2 do

Write (data2[bil2],' ');

jml_data3:= jml_data1+jml_data2;

penggabungan (bil1,bil2,data1,data2,jml_data1,jml_data2,data3,bil3,jml_data3);

WriteLn;

writeln;

write ('Hasil Pengurutan Penggabungan data pertama dan kedua : ');

for bil3 := 1 to jml_data3 do

write(data3[bil3],' ');

ReadLn;

end.

>Program Metode Penggabungan

Daftar Pustaka
>Penerbit Informatika (Algoritma Dan Pemrograman/Rinaldi Munir/2011)

Selanjutnya - Metode Pencarian (Searching) >

Kurriah

Sabtu, 01 Oktober 2016

Metode Pengurutan (Sort)

1 komentar: