//Quick sort alghoritması ortalama zamanda n(log n)
//de çalışan büyük arrayler için çok iyi sonuçlar
//veren bir sıralama algoritmasıdır.
public static void quicksort(int array[],int left,int right){
   	//Başta verilen left ve right değerlerini geçici olarak 
   	//tutabilmek için l ve r'ye atıyoruz. Aynı zamanda array'
   	//in içinde yer değiştirmeler içinde temp adlı değişkeni
   	//kullanıyoruz.
   	int l = left,r=right,temp;
   	//pivot olarak baştaki elemanı seçiyoruz
   	int pivot = array[left];
   	//partition algorithm
   	//Bu bölümde arrayimizi 2 ye ayırıyoruz
   	//Birinci bölümde pivottan küçük olanları,
   	//ikinci bölümde ise pivottan büyük elemanları
   	//tutuyoruz. 
   	while(r>=l){
   		//l değişkenini pivottan daha büyük bir eleman
   		//karşımıza çıkana kadar artırıyoruz.
   		while(pivot>array[l])
   			l++;
   		//r değişkenini pivottan daha küçük bir eleman
   		//karşımıza çıkana kadar azaltıyoruz.
   		while(pivot<array[r])
   			r--;
   		//Eğer sol tarafta pivottan daha büyük ve sağ
   		//tarafta pivottan daha küçük bir elemanla
   		//karşılaşırsak bunları temp değişkeni 
   		//yardımıyla yer değiştiriyoruz.
   		if(r>=l){
   			temp = array[r];
   			array[r] = array[l];
   			array[l] = temp;
   			//arrayin bir sonraki elamanına 
   			//ulaşabilmek için sol tarafta l'yi 
   			//artırırken  r'yi de azaltıyoruz.
   			l++;r--;
   		}
   		//En dıştaki loop sayesinde birinci grupta hep
   		//pivottan küçükleri ikinci grupta da pivottan
   		//hep büyükleri toplamış oluyoruz.
   	}
   	//Eğer l right kadar büyük olmuşsa veya right'tan 
   	//küçükse bu büyük grupta sıralanabilecek sayılar
   	//olabileceğini gösterir. Dolayısıyla 2. grup için
   	//quick sort tekrar çağrılır. 1. grup için se l değiş
   	//keninin solunda kalan kısım kullanılır. Onun için de
   	//aynı şekilde quick sort çağrılır.
   	if(right>=l){
   		quicksort(array,l,right);
   		quicksort(array,left,l-1);
   	}
}

//**************************************************************
// Link list representation in Java. 
//**************************************************************
public class LinkList{
   static Node list;
   static int size = 0;
   public void add(String str){
	// Yeni bir node oluşturuyoruz
	Node node = new Node(str);
	Node current=null;
	if(list==null)
	     list = node;
	 else{
	     //Listenin sonuna yeni nodumuzu eklemek için
	     //Listenin sonuna kadar while loop u ile gidiyoruz
	     //Sonuna geldiğimizde ise next i ni node yaparak
	     //eklemiş oluyoruz.
	     current = list;
	     while(current.next !=null)
	     current = current.next;
	     current.next = node;
	}
	size++;
    }
    public void delete(int index){
	Node current = list;
	//Silinecek olan nodun bir öncesine gidebilmek için
	for(int i=0;i<index-1;i++)
	    current = current.next;
	//Buda nodu atlayarak silmek için
	current.next = current.next.next;
	size--;
    }
    public void insert(int index,String str){
	Node node = new Node(str);
	Node current = list;
	if(index==0){
	    node.next = current;
	list = node;
    }
    else{
	//Insert edilecek yerin bir öncesine gidebilmek için
	for(int i=0;i<index-1;i++)
	    current = current.next;
	//Insert edilecek nodu orada başka bir node olduğu için 
	//bunu geçici olarak başka bir node la tutmalıyız
	//Onun için temp adında geçici bir Haha node
	// oluşturup current.next e eşitliyoruz.
	Node temp = current.next;
	//Current.next e yeni objemizi arayarak istediğimiz
	// index insert etmiş oluyoruz
	current.next = node;
	//temp ile tuttuğumuz kalanlarıda current.next.next'e
	// eşitleyecek olursak ki
	// bir sonraki elemana kalanı atamış olucaz
	current.next.next= temp;
     }
	size++;
   }
   public String toString(){
	//Nodeları tek tek gezip yazması için yaptığımız
	//bir while loop u
	Node current = list;
	String str = "";
	if(current==null)
	    return str;
	else{
	    //her seferinde bir sonrakinin null olup olmadığına
	    //bakıp bulunduğumuz nodu yazdırıyoruz.
	    while(current.next!=null){
		str += current.haha+"\t";
		current = current.next;
	    }
	     str += current.haha+"\t";
        }
        return str;
    }
    public class Node{
        //Node objesi
        //Haha class ının objesini kullanıyor
        Node next;
        Haha haha;
       public Node(String str){
	   haha = new Haha(str);
	   next = null;
       }
    }
    public class Haha{
       //Bir Haha objesi
       String haha = "";
       public Haha(String str){
           haha = str;
       }
    }
}

//*****************************************************************
// We simply introduce Selection Sort
//*****************************************************************
import java.util.Random;
public class SelectionSort{
    public static void main(String [] HAHA){
	//Create an object of random class
	Random generator = new Random();
	//Creating an integer array of size 10
	int list [] = new int [10];
	//Putting random numbers into the array we've created
	for(int i=0;i<10;i++)
	    list[i] = generator.nextInt(1000);//We put 1000
	    //because we want integers range from 0 to 1000
	for(int i=0;i<list.length-1;i++){
	     int location = i;//To specify the location of the loop
	     int max = list[i];//We specify the maximum number
	     //We choose the arrays ith element since it can be the
	     //maximum number.
	     for(int j=i;j<list.length;j++){
		 //We compare max and list[j] if max is less we make
		 //it the list[j] because we want maximum element
		 if(list[j]>max){
		      max = list[j];
		      location = j;
		 }
	     }
	     //We create a temprorary integer in order not to lose the
	     //data in list[i] then we change the data between them.
	     int temp = list[i];
	     list[i] = list[location];
	     list[location]= temp;
	}
	//We simply list the array
	for(int i=0;i<list.length;i++)
	    System.out.println(list[i]+"\t");
    }
}