AKU DENGAR BISIKAN SUARAMU

AKU DENGAR BISIKAN SUARAMU 

Aku dengar bisikan suaraMu
Menggema lembut di dalam batinku
Sungguh engkau sahabatKu
Jikalau engkau menaati perintahKu

Ref :
Pergilah dan sebarkanlah
Kabar sukacitaku
Sampai akhir jaman Aku sertamu

Bukanlah engkau yang memilihKu
Melainkan Aku yang memilihmu
Kini Aku serahkan tugas
Supaya engkau menghasilkan buah limpah---Ref

Jangan bimbang dan ragu hatimu
Yakinlah Aku hadir di sampingmu
Wartakan ke sluruh dunia
Aku datang membawa makna kehidupan---Ref

Aplikasi Cek Hari Pasaran

Aplikasi ini berguna untuk melihat atau cek Hari dan Pasaran suatu tanggal yang kita inginkan.

• Dapat dijalankan secara langsung dan offline dengan Microsoft Excel.

• Setelah tampilan muncul seperti gambar di atas, Anda tinggal ketik tanggal pada kotak tanggal yang tersedia (misalnya: "10-02-2014" tanpa tanda kutip).

• Setelah itu tekan tombol ENTER.

• Hasil akan langsung muncul di bawahnya.

Bagi yang berminat silakan download filenya di sini , GRATIS mas broo...!!
Semoga bermanfaat.

Download

Stack (java.coding)

Stack

Ini adalah hasil pengerjaan untuk tugas kuliah ALGORITMA & STRUKTUR DATA II.

import javax.swing.*;

import java.util.*;

public class stack2 {

  public static void main (String []args)

  {

    String jml_input, data;

    int n, i;

   

    jml_input = JOptionPane.showInputDialog("Jumlah input:");

    n         = Integer.parseInt(jml_input);

    System.out.println("Jumlah inputan : "+ n);

    System.out.println("______________________");

    Stack s = new Stack ();

   

    System.out.println("Hasil proses push : ");

    for (i=0; i<n; i++)

    {

      data = JOptionPane.showInputDialog("masukkan data ke-"+(i+1));

      s.push(data);

      System.out.println("push ke-"+(i+1)+" =" + data);  

    }

    System.out.println("______________________");

    System.out.println("Hasil proses pop : ");

   

    while (!s.empty())

    {

      Object elemen = s.pop();

      System.out.println(elemen);

    }

    System.out.println("");

  }

}

Hasil proses running program akan terlihat seperti gambar berikut.

Stack

Stack merupakan bagian dari struktur data yang dikategorikan ke dalam bentuk linear data, dimana operasi pemasukan maupun pengeluaran data selalu dilakukan pada salah satu sisinya[1]. Dalam dunia komputer, penggunaan stack (tumpukan) merupakan suatu hal yang umum digunakan seperti untuk penentuan alamat memory, penempatan ruang data dan aplikasi lain. Sebagai bagian dari struktur data, aplikasi stack juga digunakan untuk berbagai macam keperluan seperti pengujian kalimat palindrome, penguji tanda kurung (matching parentheses), dan juga berfungsi sebagai konversi dari notasi infix menjadi notasi postfix.


Pada perhitungan aritmatika, notasi infix adalah notasi yang menempatkan operator ditengah dua operand sedangkan notasi Postfix adalah notasi yang menempatkan operator setelah dua operand. Penggunaan notasi infix merupakan hal yang lumrah digunakan dalam perhitungan aritmatika dibandingkan dengan penggunaan notasi Postfix, akan tetapi bagi mesin kompilasi notasi Postfix merupakan notasi yang digunakan untuk melakukan suatu perhitungan.


Tulisan ini dibuat untuk memberikan gambaran secara jelas proses simulasi konversi atas dua notasi aritmatika tersebut, berdasarkan studi literatur dari beberapa buku dan dituangkan dengan bantuan bahasa pemrograman Pascal. Adapun proses konversi ini ditujukan untuk menjelaskan bagaimana mesin kompilasi dapat merubah notasi infix yang biasa digunakan oleh berbagai kalangan menjadi notasi Postfix yang dimengerti oleh mesin kompilasi sehingga suatu proses perhitungan aritmatika dapat dilaksanakan oleh komputer. Alasan pemilihan bahasa pemrograman Pascal digunakan karena fleksibilitas bahasa tersebut dalam menerangkan implementasi dan aplikasi dari struktur data dalam bentuk pemrograman (2).
TEORI
1. Definisi


Dalam dunia komputer, penggunaan stack atau tumpukan merupakan salah satu komponen penting untuk menjamin proses penanganan suatu data disamping hal lain seperti Queue (antrian), linked list, dan tree.


Definisi 1.


Stack adalah suatu koleksi atau kumpulan item data yang teroganisasi dalam bentuk urutan linear, yang operasi pemasukan dan penghapusan datanya dilakukan pada salah satu sisinya[1]


Definisi 2.


Diberikan suatu himpunan yang terurut himpunan sebagai S = {S1, S2, ……., ST}, T pada anggota S merupakan linear order, sehingga stack dari himpunan tersebut memiliki informasi sebagai berikut [1] :


1. Elemen puncak dari stack dalam himpunan S dikatakan sebagai TOPSleep, sehingga :


TOP[S} = ST ………………………………………………………………….(1)


2. Banyaknya elemen stack dalam himpunan S dikatakan sebagai NOELSleep, sehingga NOELSleep = T, dimana himpunan dari S tersebut dapat disusun sebagai :


S = {S1, S2, ………., SNOEL} ………………………..(2)



1. Suatu stack dalam keadaan kosong akan memiliki informasi NOEL(S) = 0 dan TOP(S)= undefined.


2. Untuk stack yang bukan kosong, maka akan memiliki informasi seperti yang digambarkan di bawah ini dimana informasi yang ada adalah NOEL(S) = 1 dan TOP(S) = Merah


Untuk stack yang berisi lebih dari n jumlah data maka informasi yang ada pada stack tersebut berisikan NOEL(S) = 2 (jika berisi 2 data) dan TOP(S) .


Elemen-elemen yang berada dalam stack tersebut di atas, memiliki prinsip dasar dalam pengoperasiannya yaitu prinsip LIFO (Last In First Out) atau yang masuk paling belakang akan memiliki prioritas untuk keluar paling depan.


Suatu stack dapat digambarkan sebagai suatu array (larik) berdimensi satu yang elemen-elemennya berkisar antara 1 sampai n elemen. Dengan demikian jika suatu stack didefinisikan dengan n elemen maka dapat dikatakan jumlah maksimum dari stack atau NOEL(S) nya adalah n, sehingga penambahan elemen stack yang ke n+1 tidak diperkenankan atau stack tersebut dalam kondisi overflow. Hal tersebut juga berlaku untuk stack dengan nilai minimum yaitu NOEL(S) dari stack dalam kondisi 0, jika dilakukan operasi pengambilan elemen atas stack tersebut akan mengakibatkan stack tersebut dalam kondisi underflow. Dua kondisi tersebut merupakan dasar dalam merancang suatu aplikasi pemrograman komputer.
2. Operasi-operasi Stack


Dalam penggunaannya suatu stack memiliki beberapa operasi yang dapat diterapkan seperti membuat stack, penambahan eleme ke dalam stack, menghapusan elemen dari dalam stack, dan operasi lain yang berhubungan dengan stack tersebut. Adapun operasi-operasi dasar dari suatu stack adalah :


a) Create(Stack)


Operasi Create(Stack) digunakan untuk membuat suatu stack baru dengan nama stack, yang nilai elemen saat stack tersebut dibuat adalah NOEL(S) = 0, TOP(S) = NULL (tidak terdefinisikan)


b) IsEmpty(Stack)


Operasi ini merupakan operasi untuk mencek isi dari suatu stack dalam keadaan kosong atau berisi. Operasi ini memiliki 2 (dua) kondisi boolean yaitu :


a. True jika stack tersebut kosong atau dapat dikatakan NOEL(S) = 0


b.False jika stack tersebut tidak dalam kondisi kosong atau dapat dikatakan NOEL(S) > 0


c) Push(Stack, Elemen)


Operasi ini merupakan operasi untuk menambahkan satu elemen dengan nilai X pada puncak suatu stack, sehingga posisi TOP(S) akan bernilai X, penerapan operasi push pasa suatu stack S akan berakibat overflow jika NOEL(S) dari stack tersebut telah bernilai maksimum.


d) Pop(Stack)


Operasi ini berfungsi untuk menghapus satu elemen dari stack S, sehingga posisi NOEL(S) akan berkurang satu elemen, dan TOP(S) akan berubah. Operasi pop dapat menyebabkan kondisi underflow jika suatu stack S yang berada dalam kondisi minimum dikenakan operasi pop.
3. Notasi Infix dan Postfix


Suatu perhitungan aritmatika biasanya berhubungan dengan operand dan operator. Operand merupakan suatu karakter atau elemen yang nilainya dioperasikan dengan bantuan suatu operator untuik menghasilkan suatu solusi.


Misalkan jika diberikan suatu ekspresi aritmatika 2 * 3, maka elemen ‘dua’ dan elemen ‘tiga’ merupakan operand dari ekspresi tersebut dan elemen ‘*’ merupakan operator perkalian atas dua operand yang menghasilkan suatu solusi. Suatu ekspresi aritmatika dapat dibedakan dalam tiga bentuk notasi perhitungan yaitu :


1) Notasi prefix, jika operator ditempatkan sebelum dua operand


2) Notasi infix, jika operator ditempatkan diantara dua operand


3) Notasi postfix, jika operator ditempatkan setelah dua operand


Dalam penggunaannya, dalam kehidupan sehari-hari notasi infix merupakan notasi aritmatika yang paling banyak digunakan untuk mengekspresikan suatu perhitungan artimatik dibanding dengan dua notasi yang lain, akan tetapi notasi Postfix merupakan notasi yang digunakan oleh mesin kompilasi pada komputer dengan maksud untuk mempermudah proses pengkodean, sehingga mesin kompilasi membutuhkan stack untuk proses translasi ekspresi tersebut.

Searching Java_coding

PENCARIAN (SEARCHING)

        

Operasi pencarian adalah operasi untuk menemukan sebuah nilai (data) di dalam sekumpulan nilai yang bertipe sama. Untuk menemukan nilai yang kita cari, instruksi yang paling penting yang harus dilakukan adalah memeriksa jika nilai yang kita cari sama dengan salah satu nilai dalam kumpulan nilai yang dimaksud. Metode pencarian yang bisa kita pergunakan tergantung dari:

1. Bagaimana urutan nilai-nilai di dalam kumpulan nilai.
2. Bagaimana struktur data yang dipergunakan untuk menyusun nilai-nilai tersebut.

Kita dapat mempergunakan baik metode pencarian beruntun (sequential) maupun metode pencarian biner (binary search), jika:

1. Nilai-nilai tersebut sudah tersusun secara berurutan, dan
2. Nilai-nilai tersebut disusun ke dalam bentuk larik (array) atau struktur data sejenis yang masing-masing nilai tersimpan dalam bagian-bagian yang mempunyai indeks yang unik dan indeksnya berurutan dari yang paling kecil hingga yang paling besar (bersifat ordinal).

Kita dapat mempergunakan metode pencarian beruntun atau linear (sequential search atau linear search) jika:

1. Nilai-nilai tersebut belum berurutan.
2. Nilai-nilai tersebut sudah berurutan, tetapi struktur data yang dipergunakan untuk menyimpan nilai-nilai tersebut adalah senarai.

Berikut ini adalah contoh-contoh implementasi searching pada program Java yang pernah saya buat untuk latihan di kuliah.








Binary Searching

import javax.swing.*;


public class binarySearching
{


    public static void main(String[] args)
    {
     
    int A[]= {10,20,30,40,50,60,70,80,90};
    
    int i=0, n=0, r, x,mid=0;
    boolean ketemu = false;
    
       
       
    x = Integer.parseInt(JOptionPane.showInputDialog( "CARI:"));
      System.out.println("Data yang dicari:  "+ x);
     
    i = 0;
    n = A.length;
    r = n-1;
    


        while (i<=r)
    {
    mid =(i+r)*1/2;
    if (A[mid]== x) 
    {
    ketemu = true;
    break;
    }
    else if(A[mid]>x)
    {
    r = mid-1;
    }
    else
    i = mid+1;
    }
    if (ketemu ==true)
    {
    System.out.println("KETEMU");
    }
    else 
    {
    System.out.println("dak ADOOO...!");
    }
    }
   
   
}








Sequential Searching


import javax.swing.*;
public class seq_Searching 
{
    public static void main(String [] args) 
    {
  int  A[]={30,20,50,70,60,10,90,80,40};

String x_cari;
    int x, ketemu=0;
    x_cari = JOptionPane.showInputDialog ("Cari Data:" );
  x = Integer.parseInt(x_cari);
 
  System.out.println("Cari Data (x):"+ x);
    
    
  for (int i=0;i<9; i++)
  {
  if (A[i]==x)
  {
  ketemu = 1;
break;
  }
  }
      if (ketemu==1)
    {
    System.out.println("KETEMU di INDEX ke-" + i);
  }
  else
  {
  System.out.println("TIDAK KETEMU");
    }
   
  }
    
    
}







Sentinel Searching



import javax.swing.*;
public class sentinel_searching 
{


    public static void main(String [] args) 
    {
 
  String x_cari;
    int x=0, j=0;
     
int  A[]={100,200,500,800,400,300,600,1000,900,x };

        x_cari = JOptionPane.showInputDialog ("Cari Data:" );
  x = Integer.parseInt(x_cari);
  A[9] = x;
  System.out.println("Cari Data (x):"+ x);
  System.out.println("  ");
      
      while (A[j]!=x)
  {
  if (A[j]==x)
    {
      break;
    }
  else
    {
      j = j+1;
    }
 
  }
      
   if (j<9)
   {
   System.out.println("KETEMU DI INDEX KE-" + j);
   JOptionPane.showMessageDialog (null,"PENCARIAN DATA :"+x+"KETEMU DI INDEX KE-" + j);
   }
   else
   {
   System.out.println(" KETEMU di SENTINEL");
   JOptionPane.showMessageDialog (null,"PENCARIAN DATA :"+x+"TIDAK KETEMU(data sentinel)" );
   }
 }
    
    
}

Sorting Algorithm ( Algoritma Pengurutan)

Sorting Algorithm

Sorting dan searching merupakan salah satu operasi dasar dalam ilmu komputer. Sorting merupakan suatu proses (operasi) yang mengurutkan data dalam suatu urutan yang diberikan (increasing atau decreasing). 

Terdapat 2 katagori dasar dalam tehnik sorting : internal sort dan external sort. Metoda Internal sort digunakan apabila koleksi data yang akan diurutkan tidak dalam jumlah besar sehingga proses dapat dilakukan dalam main memory. Metoda External sort digunakan apabila koleksi data yang akan diurutkan dalam jumlah besar dimana koleksi data tersebut ada dalam auxiliary memory device seperti magnetic tape atau disk.

(Yang akan di bahas adalah Internal Sort).

            Misal A merupakan suatu daftar dari n elemen A1, A2, ..., An dalam memori.  Sorting A merupakan operasi yang mengatur elemen dalam A sehingga ada dalam urutan yang terurut, misal dalam increasing order sehingga :

                                                A1  A2  A3  ..... An

Contoh :

            Misal suatu array DATA berisi 8 elemen sebagai berikut :

                                    DATA :                77, 33, 44, 11, 88, 22, 66, 55

           

            Setelah diurutkan  :

           

                                    DATA :                 11, 22, 33, 44, 55, 66, 77, 88

Insertion Sort

            Misal array A dengan n elemen A[1], A[2], ..... , A[N] dalam memori. Algoritma Insertion Sort memeriksa A dari A[1] sampai dengan A[N], menyisipkan setiap elemen A[K] ke dalam posisi yang seharusnya dalam subarray terurut A[1], A[2], ..... , A[K-1].

           

            Algoritma sorting ini umumnya digunakan apabila jumlah elemennya sedikit           (n kecil). Masalah yang akan muncul dengan metoda ini adalah bagaimana cara menyisipkan A[K] ke dalam letak yang seharusnya pada subarray terurut A[1], A[2], ....., A[K-1]. Hal ini dapat dilakukan dengan membandingkan A[K] dengan A[K-1], kemudian A[K] dengan A[K-2], A[K] dengan A[K-3] dan seterusnya, sampai menemukan elemen A[J] dimana A[J] A[K].

Algoritma ini menggunakan sentinel elemen (A[0]) yang digunakan sebagai perbandingan. Yang dimaksud dengan sentinel elemen adalah elemen yang memiliki nilai yang sangat kecil.

Penggambaran proses Insertion Sort :

Proses	A[0]	A[1]	A[2]	A[3]	A[4]	A[5]	A[6]	A[7]	A[8]
K = 1:	-	77	33	44	11	88	22	66	55
K = 2:	-	77	33	44	11	88	22	66	55
K = 3:	-	33	77	44	11	88	22	66	55
K = 4:	-	33	44	77	11	88	22	66	55
K = 5:	-	11	33	44	77	88	22	66	55
K = 6:	-	11	33	44	77	88	22	66	55
K = 7:	-	11	22	33	44	77	88	66	55
K = 8:	-	11	22	33	44	66	77	88	55
Urutan :	-	11	22	33	44	55	66	77	88

           

Tabel 1.1         

Selection Sort

      Array A dengan n elemen A[1], A[2], ....., A[N] dalam memori. Algoritma untuk mengurutkan A sebagai berikut : Pertama, cari elemen terkecil dalam array A dan letakkan pada posisi pertama dalam array tersebut. Kemudian cari elemen kedua terkecil dalam array A dan letakkan dalam posisi kedua dari array tersebut, dan begitu seterusnya.

Proses 1 :  Cari lokasi LOC yang merupakan elemen terkecil dalam array yang

                  terdiri   dari N elemen , A[1], A[2], ...., A[N] dan kemudian tukar posisi

                  A[LOC] dengan A[1].

Proses 2 :  Cari lokasi LOC yang merupakan elemen terkecil dalam array yang

                  terdiri dari N-1 elemen , A[2], A[3], ...., A[N] dan tukar posisi A[LOC]

                  dengan A[2]. A[1] , A[2] terurut, jika dan hanya jika A[1] A[2].

Proses 3 :  Cari lokasi LOC yang merupakan elemen terkecil dalam array yang

                  terdiri dari N-2 elemen, A[3], A[4],......, A[N] dan tukar posisi A[LOC]

                  dengan A[3]. A[1], A[2], A[3] terurut, jika dan hanya jika A[2] A[3].

Dst.................

Sehingga A akan terurut setelah N-1 proses.

Merging

            Misal A merupakan himpunan data terurut dengan r buah elemen dan B himpunan data terurut dengan s buah elemen. Proses yang menggabungkan elemen-elemen dalam A dan B menjadi himpunan elemen data terurut tunggal, misal C dengan n = r + s buah elemen disebut dengan proses Merging.

Secara singkat, proses Merging dapat dijelaskan sebagai berikut ; ambil elemen pertama dari A, A[1] dan B, B[1]. Bandingkan kedua elemen tersebut. Jika A[1] > B[1], B[1] dimasukkan dalam C, jika tidak A[1] dimasukkan dalam C. Untuk himpunan data yang elemennya dimasukkan dalam C, elemen yang akan dibandingkan adalah elemen berikutnya. Dan seterusnya.

Contoh :

            A = 11   12   23   33   45     67

            B = 9     12   21   42

            Disini A[1] = 11 dan B[1] = 9 dibandingkan dan A[1] > B[1], B[1] dimasukkan dalam C. Pembandingan berikutnya A[1] = 11 dibandingkan dengan B[2] = 12, A[1] dimasukkan dalam C, dan begitu seterusnya.

Shell Sort

            Disebut juga dengan metoda pertambahan menurun (diminishing increment). Metoda ini dikembangkan oleh Donald L. Shell tahun 1959. Metoda ini memanfaatkan penukaran sepasang elemen untuk mencapai keadaan urut. Dalam hal ini jarak dua elemen yang dibandingkan dan ditukarkan tertentu.

            Pada langkah pertama, ambil elemen pertama dan kita bandingkan dengan elemen pada jarak tertentu dari elemen pertama tersebut. Kemudian elemen kedua dibandingkan dengan elemen lain dengan jarak yang sama. Demikian seterusnya sampai seluruh elemen dibandingkan.

            Pada contoh berikut, proses pertama kali jarak diambil separoh banyaknya elemen yang akan diurutkan. Proses kedua jaraknya diambil separuh jarak yang pertama, dst....

Misal terdapat elemen sebagai berikut :

                        23        45        12        24        56        34        27        23        16

Proses pengurutan menggunakan metoda Shell ada pada tabel 1.3. Dalam hal ini elemen yang ditulis miring adalah elemen yang dibandingkan dan kemudian ditukar, jika perlu.

  

Jarak	A[1]	A[2]	A[3]	A[4]	A[5]	A[6]	A[7]	A[8]	A[9]
Awal	23	45	12	24	56	34	27	23	16
Jarak = 4	23	45	12	24	56	34	27	23	16
	23	45	12	24	56	34	27	23	16
	23	34	12	24	56	45	27	23	16
	23	34	12	24	56	45	27	23	16
	23	34	12	23	56	45	27	24	16
	23	34	12	23	16	45	27	24	56
Jarak = 2	23	34	12	23	16	45	27	24	56
	12	34	23	23	16	45	27	24	56
	12	23	23	34	16	45	27	24	56
	12	23	16	34	23	45	27	24	56
	12	23	16	34	23	45	27	24	56
	12	23	16	34	23	45	27	24	56
	12	23	16	34	23	24	27	45	56
	12	23	16	34	23	24	27	45	56
Jarak = 1	12	23	16	34	23	24	27	45	56
	12	23	16	34	23	24	27	45	56
	12	16	23	34	23	24	27	45	56
	12	16	23	34	23	24	27	45	56
	12	16	23	23	34	24	27	45	56
	12	16	23	23	24	34	27	45	56
	12	16	23	23	24	27	34	45	56
	12	16	23	23	24	27	34	45	56
	12	16	23	23	24	27	34	45	56
Akhir	12	16	23	23	24	27	34	45	56

Berikut ini adalah beberapa contoh algoritma Sorting:

Pengurutan Sisip (Insertion Sort)

Kamus Lokal
K : integer {pencacah langkah}

J : integer {pencacah untuk penelusuran larik}

Temp : integer {peubah bantu untuk agar L[K] tidak ditimpa selama pergeseran}

       
       ALGORITMA

{elemen L[1] dianggap sudah terurut}

for K ← 2 to N do {mulai dari langkah 2 sampai langkah N}

Temp ← L[K] {ambil elemen L[K] supaya tidak ditimpa pergeseran}

{cari posisi yang tepat untuk L[K] di dalam L[1..K-1] sambil menggeser}

J ← K - 1

while Temp ≤ L[J] AND (J > 1) do

L[J+1] ← L[J]

J ← J-1

endwhile

if Temp ≥ L[J] then

L[J+1] ← Temp

else

L[J+1] ← L[J]

L[J] ← Temp

endif

endfor

Pengurutan Sisip (Insertion Sort)

procedure UrutSisip_Turun(input/output L: Larik, input N : integer)

Kamus Lokal

K : integer {pencacah langkah}

J : integer {pencacah untuk penelusuran larik}

Temp : integer {peubah bantu untuk agar L[K] tidak ditimpa selama pergeseran}

ALGORITMA

{elemen L[1] dianggap sudah terurut}

for K ← 2 to N do {mulai dari langkah 2 sampai langkah N}

Temp ← L[K] {ambil elemen L[K] supaya tidak ditimpa pergeseran}

{cari posisi yang tepat untuk L[K] di dalam L[1..K-1] sambil menggeser}

J ← K - 1

while Temp ≥ L[J] AND (J > 1) do

L[J+1] ← L[J]

J ← J-1

endwhile

{Temp > L[J] or J = 1}

if Temp ≤ L[J] then

L[J+1] ← Temp

else

L[J+1] ← L[J]

L[J+1] ← Temp

endif

endfor

Algoritma Selection Sort

{cari elemen terkecil}

t := i {t adalah index elemen terkecil}

for j := i + 1 to n do

              if l[j] < l[t] then

                     t := j

              endif

endfor

{tukar elemen terkecil dengan elemen i}

       temp := l[j]

       l[j] := l[i]

       l[i] := temp

for i := 1 to n – 1 do

              {cari elemen terkecil}

              t := i {t adalah index elemen terkecil}

              for j := i + 1 to n do

                     if l[j] < l[t] then

                            t := j

                     endif

              endfor

              {tukar elemen terkecil dengan elemen i}

              temp := l[j]

              l[j] := l[i]

              l[i] := temp

endfor

Algoritma Selection Sort

proc UrutPilih (l,n)

{mengurutkan membesar data di dalam larik l yang berelemen sebanyak n dengan cara pemilihan}

for i := 1 to n – 1 do

       {cari elemen terkecil}

       t := i {t adalah index elemen terkecil}

       for j := i + 1 to n do

              if l[j] < l[t] then

                     t := j

              endif

       endfor

       {tukar elemen terkecil dengan elemen i}

              temp := l[j]

              l[j] := l[i]

              l[i] := temp

endfor

Algoritma Shell Sort

Banyak = N

range = banyak / 2

while range <> 0

       counter = 1

       target = banyak-range

while counter<=target

              kiri = counter

              selesai = false

              while selesai=false

                     kanan = kiri+range

if item (kiri)>= item(kanan)

                                  selesai = true

                            else

                                  swap item (kiri) dan

                                  item (kanan)

                                  if kiri > range

                                         kiri = kiri - range

                                  else

                                         selesai = true

                                  end_if

                            end_if

                     end_while

                     counter = counter + 1

               end_while

              range = range / 2

end_while

Pengurutan Gravitasi

procedure UrutGravitasi(input/output L: Larik; input N : integer)

Deklarasi

I : integer {pencacah untuk jumlah langkah}

K : integer {pencacah untuk pemberatan pada setiap langkah}

U : integer {indeks ujung kiri bagian larik yang telah terurut}

Temp : integer {peubah bantu untuk pertukaran}

Algoritma

U ← N

for I ← 1 to N-1 do

for K ← 1 to U-1 do

if L[K] > L[K+1] then {pertukarkan L[K] dengan L[K+1]}

Temp ← L[K]

L[K] ← L[K-1]

L[K-1] ← Temp

endif

endfor

{ larik L[U..N] terurut, larik L[1..U-1] belum terurut }

U ← U - 1

Endfor

Algoritma Pengurutan Maksimum

procedure UrutMaksimum(input/output L: Larik, input N : integer)

Kamus Lokal

I : integer {pencacah untuk jumlah langkah}

J : integer {pencacah untuk mencari nilai maksimum}

U : integer {indeks ujung kiri bagian larik yang telah terurut}

Maks : integer {nilai maksimum sementara}

Imaks : integer {indeks yang berisi nilai maksimum sementara}

Temp : integer {peubah bantu untuk pertukaran}

Algoritma

U ← N

for I ← 1 to N-1 do

Maks ← L[1]

Imaks ← 1

for J ← 2 to U do

if L[J] > L[Imaks] then

Maks ← L[J]

Imaks ← J

endif

endfor

{pertukarkan Maks dengan L[U]}

Temp ← L[U]

L[U] ← L[Imaks]

L[Imaks] ← Temp

{ larik L[U..N] terurut, larik L[1..U-1] belum terurut }

U ← U - 1

endfor

Algoritma Pengurutan Minimum

procedure UrutMin(input/output L: Larik, input N : integer)

Kamus Lokal

I : integer {pencacah untuk jumlah langkah}

J : integer {pencacah untuk mencari nilai minimum}

U : integer {indeks ujung kiri bagian larik yang telah terurut}

Imin : integer {indeks yang berisi nilai minimum sementara}

Temp : integer {peubah bantu untuk pertukaran}

Algoritma

U ← N

for I ← 1 to N-1 do

Imin ← 1

for J ← 2 to U do

if L[J] < L[Imin] then

Imin ← J

endif

endfor

{pertukarkan Maks dengan L[U]}

Temp ← L[U]

L[U] ← L[Imin]

L[Imin] ← Temp

{ larik L[U..N] terurut, larik L[1..U-1] belum terurut }

U ← U - 1

endfor