procedure bubble sort versi boolean dalam notasi algoritmik

procedure bubbleshort (m:array[1..20] of integer, input n:integer)
{Mengurutkan isi dari tabel m dari kecil ke besar dengan metode pengurutan bubble short}
Kamus
i,j,temp:integer {variable perulangan}
cek:boolean

Algoritma
i <- 1
cek <- true
while (i <= n-1) and (cek=true) do
cek <- false
for j <- n downto i+1
if m[j] < m[j-1] then
temp <- m[j]
m[j] <- m[j-1]
m[j-1] <- temp
cek <- true
endif
endfor
endwhile
i <- i+1

› Read More

procedure bubble sort dalam notasi algoritmik

procedure bubbleshort (m:array[1..20] of integer, input n:integer)
{Mengurutkan isi dari tabel m dari kecil ke besar dengan metode pengurutan bubble short}

Kamus
i,j:integer {variable perulangan}

Algoritma
for i = 1 to n-1 do
for j = i+1 to n do
if m[j]< m[j+1] then
temp ← m[j]
m[j] ← m[j+1]
m[j+1] ← temp
end if
end for
end for

› Read More

procedure selection sort dalam notasi algoritmik

Procedure SelectionSort (data : array[1..100] of integer; input n:integer)
{ Mengurutkan data [1..100] dengan algoritma Selection Sort.}

Kamus
i, j, temp, min : integer

Algoritma:
for i= 1 to n-1 do {notasi for}
min ← i
for j = i+1 to n do
if data[min] > data[j] then
temp ← data[j]
endif
endfor
temp ← data[i]
data[i] ← data[j]
data[j] ← temp
end for

› Read More

Counting Sort dalam notasi algoritmik

Procedure CountingSort (Input/output T:array [1..N] of integer)
{Mengurutkan Tabel T integer [1..N] dengan pencacahan, dimana range atau rentang nilainya [1..k] dengan hasil akhir T terurut menaik , dengan asumsi:Nilai N (jumlah elemen T) dan k diketahui
Asumsi : Nilai N (jumlah elemen T) dan k diketahui, rentang nilai untuk elemen T integer antara 1..k }

Kamus
C : array [1..k] of integer {Tabel array pencacahan}
i, j : Integer {indek perulangan}
c : Integer {jumlah elemen T yang sudah diisi pada pembentukank kembali}

Algoritma
for i = 1 to k do {Loop 1}
C[ i ] <-- 0;
endfor

for i = 1 to N do {Loop 2}
C[ T[ i ] ] <-- C[ T [ i ] ] + 1
endfor

c <-- 0

for i = 1 to k do {Loop 3}
if C[ i ] <> 0 then
for j = 1 to C[ i ] do {Loop 4}
c <--c + 1
T[c] <-- i
endfor;
endif;
endfor;

› Read More

bucket Sort dalam notasi algoritmik

Algoritma Bucket Sort

Procedure BucketSort ( Input/Output T: array[1..n] of integer, b: integer Output T: Array[1..n], Input n,max_n:integer)

{procedure untuk mengurutkan T array secara ascending, dengan asumsi jumlah data dan nilai terbesar diketahui}

Kamus

range                : integer                                                      {rentang nilai bucket}

x,y, i, j              : integer

baris, kolom      : integer

isi_bucket         : array [1..b] of integer                                 {penyimpan nilai isi tiap bucket}

lengh_bucket    : array [1..n] of integer                                 {kapasitas bucket menyimpan nilai}

bucket              : array [1..b] of lengh_bucket                      {bucket; kumpulan lengh_bucket}

Algoritma

x ß max_n div b

y ß max_n mod b

if (y > 0) then

                range ß x + 1

else                                                                                     {menentukan interval @bucket}

                range ß x

endif

for i = 1 to b do

                isi_bucket[i] ß 0                                                 {inisialisasi isi @bucket = 0}

endfor

for i = 1 to n do

                x              ß T[i] div range

                y              ß T[i] mod range

if (y > 0) then

                                x              ß x + 1                                 {loop; membagi nilai T ke dalam @bucket}

                endif

                isi_bucket[x]         ß isi_bucket[x] + 1

                baris                      ß x

                kolom                    ß isi_bucket[x]

                bucket[m, n]         ßT[i]     

endfor

for i = 1 to b do

                                                           {pengurutan @ bucket dengan algoritma pengurutan tertentu}

Endfor

n ß 1

for i = 1 to b do

                for  j = 1 to isi_bucket[i] do

                                T[n] ß bucket[i,j]                                  {penggabungan bucket}

                                n ß n + 1

                endfor

endfor

› Read More

procedure counting sort

Procedure CountingSort (Input/output T:array [1..N] of integer)
{Mengurutkan Tabel T integer [1..N] dengan pencacahan, dimana range atau rentang nilainya [1..k] dengan hasil akhir T terurut menaik , dengan asumsi:Nilai N (jumlah elemen T) dan k diketahui 
Asumsi : Nilai N (jumlah elemen T) dan k diketahui, rentang nilai untuk elemen T integer antara 1..k }

Kamus 
C : array [1..k] of integer {Tabel array pencacahan}
i, j : Integer {indek perulangan}
c : Integer {jumlah elemen T yang sudah diisi pada pembentukan kembali}

Algoritma 
for i = 1 to k do {Loop 1}
C[ i ] <-- 0;
endfor

for i = 1 to N do {Loop 2}
C[ T[ i ] ] <-- C[ T [ i ] ] + 1
endfor

C <-- 0

for i = 1 to k do {Loop 3}
if C[ i ] < > 0 then 
for j = 1 to C[ i ] do {Loop 4}
C <-- C + 1
T[C] <-- i
endfor;
endif;
endfor;

› Read More

mencari nilai max min secara rekursif

Procedure rekursifmaxmin(input T[1..N] array of integer, i:integer, j:integer,  output max,min:integer)

Kamus
  T1,T2: array
  min1,min2,max1,max2:integer

Algoritma
  if i=j then
  max <-- T[i]
  min <-- T[i]
  else
    if i=j-1 then
      if T[j]> T[i] then
         max <-- T[j]
         min <-- T[i]
      else
         max <-- T[i]
         min <-- T[j]
      endif
    else
      mid <-- (i+j) div 2
      maxmin(T1,i,mid,max1,min1)
      maxmin(T2,mid+1,j,2max,min2)

      if max1>max2 then
         max <-- max1
      else
         max <-- max2
      endif

      if min1 > min2 then
         min <-- min2
      else
         min <-- min1
      endif
  endif

› Read More