Owl, Owl Belgesi Yazma (2)

Equivalent Class, Equivalent Property

<owl:class rdf:id="TexasThings">
  <owl:equivalentclass>
      <owl:restriction>
          <owl:onProperty rdf:resource="#locatedIn"/>
          <owl:someValuesFrom rdf:resource="#TexasRegion"/>
       </owl:restriction>
   </owl:equivalentclass>
</owl:class>

sameAs

<Wine rdf:Id="MikesFavouriteWine">
  <owl:sameAs  rdf:resource="#StGenevieveTexasWhite"/>
</Wine>

İndividuals'lar arasındaki eşitliği gösteriyor.

DifferentFrom, allDifferent Individuals

<WineSugar rdf:Id="Dry"/>

<WineSugar rdf:Id="Sweet">
  <owl:differentFrom rdf:resource="#Dry"/>
</WineSugar>

<owl:Alldifferent>
  <owl:distinctMembers rdf:parseType="Collection">
   <vin:WineColor  rdf:about="#Red"/>
   <vin:WineColor rdf:about="#White"/>
  </owl:distinctMembers>
</owl:Alldifferent>

Intersection-OWL-DL
Kesişimini alır. hasColor özelliği White olan şaraplara WhiteWine denilsin.

<owl:Class rdf:Id="WhiteWine">
  <owl:IntersectionOf  rdf:parseType="Collection">
    <owl:Class rdf:about="#Wine"/>
      <owl:restriction>
          <owl:onProperty rdf:resource="#hasColor"/>
          <owl:hasValue  rdf:resource="#White"/>
      </owl:restriction>
  </owl:restriction>
</owl:Class>

Union-Owl-Dl
Birleşimi ifade ediyor. SweetFruit ve NonSweetFruit'in birleşimi Fruit oluyor.

<owl:Class rdf:Id="Fruit">
  <owl:unionOf rdf:parseType="Collection">
     <owl:Class rdf:about="#SweetFruit">
     <owl:Class  rdf:about="#NonSweetFruit">
   </owl:unionOf>
</owl:Class>

Complement-Owl-Dl
Olumsuzluk katıyor.

<owl:Class rdf:Id="ConsumableThing"/>

<owl:Class rdf:Id="NonConsumableThing">
  <owl:complemetOf  rdf:resource="#ConsumableThing"/>
</owl:Class>

oneOf-owl-dl
Şarap rengi bu üç renkten biridir.

<owl:Class rdf:Id="WineColor">
  <rdfs:subClassOf  rdf:resource="#WineDescriptor"/>
    <owl:oneOf rdf:parseType="Collection">
       <owl:Thing  rdf:about="#White"/>
       <owl:Thing rdf:about="#Rose"/>
      <owl:Thing rdf:about="#Red"/>
   </owl:oneOf>
</owl:Class>

disjointWith  -owl-dl
Ayırma işlemi yapıyoruz. Pasta sınıfı bunlardan biri olamaz.

<owl:Class rdf:Id="Pasta">
   <rdfs:subClassOf rdf:resource="#EdibleThing"/>
     <owl:disjointWith rdf:resource="#Meat"/>
     <owl:disjointWith rdf:resource="#Fowl"/>
     <owl:disjointWith rdf:resource="#SeaFood"/>
     <owl:disjointWith rdf:resource="#Fruit"/>
</owl:Class>

Java'da Taban Çevirme Programı

Test isimli main sınıfımız:

public class Test {
	public static void main(String[] args) {
		System.out.println(TabanCevir.tabanCevir(12121, 8));
	}
}

İşlemlerin yapıldığı TabanCevir isimli sınıfımız:

public class TabanCevir {
public static String reverse(String deger)
{
	String sonuc = "";
	for (int i = deger.length(); i >0; i--) 
   {
	sonuc += deger.substring(i-1, i);
    }
	return sonuc;
}
static int i=0;
static String cevrilenString="";
public static String tabanCevir(int sayi, int cevTaban)
{
	if(cevTaban < 2 || cevTaban > 16)
	{
		return "Taban 2-16 arasinda olmali";
	}
else if(sayi < cevTaban)
{
	cevrilenString+=sayi;
	return reverse(cevrilenString);
}
else
{
	while(true)
	{
		if(sayi < cevTaban)
		{
			cevrilenString+=sayi;
			break;
		}
else if(sayi > cevTaban && cevTaban > 10)
			{
			sayi = OndanBuyukTaban(sayi, cevTaban);

			}
else{
			cevrilenString+=sayi%cevTaban;
			sayi=sayi/cevTaban;
		}
	}
	if(i==1)
	{
		return cevrilenString;
	}
	return reverse(cevrilenString);
	}
}
private static int OndanBuyukTaban(int sayi, int cevTaban) {
		if(sayi/cevTaban==10)
		{
			cevrilenString+="a";
			sayi=sayi%cevTaban;
			i=1;
		}else if(sayi/cevTaban==11)
		{
			cevrilenString+="b";
			sayi=sayi%cevTaban;
			i=1;
		}else if(sayi/cevTaban==12)
		{
			cevrilenString+="c";
			sayi=sayi%cevTaban;
			i=1;
		}else if(sayi/cevTaban==13)
		{
			cevrilenString+="d";
			sayi=sayi%cevTaban;
			i=1;
		}else if(sayi/cevTaban==14)
		{
			cevrilenString+="e";
			sayi=sayi%cevTaban;
			i=1;
		}else if(sayi/cevTaban==15)
		{
			cevrilenString+="f";
			sayi=sayi%cevTaban;
			i=1;
		}else{
			sayi = OndanKucukTaban(sayi, cevTaban);

		}
		return sayi;
	}
	private static int OndanKucukTaban(int sayi, int cevTaban) {
		if(sayi%cevTaban==10)
		{
			cevrilenString+="a";
			sayi=sayi/cevTaban;
			i=0;
		}else if(sayi%cevTaban==11)
		{
			cevrilenString+="b";
			sayi=sayi/cevTaban;
			i=0;
		}else if(sayi%cevTaban==12)
		{
			cevrilenString+="c";
			sayi=sayi/cevTaban;
			i=0;
		}else if(sayi%cevTaban==13)
		{
			cevrilenString+="d";
			sayi=sayi/cevTaban;
			i=0;
		}else if(sayi%cevTaban==14)
		{
			cevrilenString+="e";
			sayi=sayi/cevTaban;
			i=0;
		}else if(sayi%cevTaban==15)
		{
			cevrilenString+="f";
			sayi=sayi/cevTaban;
			i=0;
		}
		else{
		cevrilenString+=sayi%cevTaban;
		sayi=sayi/cevTaban;
		i=0;
		}
		return sayi;
	}
}

Owl, Owl Belgesi Yazma (1)

OWL yazımına başlamadan önce hangi tür kelimelerin kullanılacağı tanımlanmalı.Bu tanımlar XML-Namespace düzeninde yapılmalıdır.
OWL’nin en önemli özelliği birçok veriyi dağıtık ortamlardan toplayabilir ve bunlarla ilgili çıkarsama yapabilir.

Ontoloji genel olarak; sınıflar, sınıflara ait özellikler, sınıfa ait örnekler ve bu örneklerin kendi aralarındaki ilişkilerini göstermektedir.

Owl yazımına başlayalım.

Sınıf Tanımlamaları

owl:thing  = Owl’de her sınıfın ait olduğu üst sınıftır.
owl:Nothing = OWL tarafından boş sınıf olarak tanımlanmaktadır.

Sınıf tanımlamasına örnek verelim:

<owl:class rdf:id="Magaza"/>
<owl:class rdf:id="Kullanici"/>

Burada Magaza ve Kullanici isminde sınıf tanımlamış olduk.

Rdf:ID = Sınıf isimlerinin tanımlandığı alandır.

-rdfs:subClassOf
Alt sınıf tanımlamak için kullanılır.

<owl:class  rdf:id="Musteri">
<rdfs:subclassof  rdf:resource="#Kullanici"/>
….
</owl:class>

Individuals
Bir sınıfa ait üyelerin tanıtılmasıdır.

<musteri rdf:id="Musteri1"/>

<owl:thing rdf:id="Musteri1"/>
<owl:thing rdf:about="#Musteri">
<rdf:type rdf:resource="Musteri"/>

Musteri sınıfına ait bir Musteri1 isminde bir üyeyi iki şekilde tanımladık.

Özelliklerin Tanımlanması

Datatype Properties: Daha çok nicelik tanımlamasıdır. Örneğin; Tip tanımlaması.
<owl:datatypeproperty rdf:id="Adi">
   <rdfs:domain rdf:resource="#Kullanici"/>
   <rdfs:range rdf:resource="&xsd;string/">
</owl:datatypeproperty>

Object Properties: Daha çok nitelik tanımlanamasıdır. Örneğin iki sınıf arasındaki bağlantı.
<owl:objectproperty rdf:id="sahiptir">
    <rdfs:domain rdf:resource="#Kullanici/">
    <rdfs:range rdf:resource="#Urunler"/>
</owl:objectproperty>

Restrictions
<owl:class rdf:about="#mathCourse">
   <rdfs:subclassof>
      <owl:restriction>
           <owl:onproperty rdf:resource="#isTaughtBy"/>
           <owl:hasvalue rdf:resource="#949318"/>
      </owl:restriction>
   </rdfs:subclassof>
</owl:class>

Bu örneğimizde matematik kursuna bir kısıtlama getirmişiz. Bu ders sadece 949318 numaralı kişi tarafından öğretilir.

Transitive Özellik
<owl:ObjectProperty rdf:ID="locatedIn">
  <rdf:type rdf:resource="&owl;TransitiveProperty"/>
     <rdfs:domain rdf:resource="&owl;Thing"/>
     <rdfs:range rdf:resource="#Region"/>
</owl:ObjectProperty>

Symmetric Özellik
<owl:ObjectProperty rdf:ID="adjacentRegion">
   <rdf:type rdf:resource="&owl;SymmetricProperty"/>
   <rdfs:domain rdf:resource="#Region"/>
   <rdfs:range rdf:resource="#Region"/>
</owl:ObjectProperty>

Functional Özellik
<owl:ObjectProperty rdf:ID="husband">
   <rdf:type rdf:resource="&owl;FunctionalProperty"/>
   <rdfs:domain rdf:resource="#Woman"/>
   <rdfs:range rdf:resource="#Man"/>
</owl:ObjectProperty>

Woman sadece bir Man'e sahip olabilir.

Inverse Functional Özellik
<owl:ObjectProperty rdf:ID="has social security number">

   <rdf:type rdf:resource="&owl;InverseFunctionalProperty"/>

   <rdfs:domain rdf:resource="#Person"/>

   <rdfs:range rdf:resource="#SocialSecurityNumber"/>

</owl:ObjectProperty>

İki farklı nesne aynı social security number'a sahip olamaz.

InverseOf Özellik

<owl:ObjectProperty rdf:ID="hasChild">

   <owl:inverseOf  rdf:resource=#hasParent"/>

</owl:ObjectProperty>

hasChild, hasParent birbirinin tersidir. 

allValuesFrom,someValuesFrom Özelliği

<owl:Class rdf:ID="Wine">

  <rdfs:subClassOf  rdf:resource="food;PotableLiquid"/>

  ...

  <rdfs:subClassOf>

       <owl:Restriction>

            <owl:onProperty rdf:resource="#hasMaker"/>

            <owl:allValuesFrom rdf:resource="#Winery"/>       

</owl:Restriction>

</rdfs:subClassOf>

....

</owl:Class>

<owl:Class rdf:ID="Wine">

  <rdfs:subClassOf  rdf:resource="food;PotableLiquid"/>

  ...

  <rdfs:subClassOf>

       <owl:Restriction>

            <owl:onProperty rdf:resource="#hasMaker"/>

            <owl:someValuesFrom rdf:resource="#Winery"/>       

</owl:Restriction>   

</rdfs:subClassOf>

....

</owl:Class>

hasValue Özellik

<owl:Class rdf:ID="Burgundy">

...

  <rdfs:subClassOf>

      <owl:Restriction>

         <owl:onProperty  rdf:resource="#hasSugar"/>

         <owl:hasValue rdf:resource="#Dry"/>

       </owl:Restriction>

   </rdfs:subClassOf>

</owl:Class>

Devamı ikinci kısımda anlatılacaktır.

XML'e Giriş, XML Schema

Xml (Genişletilebilir İşaretleme Dili); hem insanlar, hem bilgi işlem sistemleri tarafından kolayca okunabilecek dökümanlar oluşturmaya yarayan bir standarttır. Farklı sistemler arasında veri alış verişi yapmaya yarayan ara bir format görevi de görür.

Xml, üst veri (meta data) ortamı için standart bir gösterim sunar. Veri ve belge için ortak yapısal standartlar sunar. Uygulama bağımsız veri ve belge yaratmaktadır.

Xml dökümanları, ağaç veri yapısında olurlar.Bağımsız imler yapıyı oluştururken, içerik ya imin özelliği olarak ya da iki imin arasında gösterilir. Yapıyla ilgili ayrıntılar DTD (Document type definition) ya da XML Schema adı verilen harici dökümanlar ile tanımlanır.

Xml Schema, Xml dökümanlarının yapı ve içerik elemanlarını düzenlemeye yarayan bir dildir.
Xsd (XML Schema Definition), Xml dosyalarında taşınan verilerin nasıl yorumlanacağını tanımlayan dosya. Xsd, Dtd'nin eksikliklerini gidermek üzere geliştirilmişlerdir.

Xml dilinin kullanılmasıyla, veri sadece sınıflandırılabilmekte ve bu tür sınıflandırılmış veriler sadece insanların yorumlama yetenekleriyle anlamlı hale gelmektedir. Bu noktada verilerin yapısallığının son derece düşük olması Xml'in eksi yanlarındandır.

Ontoloji (Ontology), Ontoloji Mühendisliği

Ontoloji daha çok felsefe alanında kullanılan bir terimdir. Felsefede varlık bilim olarak tanımlanır. Bilgisayar biliminde ise ontolojiler semantic web’in gerçekleştirilmesinde kullanılan anahtar teknolojidir. Doksanlı yıllarda yapay zeka alanında popüler bir terim olarak belirli bir alandaki bilgilerin paylaşımını ve yeniden kullanımını sağlayacak “kavramlaştırmaların biçimsel ve açık belirtimi“ olarak tanımlanmış ve kullanılmıştır. Son zamanlarda ontolojilerin kullanımı zeki bilgi entegrasyonu, elektronik ticaret, doğal dil işleme ve bilgi yönetimi konularında daha çok yaygın hale gelmektedir.

Ontolojiler, ontoloji dilleri (RDFS, DAML+OIL, OWL, ..) ile tanımlanır.Bunları daha sonra inceleyeceğiz. Ontoloji geliştirme araçları (editörleri) ontolojilerin görsel olarak kolayca tanımlanmasını sağlar. Bir çok alan için değişik ontoloji dillerinde ontolojiler geliştirilmektedir. (www.daml.org/ontologies)

Ontoloji Mühendisliği: Ontoloji geliştirme süreci, ontoloji yaşam döngüsü, ontoloji yapılandırma için metotlar ve metodolojiler, tüm bunları destekleyen araç aileleri ve dilleri ile bağlantılı tüm etkinlikler ile ilgili bir çalışma alanıdır.

Ontoloji Mühendisliği; bilgi mühendisliği, yapay zeka, bilgisayar bilimleri, yazılım mühendisliği ile ilgili bir mühendisliktir. Bilgi yönetimi, doğal dil işleme, e-ticaret, zeki bilgi bütünleştirme, bilgi elde edimi, veritabanlarının bütünleştirimi, biyo-bilişim, eğitim ve benzeri uygulama alanları vardır.

Semantic Web (Anlamsal Ağ)

Web üzerinde aranılan bilgiye ulaşmak gün geçtikçe bir hayli zorlaşmaktadır. Neden olarak şunları söyleyebiliriz:
-Web üzerinde bulunan bilgilerin yapılandırılmış olmaması.
-Dinamik ve dağıtık bir ortam olması.
-Hızlı bir şekilde büyümesi.

Semantic Web, web içeriklerinin sadece doğal dillerde değil, aynı zamanda ilgili yazılımlar tarafından kullanılabilir, anlaşılabilir ve yorumlanabilir bir şekilde ifade edilebileceği, böylelikle bu yazılımların veriyi kolayca bulmasını, birleştirmesini, paylaşmasını sağlamayı amaçlayan, bir internet eklentisidir.

Semantic Web(Anlamsal Ağ)'deki temel amaç; iyi tanımlanmış ve ilişkilendirilmiş bilgilerin web ortamında kolayca, bilgisayar tarafından okunabilir ve anlaşılabilir olmasını sağlayacak standartların ve teknolojilerin geliştirilmesidir.

Semantic Web'in uygulama alanları :

Anlam tabanlı web arama makineleri
Anlam tabanlı sayısal kütüphaneler
Yazılım ajanı tabanlı dağıtık işlem uygulamaları
Ontoloji destekli kurumsal bilgi yönetimi
Otomatik web servisi keşfi, aktive edilmesi, karşılıklı işleyebilirliği ve izlenebilirliği

Binary Trees ( Ağaçlar )

Ağaçlar; lineer olmayan belirli niteliklere sahip iki boyutlu veri yapılarıdır. Bağlı listeler, yığıtlar ve kuyruklar gibi doğrusal bir veri yapısı değildir. İkili ağaçlar (Binary Trees) düğümlerinde en fazla iki bağ içerir ve sol düğüm root'dan küçük ve sağ düğüm root'dan her zaman büyüktür.

İkili ağaç yapısını Java kodu ile örneklendireceğim. Bu kodda ikili ağaca ait bir çok özellik ve fonksiyon mevcut.

class Tree
{
private TreeNode root;
int h1 = 0,h2=0;
public Tree()
{ 
root = null; 
}
public TreeNode getRoot()
{ 
return root; 
}



int dugumsayisi(TreeNode p)    //Ağaçtaki node sayısını bulur
{
if(p==null)return 0;
if(p.leftChild!=null)
{
h1=dugumsayisi(p.leftChild);
}
if(p.rightChild!=null)
{
h2=dugumsayisi(p.rightChild);
}
return(max(h1,h2)+1);
}


private int max(int h1, int h2) {
if(h1>h2)return h1;
return h2;
}


public void preOrder(TreeNode localRoot)    //Önce kök sonra left child
{                                           //Son olarak right child taranır
if(localRoot!=null)
{
localRoot.displayNode();
preOrder(localRoot.leftChild);
preOrder(localRoot.rightChild);
}
}

public void inOrder(TreeNode localRoot)     //Önce left child sonra kök
{                                           //Son olarak right child taranır
if(localRoot!=null)                       //Aynı zamanda ağacı sıralı bir şekilde yazar
{
inOrder(localRoot.leftChild);
localRoot.displayNode();
inOrder(localRoot.rightChild);
}
}

public void postOrder(TreeNode localRoot)      //Önce left child
{                                              //Sonra right child
if(localRoot!=null)                          //Son olarak kök taranır
{   
postOrder(localRoot.leftChild);
postOrder(localRoot.rightChild);
localRoot.displayNode();
}
}


public void insert(int yenidata)            //Ağaca eleman ekleme
{
TreeNode yeniNode = new TreeNode();
yeniNode.data = yenidata;
if(root==null)
root = yeniNode;
else
{
TreeNode current = root;
TreeNode parent;
while(true)
{
parent = current;
if(yenidata < current.data)
{
current = current.leftChild;
if(current==null)
{
parent.leftChild=yeniNode;
return;
}
} 
else
{
current = current.rightChild;
if(current==null)
{
parent.rightChild=yeniNode;
return;
}
}
}   
}
}



int derinlik(TreeNode root)              //Ağacın derinliğini hesaplama
{ 
if (root==null) 
{ 
return -1; 
} 
else { 
int lDepth = derinlik(root.getLeftChild()); 
int rDepth = derinlik(root.getRightChild());
if (lDepth > rDepth)
return(lDepth+1); 
else return(rDepth+1); 
} 
}




public int minValue() { 
return( minValue(root) ); 
} 

private int minValue(TreeNode node) { 
TreeNode current = node; 
while (current.getLeftChild() != null) { 
current = current.getLeftChild(); 
}
return(current.getData()); 
}





public int maxValue() { 
return( maxValue(root) ); 
} 


private int maxValue(TreeNode node) { 
TreeNode current = node; 
while (current.getRightChild() != null) { 
current = current.getRightChild(); 
}
return(current.getData()); 
}






static void lookup(TreeNode node, int target)    //Ağaçta arama
{ 
if (node == null) 
{ 
return; 
} 
else 
{ 
if (target == node.getData()) 
System.out.println(node.getData()+"bulundu"); 
else { 
if (target < node.getData()) lookup(node.getLeftChild(), target); 
else lookup(node.getRightChild(), target); 
} 
} 
}


public boolean isBST() {        //Ağaç ikili ağaç mı?
return(isBST(root)); 
}

private boolean isBST(TreeNode node) 
{ 
if (node==null) return(true);
if (node.leftChild!=null && maxValue(node.leftChild) > node.data) 
return(false); 
if (node.rightChild!=null && minValue(node.rightChild) <= node.data) 
return(false);
return( isBST(node.leftChild) && isBST(node.rightChild) ); 
} 


public boolean sameTree(Tree other) {      //İki ağaç eşit mi?
return( sameTree(root, other.root) ); 
}

boolean sameTree(TreeNode a, TreeNode b) 
{ 
if (a==null && b==null) 
return(true);
else if (a!=null && b!=null) 
{ 
return( a.data == b.data && 
sameTree(a.leftChild, b.leftChild) && 
sameTree(a.rightChild, b.rightChild) 
); 
} 
else return(false); 
} 

} 

Merge Sort (Birleştirmeli Sıralama)

Merge Sort (Birleştirmeli Sıralama), divide and conquere yaklaşımına sahip bir sıralama algoritmasıdır. Yani elimizdeki diziyi sonuna kadar parçalar ve sonrasında birleştiririz.

Bu algoritmanın adımlarını şu şekil ifade edebiliriz.
1-Sıralı olmayan listeyi ortadan eşit olarak iki alt listeye ayır .(Bu adım liste ikiye ayrılmayana dek devam eder.)
2-Alt listeleri kendi içinde sırala.
3-Sıralı iki alt listeyi tek bir sıralı liste olacak şekilde birleştir.

Bir sayı dizisi üstünde örneklendirecek olursak;
Dizimiz : 45-56-28-18-72-14-23-32

[45-56-28-18]  [72-14-23-32]                       //Dizimizi ikiye ayırdık
[45-56]  [28-18]  [72-14]  [23-32]                 //Tekrar ikiye ayırıyoruz.
[45] [56] [28] [18] [72] [14] [23] [32]            //Dizimiz parça parça oldu.
 \          /   \        /    \         /    \        /    
 [45-56]   [18-28]   [14-72]    [23-32]           //İkili ikili sıralı bir şekilde birleştirmeye başlıyoruz.
  \                      /        \                    /
  [18-28-45-56]        [14-23-32-72]              //Yeniden sıralı bir şekilde birleştirme yapıyoruz.
   \                                                 /
      [14-18-23-28-32-45-56-72]                   // Tüm diziyi sıralı bir şekilde birleştiriyoruz.


Bu algoritma recursive şekilde gerçeklenir.
Merge sort sıralama algoritmasının java kodu aşağıdaki şekilde olur.

public static void mergeSort(int array[],int lo, int n){
int bas = lo;
int son = n;
if (bas >= son) {
return;
}
int middle = (bas + son) / 2;
mergeSort(array, bas, middle);
mergeSort(array, middle + 1, son);
int basinSonu = middle;
int sonunBasi = middle + 1;
while ((bas <= basinSonu) && (sonunBasi <= son)) {
if (array[bas] < array[sonunBasi]) {
bas++;
} else {
int Temp = array[sonunBasi];
for (int k = sonunBasi- 1; k >= bas; k--) {
array[k+1] = array[k];
}
array[bas] = Temp;
bas++;
sonunBasi++;
}
}
}    

Kolay gelsin.

Selection Sort(Seçmeli Sıralama)

Selection Sort(Seçmeli Sıralama) algoritmasını anlatmaya çalışacağım.

Selection Sort algoritması; sıralı olmayan dizi içinden ilk elemanı, dizinin en küçüğü kabul eder ve her iterasyonda dizinin diğer elemanlarıyla karşılaştırma yapar. Böylelikle dizinin en küçük elemanı bulunur ve ilk elemanla yer değiştirir. Daha sonra ikinci eleman ele alınır, yine aynı şekilde bu eleman dizinin en küçük elemanı kabul edilir ve her iterasyonda dizinin diğer elemanlarıyla karşılaştırılarak, kalan dizide en küçük eleman bulunmuş olur.Bulunan sayı ikinci elemanla yer değiştirir. Bu döngü dizinin sonuna dek devam eder. Böylece dizi sıralanmış olur.

Örnek verecek olursak:
En basitinden dizimizin ilk hali şu şekil olsun.
8-12-10-4-11
1.iterasyon: 4-12-10-8-11 //4 ile 8 yer değiştirdi
2.iterasyon: 4-8-10-12-11 //8 ile 12 yer değiştirdi
3.iterasyon: 4-8-10-12-11 //10 yer değiştirmedi
4.iterasyon: 4-8-10-11-12 //11 ile 12 yer değiştirdi


Bu algoritmayı java ile kodlayacak olursak:

public void selectionSort(int[] arr) { 
int i, j, minIndex, tmp;       
int n = arr.length;       
for (i = 0; i < n - 1; i++) {   
minIndex = i;               
for (j = i + 1; j < n; j++)
if (arr[j] < arr[minIndex])
minIndex = j;
if (minIndex != i) {
tmp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = tmp;
}
}
}